From dccd493277c1adb71a3aefe3b4f2513e13e14206 Mon Sep 17 00:00:00 2001 From: ktsaou <2662304+ktsaou@users.noreply.github.com> Date: Mon, 14 Sep 2026 09:12:04 +0000 Subject: [PATCH 01/20] fix(qwen): alias minimal effort to low --- docs/qwen-effort-alias.md | 23 +++--- .../0015-qwen-flash-next-effort-alias.patch | 8 +- provenance/qwen-effort-alias-review.json | 20 +++-- provenance/qwen-effort-alias.json | 6 +- .../responses-compat-runtime-files.json | 2 +- provenance/responses-compat.json | 2 +- .../srt/entrypoints/openai/serving_chat.py | 6 +- tests/runtime_qwen_effort_alias.py | 76 ++++++++++++++----- 8 files changed, 96 insertions(+), 47 deletions(-) diff --git a/docs/qwen-effort-alias.md b/docs/qwen-effort-alias.md index 54bebe6..53775fe 100644 --- a/docs/qwen-effort-alias.md +++ b/docs/qwen-effort-alias.md @@ -1,6 +1,6 @@ # Qwen Flash-Next effort aliases — candidate, not deployed -This source-only candidate is based on main `b8e8bebf2274e0099c3abce5718ac8813dd9001d` +This source-only candidate is based on main `93463c3466b0de9d21776fbeff95657285df8269` and the published Chat precedence image `kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404`. No image was built/published and no production settings or checkpoint files were changed. @@ -12,8 +12,9 @@ of the deployed image from the candidate runtime overlay. Only loaded `hf_config.model_type` equal to `qwen3_8_flash_next` or `qwen3_8_flash_next_text` opts in. A client `model` name cannot opt another -checkpoint in. `high` and `max` deliberately render as `xhigh`; case/whitespace -variants are not repaired. Other models retain native `high` behavior. +checkpoint in. `minimal` deliberately renders as `low`; `high` and `max` +deliberately render as `xhigh`. Case/whitespace variants are not repaired. +Other models retain their native effort behavior. Precedence: nonnull `chat_template_kwargs.reasoning_effort`, then nonnull request effort, then server default. The production server default stays @@ -35,6 +36,9 @@ are not aliased. No extra logging, prompt capture, or checkpoint template rewrit - Responses `/v1/responses`: `reasoning.effort` and nested template kwargs via the actual non-Harmony `_make_request` conversion. This Qwen-specific path also fixes request effort being hidden by the medium server default. +- Anthropic `/v1/messages`: `output_config.effort` through the actual Anthropic + request conversion and the shared Chat renderer. Anthropic `xhigh` first + becomes the OpenAI-compatible literal `max`, then renders as Qwen `xhigh`. - `/v1/tokenize` with messages: actual `_tokenize_chat_request` path. - Text-only and multimodal prompt rendering branches share normalization; CPU tests cover rendered multimodal text, not image encoding/inference. @@ -42,10 +46,11 @@ are not aliased. No extra logging, prompt capture, or checkpoint template rewrit and are not normalized. Harmony/custom encoders and other model families are outside this patch. No HTTP server or GPU inference validation is claimed. -**Schema finding:** the exact published base already accepts `max` in -`ReasoningEffortTier`, Chat and `ResponseReasoningParam`. Both imported request -classes were exercised. No schema widening or global alias is needed. The -failure in this runtime is the unchanged Qwen template rejecting high/max. +**Schema finding:** the exact published base already accepts `minimal`, `high`, +and `max` through the Chat and Responses request models; Anthropic +`output_config.effort` also accepts them. The imported request classes were +exercised. No schema widening or global alias is needed. The failure in this +runtime is the unchanged Qwen template rejecting minimal/high/max. ## Reproduction @@ -64,8 +69,8 @@ QWEN_TOKENIZER_PATH=/absolute/scratch/tokenizer bash scripts/test_qwen_effort_al The runner requires the published image locally, forbids pulling/network, mounts the repository and tokenizer read-only plus a read-only single-file runtime overlay, and exposes no GPUs. Tokenizer, runtime and patch hashes are checked -before execution. Expected: 13 imported API -test methods (including the four unchanged Chat regressions), then 77 existing +before execution. Expected: 14 imported API +test methods (including the four unchanged Chat regressions), then 81 existing CPU package tests. CUDA-unavailable and deprecated-max_tokens warnings are inherited from the baseline. diff --git a/patches/0015-qwen-flash-next-effort-alias.patch b/patches/0015-qwen-flash-next-effort-alias.patch index 387f446..41d3afa 100644 --- a/patches/0015-qwen-flash-next-effort-alias.patch +++ b/patches/0015-qwen-flash-next-effort-alias.patch @@ -32,13 +32,13 @@ def _process_messages( self, request: ChatCompletionRequest, -@@ -1059,6 +1070,21 @@ +@@ -1059,6 +1070,23 @@ request_first_reasoning_effort: bool = False, ) -> MessageProcessingResult: """Process chat messages and apply chat template""" + if self._uses_qwen_flash_next_effort_aliases(): + # Rendering-only compatibility: retain literal API effort/provenance. -+ # This common path also serves Responses and message tokenization. ++ # This path also serves Responses, Anthropic Messages, and tokenization. + request = request.model_copy() + ctk = dict(request.chat_template_kwargs or {}) + effort = ctk.pop("reasoning_effort", None) @@ -46,7 +46,9 @@ + effort = request.reasoning_effort + if effort is None: + effort = self.default_chat_template_kwargs.get("reasoning_effort") -+ if effort in ("high", "max"): ++ if effort == "minimal": ++ effort = "low" ++ elif effort in ("high", "max"): + effort = "xhigh" + request.reasoning_effort = effort + request.chat_template_kwargs = ctk diff --git a/provenance/qwen-effort-alias-review.json b/provenance/qwen-effort-alias-review.json index 667fcaf..be9f7cb 100644 --- a/provenance/qwen-effort-alias-review.json +++ b/provenance/qwen-effort-alias-review.json @@ -1,9 +1,15 @@ { - "passed": true, - "security_concerns": [], - "logic_errors": [], - "suggestions": [ - "Consider adding Responses negative-control coverage for non-Qwen models and extending the skip_special_tokens regression to the multimodal rendering branch." - ], - "summary": "Reviewed all seven staged files as data. Aliases are gated on loaded Qwen Flash-Next model types, preserve caller literals, and implement nested/request/default precedence. The correction transfers processed skip_special_tokens to the internal Chat request before sampling; six regression subcases assert both returned-request and sampling state while preserving caller input. Staged patch hunks exactly match the runtime diff, and patch plus runtime before/after SHA-256 hashes match the manifest. Coverage includes Chat, Responses, tokenize, multimodal rendering, precedence, defaults, invalid inputs, and unrelated-model controls. No security or logic errors found. No agents, edits, tests, network, GPU, or deployment operations were performed; reported test results were not independently rerun." + "current_patch_reviewed": false, + "superseded": true, + "reviewed_patch_sha256": "7a05330ee503332050c80bf60d37484c12e9000223dcedba0e040d09bd0a0688", + "note": "Historical review of the high/max-only candidate; the minimal alias extension is covered by the current regression suite.", + "historical_review": { + "passed": true, + "security_concerns": [], + "logic_errors": [], + "suggestions": [ + "Consider adding Responses negative-control coverage for non-Qwen models and extending the skip_special_tokens regression to the multimodal rendering branch." + ], + "summary": "Reviewed all seven staged files as data. Aliases are gated on loaded Qwen Flash-Next model types, preserve caller literals, and implement nested/request/default precedence. The correction transfers processed skip_special_tokens to the internal Chat request before sampling; six regression subcases assert both returned-request and sampling state while preserving caller input. Staged patch hunks exactly match the runtime diff, and patch plus runtime before/after SHA-256 hashes match the manifest. Coverage includes Chat, Responses, tokenize, multimodal rendering, precedence, defaults, invalid inputs, and unrelated-model controls. No security or logic errors found. No agents, edits, tests, network, GPU, or deployment operations were performed; reported test results were not independently rerun." + } } diff --git a/provenance/qwen-effort-alias.json b/provenance/qwen-effort-alias.json index 0f815bf..3cba072 100644 --- a/provenance/qwen-effort-alias.json +++ b/provenance/qwen-effort-alias.json @@ -1,13 +1,13 @@ { "status": "CPU-tested candidate only; not deployed or published", - "base_git_commit": "b8e8bebf2274e0099c3abce5718ac8813dd9001d", + "base_git_commit": "93463c3466b0de9d21776fbeff95657285df8269", "base_image": "kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", "patch": "0015-qwen-flash-next-effort-alias.patch", - "patch_sha256": "7a05330ee503332050c80bf60d37484c12e9000223dcedba0e040d09bd0a0688", + "patch_sha256": "93984526c5b2c03c5bf79a1cd9cc6404b5d38bab86b8f0fadb283c6b16ff10d3", "files": { "python/sglang/srt/entrypoints/openai/serving_chat.py": { "before": "c6228b8d8771e7136ba87404f53da2d51ee2c5c68e7cc32b7d48da9310f55427", - "after": "6d881d19da2c4a7028b0fb179cf5cdb958480612d4192c1606dfd25f98a9ba56" + "after": "07ccd04de5f716277d2df873f66bdc4c03d13f7e89aad105c6dcba979ff47931" } }, "tokenizer": { diff --git a/provenance/responses-compat-runtime-files.json b/provenance/responses-compat-runtime-files.json index d47b132..15cc027 100644 --- a/provenance/responses-compat-runtime-files.json +++ b/provenance/responses-compat-runtime-files.json @@ -2483,7 +2483,7 @@ "python/sglang/srt/entrypoints/openai/realtime/session.py": "3689c4b302059606ca144e782dd171f14a173881fb58365adc66021d8e17ce87", "python/sglang/srt/entrypoints/openai/responses_compat.py": "72bfe1e5e45073d57f09dc90ba7b2ea6b87df932cfbcb67ed8116f25c5830037", "python/sglang/srt/entrypoints/openai/serving_base.py": "3d0613b92abae51e8566a11ae80a2369a46422b49bd63c4cd6aa593d8a4bdbc2", - "python/sglang/srt/entrypoints/openai/serving_chat.py": "6d881d19da2c4a7028b0fb179cf5cdb958480612d4192c1606dfd25f98a9ba56", + "python/sglang/srt/entrypoints/openai/serving_chat.py": "07ccd04de5f716277d2df873f66bdc4c03d13f7e89aad105c6dcba979ff47931", "python/sglang/srt/entrypoints/openai/serving_classify.py": "b05079d8e3930397653a4ddcdef560250d6d7cf3a3af0cd749a9e7ed7c679005", "python/sglang/srt/entrypoints/openai/serving_completions.py": "67f08075f21481b03e246327c7453f57ac001d0f3e78f5a9247caa553e1942e3", "python/sglang/srt/entrypoints/openai/serving_embedding.py": "cf1b283df88e1286b7f803f2173bf89499c65e25c93462bc299b2c64539d77b8", diff --git a/provenance/responses-compat.json b/provenance/responses-compat.json index 1a9f0a6..6583b6d 100644 --- a/provenance/responses-compat.json +++ b/provenance/responses-compat.json @@ -25,7 +25,7 @@ }, "source_files_before": 4391, "source_files_after": 4392, - "inventory_sha256": "e574ce136e79576c3970da7f479b729b21d18ef8e4fe3e49ae3a5fd521866138", + "inventory_sha256": "f5e07abf852aae5e0ec7fe4ff16e257bd97238ea23bcf451e8b9466906c7a240", "consulted_upstream": { "39174": "771843d0e476e24761904aba61801dd662448d42", "38359": "02d84e6b2bb4460a4d1a648a3a9dc2d1b4fe1905", diff --git a/runtime/python/sglang/srt/entrypoints/openai/serving_chat.py b/runtime/python/sglang/srt/entrypoints/openai/serving_chat.py index 266889e..148f80a 100644 --- a/runtime/python/sglang/srt/entrypoints/openai/serving_chat.py +++ b/runtime/python/sglang/srt/entrypoints/openai/serving_chat.py @@ -1072,7 +1072,7 @@ def _process_messages( """Process chat messages and apply chat template""" if self._uses_qwen_flash_next_effort_aliases(): # Rendering-only compatibility: retain literal API effort/provenance. - # This common path also serves Responses and message tokenization. + # This path also serves Responses, Anthropic Messages, and tokenization. request = request.model_copy() ctk = dict(request.chat_template_kwargs or {}) effort = ctk.pop("reasoning_effort", None) @@ -1080,7 +1080,9 @@ def _process_messages( effort = request.reasoning_effort if effort is None: effort = self.default_chat_template_kwargs.get("reasoning_effort") - if effort in ("high", "max"): + if effort == "minimal": + effort = "low" + elif effort in ("high", "max"): effort = "xhigh" request.reasoning_effort = effort request.chat_template_kwargs = ctk diff --git a/tests/runtime_qwen_effort_alias.py b/tests/runtime_qwen_effort_alias.py index d6586df..388932c 100644 --- a/tests/runtime_qwen_effort_alias.py +++ b/tests/runtime_qwen_effort_alias.py @@ -2,6 +2,8 @@ import copy import unittest from runtime_chat_effort import ChatEffortTest +from sglang.srt.entrypoints.anthropic.protocol import AnthropicMessagesRequest +from sglang.srt.entrypoints.anthropic.serving import AnthropicServing from sglang.srt.entrypoints.openai.protocol import ChatCompletionRequest, ResponsesRequest from sglang.srt.entrypoints.openai.serving_responses import OpenAIServingResponses @@ -15,9 +17,9 @@ def setUp(self): def test_chat_alias_tokens_and_literal_provenance(self): messages = [{'role': 'user', 'content': 'Hi'}] - expected = self.tokenizer.apply_chat_template(messages, tokenize=True, - return_dict=False, add_generation_prompt=True, reasoning_effort='xhigh') - for alias in ('high', 'max'): + for alias, effective in (('minimal', 'low'), ('high', 'xhigh'), ('max', 'xhigh')): + expected = self.tokenizer.apply_chat_template(messages, tokenize=True, + return_dict=False, add_generation_prompt=True, reasoning_effort=effective) for stream in (False, True): for fields in ({'reasoning_effort': alias}, {'chat_template_kwargs': {'reasoning_effort': alias}}, @@ -35,8 +37,8 @@ def test_supported_values_precedence_null_and_no_leak(self): messages = [{'role': 'user', 'content': 'Hi'}] cases = [({}, 'medium'), ({'reasoning_effort': None}, 'medium'), ({'chat_template_kwargs': {'reasoning_effort': None}}, 'medium')] - for effort in ('low', 'medium', 'xhigh', 'high', 'max'): - effective = 'xhigh' if effort in ('high', 'max') else effort + for effort in ('minimal', 'low', 'medium', 'xhigh', 'high', 'max'): + effective = {'minimal': 'low', 'high': 'xhigh', 'max': 'xhigh'}.get(effort, effort) cases.extend([({'reasoning_effort': effort}, effective), ({'reasoning_effort': effort, 'chat_template_kwargs': {'reasoning_effort': None}}, effective), ({'reasoning_effort': 'max', 'chat_template_kwargs': {'reasoning_effort': effort}}, effective)]) @@ -58,54 +60,85 @@ def test_responses_real_conversion_and_literal_effort(self): responses = OpenAIServingResponses.__new__(OpenAIServingResponses) responses.__dict__.update(self.chat.__dict__) for stream in (False, True): - for effort in ('high', 'max', 'low', 'medium', 'xhigh', None): - for nested in (None, 'low', 'high', 'max'): + for effort in ('minimal', 'high', 'max', 'low', 'medium', 'xhigh', None): + for nested in (None, 'minimal', 'low', 'high', 'max'): with self.subTest(stream=stream, effort=effort, nested=nested): req = ResponsesRequest(model='fixture-qwen', input='Hi', stream=stream, reasoning={'effort': effort}, chat_template_kwargs={'reasoning_effort': nested}) before = req.model_dump() messages, _, prompts, _ = asyncio.run(responses._make_request(req, None, self.tokenizer)) effective = nested or effort or 'medium' - effective = 'xhigh' if effective in ('high', 'max') else effective + effective = {'minimal': 'low', 'high': 'xhigh', 'max': 'xhigh'}.get( + effective, effective) expected = self.tokenizer.apply_chat_template(messages, tokenize=True, return_dict=False, add_generation_prompt=True, reasoning_effort=effective) self.assertEqual(prompts, [expected]) self.assertEqual(req.model_dump(), before) - def test_unrelated_model_native_high_is_not_aliased(self): - # A real tokenizer with a tiny native-high template, not a mocked renderer. + def test_anthropic_messages_effort_uses_shared_aliases(self): + serving = AnthropicServing(self.chat) + messages = [{'role': 'user', 'content': 'Hi'}] + for stream in (False, True): + for effort, literal, effective in ( + ('minimal', 'minimal', 'low'), + ('low', 'low', 'low'), + ('medium', 'medium', 'medium'), + ('high', 'high', 'xhigh'), + ('xhigh', 'max', 'xhigh'), + ('max', 'max', 'xhigh'), + ): + with self.subTest(stream=stream, effort=effort): + request = AnthropicMessagesRequest(model='fixture-qwen', + messages=messages, max_tokens=64, stream=stream, + output_config={'effort': effort}) + chat_request = serving._convert_to_chat_completion_request(request) + before = chat_request.model_dump() + internal, normalized = self.chat._convert_to_internal_request(chat_request) + expected = self.tokenizer.apply_chat_template(messages, tokenize=True, + return_dict=False, add_generation_prompt=True, + reasoning_effort=effective) + self.assertEqual(internal.input_ids, expected) + self.assertEqual(chat_request.model_dump(), before) + self.assertEqual(normalized.reasoning_effort, literal) + + def test_unrelated_model_native_efforts_are_not_aliased(self): + # A real tokenizer with a tiny native-effort template, not a mocked renderer. tokenizer = copy.deepcopy(self.tokenizer) tokenizer.chat_template = '{{ reasoning_effort }}' self.chat.tokenizer_manager.tokenizer = tokenizer for model_type in ('qwen4', 'qwen3', 'llama', 'deepseek_v3'): self.chat.tokenizer_manager.model_config.hf_config.model_type = model_type - req = ChatCompletionRequest(model='qwen3_8_flash_next', - messages=[{'role': 'user', 'content': 'Hi'}], reasoning_effort='high') - internal, normalized = self.chat._convert_to_internal_request(req) - self.assertEqual(internal.input_ids, tokenizer.encode('high', add_special_tokens=False)) - self.assertEqual(normalized.reasoning_effort, 'high') + for effort in ('minimal', 'high'): + req = ChatCompletionRequest(model='qwen3_8_flash_next', + messages=[{'role': 'user', 'content': 'Hi'}], reasoning_effort=effort) + internal, normalized = self.chat._convert_to_internal_request(req) + self.assertEqual(internal.input_ids, + tokenizer.encode(effort, add_special_tokens=False)) + self.assertEqual(normalized.reasoning_effort, effort) def test_tokenize_and_multimodal_render_paths(self): from sglang.srt.entrypoints.openai.protocol import TokenizeRequest from sglang.srt.entrypoints.openai.serving_tokenize import OpenAIServingTokenize serving = OpenAIServingTokenize(self.chat.tokenizer_manager, self.chat.template_manager) messages = [{'role': 'user', 'content': 'Hi'}] - for effort in ('high', 'max', 'xhigh'): + for effort, effective in (('minimal', 'low'), ('high', 'xhigh'), + ('max', 'xhigh'), ('xhigh', 'xhigh')): with self.subTest(effort=effort): req = TokenizeRequest(messages=messages, reasoning_effort=effort) expected = self.tokenizer.apply_chat_template(messages, tokenize=True, - return_dict=False, add_generation_prompt=True, reasoning_effort='xhigh') + return_dict=False, add_generation_prompt=True, reasoning_effort=effective) self.assertEqual(serving._tokenize_chat_request(req), expected) self.chat.tokenizer_manager.model_config.is_multimodal = True chat_req = ChatCompletionRequest(messages=messages, reasoning_effort=effort) internal, _ = self.chat._convert_to_internal_request(chat_req) self.assertEqual(internal.text, self.tokenizer.apply_chat_template(messages, - tokenize=False, add_generation_prompt=True, reasoning_effort='xhigh')) + tokenize=False, add_generation_prompt=True, reasoning_effort=effective)) self.chat.tokenizer_manager.model_config.is_multimodal = False def test_server_default_and_absence_semantics(self): messages = [{'role': 'user', 'content': 'Hi'}] - for defaults, expected_effort in (({}, 'xhigh'), ({'reasoning_effort': 'high'}, 'xhigh'), + for defaults, expected_effort in (({}, 'xhigh'), ({'reasoning_effort': 'minimal'}, 'low'), + ({'reasoning_effort': 'high'}, 'xhigh'), ({'reasoning_effort': 'max'}, 'xhigh'), ({'reasoning_effort': 'medium'}, 'medium')): self.chat.default_chat_template_kwargs = defaults for fields in ({}, {'reasoning_effort': None}, @@ -124,7 +157,8 @@ def test_tokenize_precedence_null_and_provenance(self): from sglang.srt.entrypoints.openai.serving_tokenize import OpenAIServingTokenize serving = OpenAIServingTokenize(self.chat.tokenizer_manager, self.chat.template_manager) messages = [{'role': 'user', 'content': 'Hi'}] - for fields, effort in (({'reasoning_effort': 'max', 'chat_template_kwargs': {'reasoning_effort': 'low'}}, 'low'), + for fields, effort in (({'reasoning_effort': 'max', 'chat_template_kwargs': {'reasoning_effort': 'minimal'}}, 'low'), + ({'reasoning_effort': 'minimal', 'chat_template_kwargs': {'reasoning_effort': None}}, 'low'), ({'reasoning_effort': 'high', 'chat_template_kwargs': {'reasoning_effort': None}}, 'xhigh'), ({'chat_template_kwargs': {'reasoning_effort': None}}, 'medium')): req = TokenizeRequest(messages=messages, **fields) @@ -145,7 +179,7 @@ def test_tokenize_precedence_null_and_provenance(self): def test_processing_special_token_state_survives_render_copy(self): tools = [{'type': 'function', 'function': {'name': 'lookup', 'parameters': {'type': 'object', 'properties': {}}}}] - for effort in ('medium', 'high', 'max'): + for effort in ('minimal', 'medium', 'high', 'max'): for parser, request_tools in ((None, tools), ('mistral', None)): with self.subTest(effort=effort, parser=parser): self.chat.reasoning_parser = parser From 3c9658576a4018690a25b1c0fbd2cfc1e5d4a4a4 Mon Sep 17 00:00:00 2001 From: ktsaou <2662304+ktsaou@users.noreply.github.com> Date: Mon, 14 Sep 2026 10:35:20 +0000 Subject: [PATCH 02/20] wip(hicache): preserve Qwen auxiliary cache state --- Dockerfile.hicache-wip | 15 + README.md | 5 + docs/hicache-wip.md | 121 +++++ patches/0020-hicache-ple-state.patch | 308 +++++++++++++ patches/0021-hicache-file-integrity.patch | 67 +++ patches/0022-hicache-qsa-sidecar.patch | 228 ++++++++++ patches/series.hicache-wip | 3 + provenance/hicache-wip.json | 119 +++++ scripts/test_hicache_wip.sh | 46 ++ scripts/verify_hicache_wip.py | 135 ++++++ tests/test_hicache_wip_packaging.py | 78 ++++ .../hicache/test_hicache_file_gpu_local.py | 42 ++ validation/hicache/test_hicache_file_local.py | 237 ++++++++++ .../hicache/test_hicache_ple_gpu_local.py | 192 ++++++++ validation/hicache/test_hicache_ple_local.py | 420 ++++++++++++++++++ .../hicache/test_hicache_qsa_gpu_local.py | 163 +++++++ validation/hicache/test_hicache_qsa_local.py | 254 +++++++++++ 17 files changed, 2433 insertions(+) create mode 100644 Dockerfile.hicache-wip create mode 100644 docs/hicache-wip.md create mode 100644 patches/0020-hicache-ple-state.patch create mode 100644 patches/0021-hicache-file-integrity.patch create mode 100644 patches/0022-hicache-qsa-sidecar.patch create mode 100644 patches/series.hicache-wip create mode 100644 provenance/hicache-wip.json create mode 100755 scripts/test_hicache_wip.sh create mode 100755 scripts/verify_hicache_wip.py create mode 100644 tests/test_hicache_wip_packaging.py create mode 100644 validation/hicache/test_hicache_file_gpu_local.py create mode 100644 validation/hicache/test_hicache_file_local.py create mode 100644 validation/hicache/test_hicache_ple_gpu_local.py create mode 100644 validation/hicache/test_hicache_ple_local.py create mode 100644 validation/hicache/test_hicache_qsa_gpu_local.py create mode 100644 validation/hicache/test_hicache_qsa_local.py diff --git a/Dockerfile.hicache-wip b/Dockerfile.hicache-wip new file mode 100644 index 0000000..af9ab2c --- /dev/null +++ b/Dockerfile.hicache-wip @@ -0,0 +1,15 @@ +# EXPERIMENTAL: this profile preserves incomplete HiCache work for review. +# It is not qualified for deployment; see docs/hicache-wip.md. +FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 +ARG SOURCE_REVISION +LABEL org.opencontainers.image.source="https://github.com/kanadaj/sglang" \ + org.opencontainers.image.revision="${SOURCE_REVISION}" \ + org.opencontainers.image.description="Experimental unqualified Qwen HiCache state-transfer profile" +COPY patches/0020-hicache-ple-state.patch patches/0021-hicache-file-integrity.patch patches/0022-hicache-qsa-sidecar.patch patches/series.hicache-wip /opt/qwen-hicache-wip/patches/ +COPY provenance/production/runtime-files.json /opt/qwen-hicache-wip/provenance/production/runtime-files.json +COPY provenance/chat-effort.json provenance/hicache-wip.json /opt/qwen-hicache-wip/provenance/ +COPY scripts/verify_hicache_wip.py /opt/qwen-hicache-wip/scripts/verify_hicache_wip.py +RUN python3 -B /opt/qwen-hicache-wip/scripts/verify_hicache_wip.py \ + --tree /sgl-workspace/sglang --apply +ENTRYPOINT ["python3", "-m", "sglang.launch_server"] +CMD ["--help"] diff --git a/README.md b/README.md index c2bf16c..ba5f336 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,10 @@ # Qwen TP2 packed-PLE vision on SM120 +**Experimental draft:** [Qwen HiCache state-transfer work](docs/hicache-wip.md) +preserves RAM/file fixes and focused tests. End-to-end generation still has an +unresolved corruption failure, so this separate profile must not be deployed or +added to the default patch series. + **Unpublished CPU candidate:** [Responses namespace/custom compatibility](docs/responses-compat.md) adds a separately attested boundary backport after the effort-alias profile. Historical production profiles below are unchanged; no deployment is implied. diff --git a/docs/hicache-wip.md b/docs/hicache-wip.md new file mode 100644 index 0000000..4338e6b --- /dev/null +++ b/docs/hicache-wip.md @@ -0,0 +1,121 @@ +# Qwen HiCache state transfer — experimental draft + +## Status + +**Do not merge or deploy this profile.** It preserves three incomplete HiCache +patches and the tests used to investigate them. Narrow state-transfer tests and +one exact live restoration fixture passed, but a later end-to-end generation +gate passed only 32 of 48 cases with repeated punctuation. + +`Dockerfile.hicache-wip` and `patches/series.hicache-wip` are isolated from every +default and production profile. No launcher enables HiCache, no deployment +configuration changes, and the ordinary `Dockerfile` does not install this work. + +## Defects addressed by the patch series + +The Qwen Flash-Next runtime has state outside the ordinary full-attention KV and +Mamba recurrent buffers. Restoring only the existing host-pool components can +therefore reuse a prefix with incomplete model state. + +1. `0020-hicache-ple-state.patch` adds the PLE short-convolution and N-gram + slot tensors to Mamba host checkpoints. It includes their bytes in host-pool + sizing, carries them through RAM and flat page representations, and waits for + the first relevant transfer event before an early PLE read. +2. `0021-hicache-file-integrity.patch` treats missing, truncated, or unreadable + file pages as cache misses so a prefetch worker can continue. It permits the + complete PLE checkpoint format only with the tested built-in file backend; + other storage backends remain rejected. +3. `0022-hicache-qsa-sidecar.patch` adds a required page-aligned sidecar for + compressed QSA index keys, including packed MTP draft layers. It budgets the + index inside the KV share of the existing host limit, requires complete pages, + and waits for the corresponding layer transfer before QSA reads the index. + +The patch preimages match the 4,391-file production Chat-effort inventory and +the immutable base image: + +```text +kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 +``` + +`provenance/hicache-wip.json` records every hash transition, the ordered patch +hashes, and the resulting 4,392-file inventory digest. The one new source file is +`python/sglang/srt/mem_cache/qsa_pool_host.py`. + +## Retained evidence + +These results were collected on the preserved candidate before this draft was +packaged: + +| Gate | Result | What it establishes | +|---|---:|---| +| Packaged CPU PLE/file/QSA fixtures | 55 passed | Layout, sizing, lifecycle, file-error, sidecar, and wait behavior | +| PLE transfer cases | 24 per GPU | Real kernel copies for the companion slot state | +| Combined PLE/Mamba/target/draft checkpoint | 1 passed | Repeated asynchronous relocation and event-ring reuse | +| File reconstruction checkpoint | 1 passed | GPU→RAM→file→RAM→GPU with a reconstructed backend | +| QSA relocation | 4 per GPU | Target and draft indices, two layouts, RAM and reconstructed files | +| Exact live restore fixture | cold 4/4; storage 4/4; GPU replay 4/4 | Positive storage and H2D use after a flush | +| Ordinary 200-tool catalogue/replay | **32/48** | **Blocking end-to-end corruption remains** | + +The PLE GPU result covers the kernel transfer backend. Six direct-copy cases +were deselected after the unmodified parent failed them with the same invalid +argument error; this profile makes no direct-backend qualification claim. + +The live restore transferred 81,788,928 more bytes than the preceding build, +exactly 832 bytes per restored KV token. This matches the added QSA index state +and supports the omitted-state diagnosis for that fixture. + +The later 32/48 failure recorded no new host or storage reads. That means the +failure cannot be attributed solely to corrupt data restored by these patches. +Instrumented diagnostics also observed NaNs in CUDA-graph draft extension, but +they did not establish whether that path caused the emitted punctuation. This +draft contains no draft-extension workaround. + +## Verification and CPU fixtures + +The standard package test remains unchanged. Verify the isolated patch hashes, +declared transitions, and result inventory: + +```bash +python3 scripts/verify_hicache_wip.py +python3 -m unittest tests/test_hicache_wip_packaging.py -v +``` + +Build the experimental image only for investigation: + +```bash +docker build --pull=false -f Dockerfile.hicache-wip \ + --build-arg SOURCE_REVISION="$(git rev-parse HEAD)" \ + -t qwen-hicache:wip . +HICACHE_WIP_IMAGE=qwen-hicache:wip bash scripts/test_hicache_wip.sh +``` + +The runner uses no network or GPUs. It executes the 55 CPU cases from +`validation/hicache/` inside the candidate image. The three GPU files are retained +for review and require an explicitly isolated GPU environment; the runner does +not claim or acquire an available GPU. + +To verify and apply the patch series to a complete export of the exact base +image: + +```bash +python3 scripts/verify_hicache_wip.py --tree /path/to/sglang --apply +``` + +The verifier checks the complete base inventory before applying anything and +the complete result inventory afterward. The Docker build runs this mode, so a +clean application against the exact parent is required to produce an image. + +## Remaining merge blockers + +- Isolate the repeated-punctuation failure and determine whether HiCache, + scheduler overlap, speculative draft graphs, or another inherited path is + responsible. +- Pass repeated no-logprob catalogue/replay gates after positive RAM and file + restoration, including eviction and slot reuse. +- Repeat real GPU transfer tests on both ranks, long-context retrieval, mixed + media, concurrency, cancellation, restart persistence, and a soak on the final + implementation. +- Review support for storage backends other than the built-in file backend. They + are intentionally rejected when PLE companion state is present. + +Until those blockers are closed, HiCache should remain disabled for this model. diff --git a/patches/0020-hicache-ple-state.patch b/patches/0020-hicache-ple-state.patch new file mode 100644 index 0000000..9d314fe --- /dev/null +++ b/patches/0020-hicache-ple-state.patch @@ -0,0 +1,308 @@ +--- a/python/sglang/srt/mem_cache/ple_state_pool.py ++++ b/python/sglang/srt/mem_cache/ple_state_pool.py +@@ -37,6 +37,10 @@ + def get_cpu_slots(self, indices: torch.Tensor) -> Any: ... + + def load_cpu_slots(self, data: Any, indices: torch.Tensor) -> None: ... ++ ++ def get_slot_tensors(self) -> Tuple[torch.Tensor, ...]: ++ """Contiguous [layer, slot, ...] views for bounded host-cache transfers.""" ++ ... + + + class ShortConvPool: +@@ -110,6 +114,9 @@ + + # SlotIndexedState: slot is dim 1, behind the layer dim. + ++ def get_slot_tensors(self) -> Tuple[torch.Tensor, ...]: ++ return () if self.conv_state is None else (self.conv_state,) ++ + def reset_slots(self, indices: torch.Tensor) -> None: + if self.conv_state is not None and indices.numel() > 0: + self.conv_state[:, indices] = 0 +@@ -201,6 +208,9 @@ + + # SlotIndexedState: slot is dim 0, no layer dim. + ++ def get_slot_tensors(self) -> Tuple[torch.Tensor, ...]: ++ return () if self.context is None else (self.context.unsqueeze(0),) ++ + def reset_slots(self, indices: torch.Tensor) -> None: + if self.context is not None and indices.numel() > 0: + self.context[indices.to(dtype=torch.long)] = self.eos_token_id +--- a/python/sglang/srt/mem_cache/memory_pool_host.py ++++ b/python/sglang/srt/mem_cache/memory_pool_host.py +@@ -58,6 +58,7 @@ + ) + from sglang.srt.mem_cache.pool_host.common import ( + ALLOC_MEMORY_FUNCS, ++ _cuda_host_unregister, + get_allocator_from_storage, + ) + from sglang.srt.mem_cache.pool_host.hisparse import HiSparseHostPoolMixin +@@ -99,6 +100,20 @@ + self.conv_dtype = device_pool.mamba_cache.conv[0].dtype + self.temporal_dtype = device_pool.mamba_cache.temporal.dtype + self.dtype = self.conv_dtype ++ self.sibling_device_tensors = tuple( ++ tensor ++ for sibling in getattr(device_pool, "_slot_siblings", ()) ++ for tensor in sibling.get_slot_tensors() ++ ) ++ for tensor in self.sibling_device_tensors: ++ if tensor.ndim < 3 or not tensor.is_contiguous(): ++ raise ValueError( ++ "HiCache slot state must be contiguous [layer, slot, ...]." ++ ) ++ self.sibling_bytes_per_slot = sum( ++ tensor.shape[0] * int(np.prod(tensor.shape[2:])) * tensor.element_size() ++ for tensor in self.sibling_device_tensors ++ ) + self.size_per_token = self.get_size_per_token() + + if host_size > 0: +@@ -152,8 +167,23 @@ + ) + for conv_state in device_pool.mamba_cache.conv + ] +- +- self.init_kv_buffer() ++ self.sibling_device_ptrs = [ ++ torch.tensor( ++ [layer.data_ptr() for layer in tensor], ++ dtype=torch.uint64, ++ device=self.device_pool.device, ++ ) ++ for tensor in self.sibling_device_tensors ++ ] ++ ++ self.temporal_buffer = None ++ self.conv_buffer = [] ++ self.sibling_buffers = [] ++ try: ++ self.init_kv_buffer() ++ except Exception: ++ self.destroy() ++ raise + self._init_write_back_staging_buffers() + self.lock = threading.RLock() + self.clear() +@@ -226,6 +256,39 @@ + ) + ) + ++ for tensor in self.sibling_device_tensors: ++ self.sibling_buffers.append( ++ alloc_func( ++ (self.size, tensor.shape[0], 1, *tensor.shape[2:]), ++ dtype=tensor.dtype, ++ device=self.device, ++ pin_memory=self.pin_memory, ++ allocator=self.allocator, ++ ) ++ ) ++ ++ def destroy(self): ++ if getattr(self, "_destroyed", False): ++ return ++ buffers = [ ++ getattr(self, "temporal_buffer", None), ++ *getattr(self, "conv_buffer", ()), ++ *getattr(self, "sibling_buffers", ()), ++ ] ++ for buffer in buffers: ++ if ( ++ buffer is not None ++ and buffer.numel() ++ and self.pin_memory ++ and (_is_cuda or _is_hip) ++ ): ++ _cuda_host_unregister(buffer) ++ self.temporal_buffer = None ++ self.conv_buffer = [] ++ self.sibling_buffers = [] ++ self.sibling_device_ptrs = [] ++ super().destroy() ++ + def _init_write_back_staging_buffers(self): + self.temporal_staging_buffer = None + self.conv_staging_buffers = [None] * len(self.conv_buffer) +@@ -239,7 +302,7 @@ + + def get_hybrid_pool_buffer(self): + # Expose all mamba host tensors that need Mooncake buffer registration. +- return [self.temporal_buffer, *self.conv_buffer] ++ return [self.temporal_buffer, *self.conv_buffer, *self.sibling_buffers] + + def _iter_page_tensors(self, index: int): + if self.layout in ["page_first", "page_first_direct"]: +@@ -250,6 +313,8 @@ + yield self.temporal_buffer[:, index : index + self.page_size] + for conv_buf in self.conv_buffer: + yield conv_buf[:, index : index + self.page_size] ++ for buffer in self.sibling_buffers: ++ yield buffer[index] + + @staticmethod + def _flatten_tensor_bytes(tensor: torch.Tensor) -> torch.Tensor: +@@ -298,7 +363,9 @@ + for conv_elem_size in self.conv_state_elem_sizes + ) + temporal_size = self.temporal_state_elem_size * self.temporal_dtype.itemsize +- return (conv_total_size + temporal_size) * self.num_mamba_layers ++ return ( ++ conv_total_size + temporal_size ++ ) * self.num_mamba_layers + self.sibling_bytes_per_slot + + def get_ksize_per_token(self): + return self.get_size_per_token() +@@ -434,6 +501,22 @@ + *, + is_draft: bool = False, + ): ++ # Qwen reads N-gram history before layer execution. Its getter waits on ++ # this first Mamba layer's completion event, including both companions. ++ if layer_id == 0: ++ for host_buffer, tensor in zip( ++ self.sibling_buffers, self.sibling_device_tensors ++ ): ++ for sibling_layer, target in enumerate(tensor): ++ self._copy_tensor_pf_lf( ++ src=host_buffer, ++ dst=target, ++ src_indices=host_indices, ++ dst_indices=device_indices, ++ layer_id=sibling_layer, ++ num_layers=tensor.shape[0], ++ io_backend=io_backend, ++ ) + if self.layout in ["page_first", "page_first_direct"]: + # no ssm state on conv-only models: nothing to transfer + if self.temporal_state_elem_size > 0: +@@ -476,6 +559,20 @@ + def backup_from_device_all_layer( + self, device_pool, host_indices, device_indices, io_backend="kernel" + ): ++ for tensor, host_buffer, device_ptrs in zip( ++ self.sibling_device_tensors, ++ self.sibling_buffers, ++ self.sibling_device_ptrs, ++ ): ++ self._copy_tensor_all_layers_lf_pf( ++ src_layers=tensor, ++ dst=host_buffer, ++ src_indices=device_indices, ++ dst_indices=host_indices, ++ num_layers=tensor.shape[0], ++ io_backend=io_backend, ++ src_ptrs=device_ptrs, ++ ) + if self.layout in ["page_first", "page_first_direct"]: + # no ssm state on conv-only models: a 0-size batched memcpy errors + if self.temporal_state_elem_size > 0: +@@ -585,6 +682,10 @@ + ) + for i in range(len(self.conv_state_shapes)) + ] ++ sibling_meta = [ ++ (buffer.data_ptr(), self._item_size_per_index(buffer)) ++ for buffer in self.sibling_buffers ++ ] + + for i in range(0, len(indices), self.page_size): + # Emit component pointers in stable order: temporal first (dropped +@@ -611,6 +712,9 @@ + ) + ptr_list.append(conv_ptr) + element_size_list.append(conv_element_sizes[j]) ++ for base_ptr, size_bytes in sibling_meta: ++ ptr_list.append(base_ptr + indices[i] * size_bytes) ++ element_size_list.append(size_bytes) + return ptr_list, element_size_list + + def is_stride_page_aligned(self, page_size_bytes: int = 4096) -> bool: +@@ -630,6 +734,12 @@ + if buf.data_ptr() % page_size_bytes != 0: + return False + if conv_stride % page_size_bytes != 0: ++ return False ++ for buffer in self.sibling_buffers: ++ if ( ++ buffer.data_ptr() % page_size_bytes != 0 ++ or self._item_size_per_index(buffer) % page_size_bytes != 0 ++ ): + return False + return True + +--- a/python/sglang/srt/mem_cache/memory_pool.py ++++ b/python/sglang/srt/mem_cache/memory_pool.py +@@ -1478,7 +1478,9 @@ + + def short_conv_layer_cache(self, layer_id: int) -> torch.Tensor: + if self.layer_transfer_counter is not None: +- self.layer_transfer_counter.wait_until(layer_id - self.start_layer) ++ # Companion state is restored with the first local Mamba layer. ++ ready_layer = max(layer_id, min(self.mamba_map)) ++ self.layer_transfer_counter.wait_until(ready_layer - self.start_layer) + return self.short_conv_pool.layer_cache(layer_id) + + def short_conv_layer_intermediate_cache( +@@ -1490,6 +1492,11 @@ + return self.get_mamba_indices(req_indices) + + def get_ngram_context(self, ngram_indices: torch.Tensor) -> torch.Tensor: ++ if self.layer_transfer_counter is not None: ++ # PLE prepares token history before the model's first layer runs. ++ self.layer_transfer_counter.wait_until( ++ min(self.mamba_map) - self.start_layer ++ ) + return self.ngram_pool.get_context(ngram_indices) + + def set_ngram_context( +--- a/python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py ++++ b/python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py +@@ -31,7 +31,11 @@ + PoolTransferResult, + ) + from sglang.srt.mem_cache.l2_transfer import L2Transfer +-from sglang.srt.mem_cache.memory_pool_host import HostPoolGroup, PoolEntry ++from sglang.srt.mem_cache.memory_pool_host import ( ++ HostPoolGroup, ++ MambaPoolHost, ++ PoolEntry, ++) + from sglang.srt.mem_cache.pool_host.mha import MHATokenToKVPoolHost + + if TYPE_CHECKING: +@@ -159,6 +163,8 @@ + storage_backend_extra_config: Optional[dict] = None, + host_pools: Optional[list[PoolEntry]] = None, + ): ++ for entry in [*getattr(self.mem_pool_host, "entries", ()), *(host_pools or ())]: ++ self._check_storage_pool(entry.host_pool) + super().attach_storage_backend( + storage_backend=storage_backend, + prefetch_threshold=prefetch_threshold, +@@ -169,9 +175,21 @@ + for entry in host_pools or []: + self.storage_backend.register_mem_host_pool_v2(entry.host_pool, entry.name) + ++ @staticmethod ++ def _check_storage_pool(host_pool): ++ if isinstance(host_pool, MambaPoolHost) and getattr( ++ host_pool, "sibling_buffers", () ++ ): ++ raise NotImplementedError( ++ "HiCache with PLE companion state supports RAM only; " ++ "storage backends do not preserve its component format." ++ ) ++ + def register_host_pool_entry(self, entry: PoolEntry) -> None: + if not isinstance(self.mem_pool_host, HostPoolGroup): + raise TypeError("Dynamic HiCache sidecars require HostPoolGroup.") ++ if self.enable_storage: ++ self._check_storage_pool(entry.host_pool) + self.mem_pool_host.add_entry(entry) + if not entry.is_primary_index_anchor: + self.extra_host_mem_release_queues.setdefault(entry.name, Queue()) diff --git a/patches/0021-hicache-file-integrity.patch b/patches/0021-hicache-file-integrity.patch new file mode 100644 index 0000000..14141bf --- /dev/null +++ b/patches/0021-hicache-file-integrity.patch @@ -0,0 +1,67 @@ +--- a/python/sglang/srt/mem_cache/hicache_storage.py ++++ b/python/sglang/srt/mem_cache/hicache_storage.py +@@ -478,10 +478,13 @@ + if self.metadata_cache is not None: + self.metadata_cache.add(suffixed) + return target_location +- except FileNotFoundError: ++ except OSError as error: + if self.metadata_cache is not None: + self.metadata_cache.remove(suffixed) +- logger.warning(f"Failed to fetch {key} from HiCacheFile storage.") ++ # A broken cache page must not terminate the prefetch worker. ++ logger.warning( ++ "Failed to fetch %s from HiCacheFile storage: %s", key, error ++ ) + return None + + def batch_get( +--- a/python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py ++++ b/python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py +@@ -24,6 +24,7 @@ + StorageOperation as BaseStorageOperation, + ) + from sglang.srt.mem_cache.hicache_storage import ( ++ HiCacheFile, + HiCacheStorageExtraInfo, + PoolHitPolicy, + PoolName, +@@ -164,7 +165,7 @@ + host_pools: Optional[list[PoolEntry]] = None, + ): + for entry in [*getattr(self.mem_pool_host, "entries", ()), *(host_pools or ())]: +- self._check_storage_pool(entry.host_pool) ++ self._check_storage_pool(entry.host_pool, storage_backend) + super().attach_storage_backend( + storage_backend=storage_backend, + prefetch_threshold=prefetch_threshold, +@@ -176,20 +177,23 @@ + self.storage_backend.register_mem_host_pool_v2(entry.host_pool, entry.name) + + @staticmethod +- def _check_storage_pool(host_pool): +- if isinstance(host_pool, MambaPoolHost) and getattr( +- host_pool, "sibling_buffers", () ++ def _check_storage_pool(host_pool, storage_backend=None): ++ if ( ++ isinstance(host_pool, MambaPoolHost) ++ and getattr(host_pool, "sibling_buffers", ()) ++ and storage_backend != "file" ++ and not isinstance(storage_backend, HiCacheFile) + ): + raise NotImplementedError( +- "HiCache with PLE companion state supports RAM only; " +- "storage backends do not preserve its component format." ++ "HiCache with PLE companion state supports RAM and file storage only; " ++ "other storage backends are not qualified for this checkpoint format." + ) + + def register_host_pool_entry(self, entry: PoolEntry) -> None: + if not isinstance(self.mem_pool_host, HostPoolGroup): + raise TypeError("Dynamic HiCache sidecars require HostPoolGroup.") + if self.enable_storage: +- self._check_storage_pool(entry.host_pool) ++ self._check_storage_pool(entry.host_pool, self.storage_backend) + self.mem_pool_host.add_entry(entry) + if not entry.is_primary_index_anchor: + self.extra_host_mem_release_queues.setdefault(entry.name, Queue()) diff --git a/patches/0022-hicache-qsa-sidecar.patch b/patches/0022-hicache-qsa-sidecar.patch new file mode 100644 index 0000000..cd387c3 --- /dev/null +++ b/patches/0022-hicache-qsa-sidecar.patch @@ -0,0 +1,228 @@ +--- a/python/sglang/srt/mem_cache/hicache_storage.py ++++ b/python/sglang/srt/mem_cache/hicache_storage.py +@@ -62,6 +62,7 @@ + MAMBA = "mamba" + SWA = "swa" + INDEXER = "indexer" ++ QSA_INDEXER = "qsa_indexer" + # TODO(hzh0425): Current DeepSeek V4 pool naming is verbose; will be normalized to + # 'COMPRESSED_KV / COMPRESSED_INDEXER / COMPRESSED_STATE' in the next PR. + DEEPSEEK_V4_C4 = "deepseek_v4_c4" +--- a/python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py ++++ b/python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py +@@ -687,6 +687,7 @@ + model_name: Optional[str] = None, + storage_backend_extra_config: Optional[dict] = None, + enable_storage_metrics: bool = False, ++ qsa_device_pools: tuple[Any, ...] = (), + ) -> tuple[HostPoolGroup, HybridCacheController]: + transfer_layer_num = len(full_layer_mapping | mamba_layer_mapping) + mamba_allocator = params.req_to_token_pool.mamba_allocator +@@ -698,6 +699,16 @@ + kv_host_size, mamba_host_size = _split_hicache_size( + server_args.hicache_size, (kv_pool, mamba_pool) + ) ++ if qsa_device_pools: ++ from sglang.srt.mem_cache.qsa_pool_host import qsa_index_bytes_per_token ++ ++ # The index shares KV slots and must fit inside the fixed KV budget. ++ kv_bytes = sum( ++ sum(pool.get_kv_size_bytes()) / (pool.size + pool.page_size) ++ for pool in (kv_pool, *mtp_draft_device_pools) ++ ) ++ index_bytes = qsa_index_bytes_per_token(qsa_device_pools, params.page_size) ++ kv_host_size *= kv_bytes / (kv_bytes + index_bytes) + kv_host_pool = build_kv_host_pool( + kv_pool=kv_pool, + page_size=params.page_size, +@@ -741,6 +752,25 @@ + device_free_fn=mamba_allocator.free, + ), + ] ++ if qsa_device_pools: ++ from sglang.srt.mem_cache.qsa_pool_host import QSAPagedHostPool ++ ++ index_host_pool = QSAPagedHostPool( ++ qsa_device_pools, ++ num_host_tokens=kv_host_pool.size, ++ page_size=params.page_size, ++ layout=server_args.hicache_mem_layout, ++ allocator_type=_get_allocator_type(server_args), ++ ) ++ entries.append( ++ build_pool_entry( ++ name=PoolName.QSA_INDEXER, ++ host_pool=index_host_pool, ++ device_pool=qsa_device_pools[0], ++ layer_mapping=full_layer_mapping, ++ transfer_layer_num=transfer_layer_num + len(mtp_draft_device_pools), ++ ) ++ ) + host_pool_group = HostPoolGroup(entries) + cache_controller = HybridCacheController( + params.token_to_kv_pool_allocator, +@@ -1279,9 +1309,22 @@ + enable_storage_metrics=False, + ): + from sglang.srt.mem_cache.base_prefix_cache import EvictParams ++ from sglang.srt.mem_cache.qsa_kv_pool import QSATokenToKVPool + + full_layer_mapping = dict(kvcache.full_attention_layer_id_mapping) + mamba_layer_mapping = dict(params.req_to_token_pool.mamba_map) ++ ++ qsa_pools = () ++ if isinstance(kvcache, QSATokenToKVPool): ++ qsa_pools = (kvcache, *params.mtp_draft_device_pools) ++ if any(not isinstance(pool, QSATokenToKVPool) for pool in qsa_pools): ++ raise ValueError("QSA HiCache requires compressed QSA draft pools") ++ if any( ++ len(pool.qsa_compressed_k_buffer_pool) != pool.full_kv_pool.layer_num ++ or pool.page_size != params.page_size ++ for pool in qsa_pools ++ ) or any(pool.full_kv_pool.layer_num != 1 for pool in qsa_pools[1:]): ++ raise ValueError("QSA HiCache target/draft index layers must match KV") + host_pool_group, cache_controller = build_hybrid_mamba_stack( + params=params, + server_args=server_args, +@@ -1298,6 +1341,7 @@ + model_name=model_name, + storage_backend_extra_config=storage_backend_extra_config, + enable_storage_metrics=enable_storage_metrics, ++ qsa_device_pools=qsa_pools, + ) + return StackBuildResult( + host_pool_group=host_pool_group, +@@ -1306,9 +1350,14 @@ + ComponentType.FULL: host_pool_group.get_pool(PoolName.KV), + ComponentType.MAMBA: host_pool_group.get_pool(PoolName.MAMBA), + }, ++ sidecars=( ++ [SidecarPoolSpec(PoolName.QSA_INDEXER, indices_from_pool=PoolName.KV)] ++ if qsa_pools ++ else [] ++ ), + register_req_to_token_counter=True, + transfer_layer_num=len(full_layer_mapping | mamba_layer_mapping), +- pools_desc="KV + MAMBA", ++ pools_desc="KV + MAMBA + QSA_INDEXER" if qsa_pools else "KV + MAMBA", + ) + + +--- a/python/sglang/srt/mem_cache/qsa_kv_pool.py ++++ b/python/sglang/srt/mem_cache/qsa_kv_pool.py +@@ -209,6 +209,7 @@ + return self.qsa_rope_position_buffer[loc.long()] + + def get_qsa_compressed_k_buffer(self, layer_id: int) -> torch.Tensor: ++ self._wait_for_layer(layer_id) + return self.qsa_compressed_k_buffer_pool[ + self._transfer_full_attention_id(layer_id) + ] +--- a/python/sglang/srt/mem_cache/qsa_pool_host.py ++++ b/python/sglang/srt/mem_cache/qsa_pool_host.py +@@ -0,0 +1,105 @@ ++"""Page-aligned HiCache storage for compressed QSA index keys.""" ++ ++from __future__ import annotations ++ ++import torch ++ ++from sglang.srt.mem_cache.memory_pool_host import DeepSeekV4PagedHostPool ++ ++ ++def qsa_index_bytes_per_token(device_pools, page_size: int) -> int: ++ total = 0 ++ for pool in device_pools: ++ ratio = pool.qsa_compress_ratio ++ if ratio <= 0 or page_size <= 1 or page_size % ratio: ++ raise ValueError( ++ "QSA HiCache requires complete compression groups per page" ++ ) ++ buffers = pool.qsa_compressed_k_buffer_pool ++ if not buffers: ++ raise ValueError("QSA HiCache requires compressed index buffers") ++ for buffer in buffers: ++ if buffer.dtype != torch.bfloat16 or buffer.ndim != 3: ++ raise ValueError("QSA HiCache requires BF16 [slot, head, dim] indices") ++ slot_bytes = buffer[0].numel() * buffer.element_size() ++ if slot_bytes % ratio: ++ raise ValueError("QSA compressed index byte size must divide the ratio") ++ total += slot_bytes // ratio ++ return total ++ ++ ++class QSAPagedHostPool(DeepSeekV4PagedHostPool): ++ """Mirror target and MTP indices using the full KV page address space.""" ++ ++ def __init__( ++ self, ++ device_pools, ++ num_host_tokens: int, ++ page_size: int, ++ layout: str, ++ *, ++ allocator_type: str = "default", ++ pin_memory: bool = True, ++ ): ++ device_pools = tuple(device_pools) ++ if ( ++ not device_pools ++ or page_size <= 1 ++ or num_host_tokens <= 0 ++ or num_host_tokens % page_size ++ ): ++ raise ValueError("QSA HiCache requires pools and a page-aligned host size") ++ if layout not in ("layer_first", "page_first", "page_first_direct"): ++ raise ValueError(f"Unsupported QSA HiCache layout: {layout}") ++ bytes_per_token = qsa_index_bytes_per_token(device_pools, page_size) ++ buffers = [] ++ item_bytes = None ++ index_shape = None ++ for pool in device_pools: ++ ratio = pool.qsa_compress_ratio ++ for buffer in pool.qsa_compressed_k_buffer_pool: ++ shape = (ratio, *buffer.shape[1:]) ++ if index_shape is not None and shape != index_shape: ++ raise ValueError("Target and draft QSA index shapes must match") ++ index_shape = shape ++ page_bytes = ( ++ page_size // ratio * buffer[0].numel() * buffer.element_size() ++ ) ++ if item_bytes is not None and page_bytes != item_bytes: ++ raise ValueError( ++ "Target and draft QSA index page shapes must match" ++ ) ++ if ( ++ not buffer.is_contiguous() ++ or buffer.numel() * buffer.element_size() % page_bytes ++ ): ++ raise ValueError( ++ "QSA index buffers must contain contiguous complete pages" ++ ) ++ item_bytes = page_bytes ++ # The reused transport copies byte rows, independent of index dtype. ++ buffers.append(buffer.view(torch.uint8).reshape(-1, page_bytes)) ++ super().__init__( ++ pool_name="qsa_indexer", ++ device_buffers=buffers, ++ item_bytes=item_bytes, ++ num_host_pages=num_host_tokens // page_size, ++ slot_page_size=page_size, ++ layout=layout, ++ allocator_type=allocator_type, ++ pin_memory=pin_memory, ++ ) ++ self.size_per_token = bytes_per_token ++ ++ def get_size_per_token(self): ++ return self.layer_num * self.item_bytes // self.slot_page_size ++ ++ def get_ksize_per_token(self): ++ return self.get_size_per_token() ++ ++ def _has_transfer_indices(self, host_indices, device_indices): ++ present = super()._has_transfer_indices(host_indices, device_indices) ++ if present and host_indices.numel() % self.slot_page_size: ++ # Partial groups would need ring state; restored prefixes end on pages. ++ raise ValueError("QSA HiCache transfers must contain complete KV pages") ++ return present diff --git a/patches/series.hicache-wip b/patches/series.hicache-wip new file mode 100644 index 0000000..0d0da53 --- /dev/null +++ b/patches/series.hicache-wip @@ -0,0 +1,3 @@ +0020-hicache-ple-state.patch +0021-hicache-file-integrity.patch +0022-hicache-qsa-sidecar.patch diff --git a/provenance/hicache-wip.json b/provenance/hicache-wip.json new file mode 100644 index 0000000..ed971d3 --- /dev/null +++ b/provenance/hicache-wip.json @@ -0,0 +1,119 @@ +{ + "status": "DRAFT / WIP: narrow state-transfer paths pass; end-to-end HiCache remains unqualified", + "base_git_commit": "93463c3466b0de9d21776fbeff95657285df8269", + "base_image": "kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", + "base_inventory": "provenance/production/runtime-files.json", + "base_inventory_sha256": "d8d9c8a32c4568a742fb59c51b9f0175fd0ad5b2e6d07d50b0f7ccf29a7ff1b7", + "source_files_before": 4391, + "source_files_after": 4392, + "patches": [ + { + "file": "0020-hicache-ple-state.patch", + "sha256": "4864c6bdec355a097e12764da72e5842369ef011af19948054b00e4e9e2c364c", + "files": { + "python/sglang/srt/mem_cache/ple_state_pool.py": { + "before": "a99b71c6e3941c060e4126c212fa9a941545d4d6614af7131681dc9b696515e2", + "after": "3364674a48d7db3a1f36690e420d42f888c50d12bb15d9b113d437b503513515" + }, + "python/sglang/srt/mem_cache/memory_pool_host.py": { + "before": "fd2b196b9bf39ae93f96afce6748ae2571c26308dbc150da452dd055f3b03125", + "after": "8a224a8434d7879c134100c1edb205a5dabb12d2d3310c68b3a720b3391e4634" + }, + "python/sglang/srt/mem_cache/memory_pool.py": { + "before": "ebcb705f37b6f78cfb730ea43c767538a4f63b719a14336f5bbac71d20ec3f7c", + "after": "b5cf490ef31e5ade34b24e6e5641b0db67f411324e065458a85c18f2f3feb46b" + }, + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py": { + "before": "bc06826aeae69fa9702469d6a8606fba6efafe66433e402f9a8fd488dfdb1096", + "after": "0c919d2416d86f30b60ff2bcc2621823c8d0021cbac6c5d3ab7dd13162a51003" + } + } + }, + { + "file": "0021-hicache-file-integrity.patch", + "sha256": "569a2cabf483ad6ecbc585ecd7791d3718b75fba80f64875e802b4b378ae5715", + "files": { + "python/sglang/srt/mem_cache/hicache_storage.py": { + "before": "de92d6c7228f3c93d889e1c054f867235055f74663b2808c5456e53ff040be86", + "after": "fd7b610e978fb84b3dc69ff47577be27796770b18c673bf0c60824521d43eea9" + }, + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py": { + "before": "0c919d2416d86f30b60ff2bcc2621823c8d0021cbac6c5d3ab7dd13162a51003", + "after": "c6ddda7a329f84b99e31629c415eaca82360c6c95b83469ac2f482cca17bd5cb" + } + } + }, + { + "file": "0022-hicache-qsa-sidecar.patch", + "sha256": "a0972e94c8b31cec72dd249947fd1e9dc77adc7dab655db062be373064912db2", + "files": { + "python/sglang/srt/mem_cache/hicache_storage.py": { + "before": "fd7b610e978fb84b3dc69ff47577be27796770b18c673bf0c60824521d43eea9", + "after": "09f53cb53e4359d369a072470c54bc2fcc1141ce649c05d98ffcef50f92be21d" + }, + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py": { + "before": "a348509b43c64ee979d838dfd7c6ee3350b6617edb608ccb0f593f7af86e7140", + "after": "c2fcd1f95bc5a7754ca22111748c76918729a593b784e04827520238174eb5d1" + }, + "python/sglang/srt/mem_cache/qsa_kv_pool.py": { + "before": "85e7687daee0af9506b4c0e8840ec5b4c870be6f6930a3c210cbd31bf1f84412", + "after": "9a07709e8c6b05858d13f9418984e27916cfcb2c21cd2619c25f0db361035e29" + }, + "python/sglang/srt/mem_cache/qsa_pool_host.py": { + "before": null, + "after": "b32eaab324d52ecef8e66e28dd2d270a8543b2a30cf7ab2145f0ac8d1fb38b07" + } + } + } + ], + "files": { + "python/sglang/srt/mem_cache/hicache_storage.py": { + "before": "de92d6c7228f3c93d889e1c054f867235055f74663b2808c5456e53ff040be86", + "after": "09f53cb53e4359d369a072470c54bc2fcc1141ce649c05d98ffcef50f92be21d" + }, + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py": { + "before": "bc06826aeae69fa9702469d6a8606fba6efafe66433e402f9a8fd488dfdb1096", + "after": "c6ddda7a329f84b99e31629c415eaca82360c6c95b83469ac2f482cca17bd5cb" + }, + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py": { + "before": "a348509b43c64ee979d838dfd7c6ee3350b6617edb608ccb0f593f7af86e7140", + "after": "c2fcd1f95bc5a7754ca22111748c76918729a593b784e04827520238174eb5d1" + }, + "python/sglang/srt/mem_cache/memory_pool.py": { + "before": "ebcb705f37b6f78cfb730ea43c767538a4f63b719a14336f5bbac71d20ec3f7c", + "after": "b5cf490ef31e5ade34b24e6e5641b0db67f411324e065458a85c18f2f3feb46b" + }, + "python/sglang/srt/mem_cache/memory_pool_host.py": { + "before": "fd2b196b9bf39ae93f96afce6748ae2571c26308dbc150da452dd055f3b03125", + "after": "8a224a8434d7879c134100c1edb205a5dabb12d2d3310c68b3a720b3391e4634" + }, + "python/sglang/srt/mem_cache/ple_state_pool.py": { + "before": "a99b71c6e3941c060e4126c212fa9a941545d4d6614af7131681dc9b696515e2", + "after": "3364674a48d7db3a1f36690e420d42f888c50d12bb15d9b113d437b503513515" + }, + "python/sglang/srt/mem_cache/qsa_kv_pool.py": { + "before": "85e7687daee0af9506b4c0e8840ec5b4c870be6f6930a3c210cbd31bf1f84412", + "after": "9a07709e8c6b05858d13f9418984e27916cfcb2c21cd2619c25f0db361035e29" + }, + "python/sglang/srt/mem_cache/qsa_pool_host.py": { + "before": null, + "after": "b32eaab324d52ecef8e66e28dd2d270a8543b2a30cf7ab2145f0ac8d1fb38b07" + } + }, + "result_inventory_sha256": "8421600e954b264a7f6d3b8ecd4ba275d7baa375c8593d86ed3fd1a42d747428", + "retained_validation": { + "cpu_unique_tests": "55 passed in the packaged PLE, file, and QSA fixture suite", + "gpu_ple": "24 per-card kernel-transfer cases plus one combined asynchronous target/draft/recurrent checkpoint case passed; 6 direct-copy cases were excluded after matching parent failures", + "gpu_file": "one real GPU to RAM to reconstructed-file checkpoint case passed", + "gpu_qsa": "4 per card: target/draft relocation, two layouts, RAM and reconstructed file storage", + "live_restore": "cold 4/4, storage 4/4, GPU replay 4/4; QSA added 81,788,928 restored bytes (832 bytes/token)" + }, + "known_blockers": [ + "A later ordinary 200-tool catalogue/replay run passed only 32/48 with repeated punctuation.", + "That failing run recorded no new host or storage reads, so the corruption is not attributed solely to restored cache data.", + "Instrumented diagnostics observed NaNs in CUDA-graph draft extension; causation and a safe fix remain unresolved.", + "No production deployment or merge qualification is claimed; HiCache must remain disabled." + ], + "base_profile": "production-chat-effort", + "chat_effort_manifest_sha256": "460ba43bc10bee3dc1367807aca353b4f195e78986d974d521d2332f8c08410d" +} diff --git a/scripts/test_hicache_wip.sh b/scripts/test_hicache_wip.sh new file mode 100755 index 0000000..504a813 --- /dev/null +++ b/scripts/test_hicache_wip.sh @@ -0,0 +1,46 @@ +#!/usr/bin/env bash +set -euo pipefail + +RED='\033[0;31m' +YELLOW='\033[1;33m' +GRAY='\033[0;90m' +NC='\033[0m' + +run() { + printf >&2 "${GRAY}$(pwd) >${NC} " + printf >&2 "${YELLOW}" + printf >&2 "%q " "$@" + printf >&2 "${NC}\n" + + "$@" || { + local exit_code=$? + printf >&2 "${RED}Command failed with exit code %s: %s${NC}\n" "$exit_code" "$1" + return "$exit_code" + } +} + +cd "$(dirname "$0")/.." +PYTHON="${PYTHON:-python3}" + +run "$PYTHON" scripts/verify_hicache_wip.py +run "$PYTHON" -m unittest tests/test_hicache_wip_packaging.py -v + +if [[ -n "${HICACHE_WIP_IMAGE:-}" ]]; then + run docker run --rm --pull never --network none --read-only \ + --user "$(id -u):$(id -g)" \ + --memory 4g --cpus 4 --pids-limit 512 --cap-drop ALL \ + --tmpfs /tmp:rw,noexec,nosuid,size=1g,mode=1777 \ + -e HOME=/tmp/hicache-home \ + -e SGLANG_CACHE_DIR=/tmp/hicache-cache \ + -e PYTHONDONTWRITEBYTECODE=1 \ + -e SGLANG_DEVICE=cpu \ + -e QWEN_HICACHE_TEST_DEVICE=cpu \ + -e PYTHONPATH=/hicache-tests:/sgl-workspace/sglang/python \ + -v "$(pwd)/validation/hicache:/hicache-tests:ro" \ + --entrypoint python3 "$HICACHE_WIP_IMAGE" -c \ + 'from sglang.test.test_utils import maybe_stub_sgl_kernel; maybe_stub_sgl_kernel(); import pytest,sys; sys.exit(pytest.main(sys.argv[1:]))' \ + /hicache-tests/test_hicache_ple_local.py \ + /hicache-tests/test_hicache_file_local.py \ + /hicache-tests/test_hicache_qsa_local.py \ + -q -p no:cacheprovider +fi diff --git a/scripts/verify_hicache_wip.py b/scripts/verify_hicache_wip.py new file mode 100755 index 0000000..68351f0 --- /dev/null +++ b/scripts/verify_hicache_wip.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python3 +"""Verify the isolated, unqualified HiCache patch profile.""" + +import argparse +import hashlib +import json +from pathlib import Path +import subprocess + + +ROOT = Path(__file__).resolve().parents[1] + + +def digest(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def inventory_hash(inventory: dict[str, str]) -> str: + payload = (json.dumps(dict(sorted(inventory.items())), indent=2) + "\n").encode() + return hashlib.sha256(payload).hexdigest() + + +def base_inventory() -> dict[str, str]: + records = json.loads( + (ROOT / "provenance/production/runtime-files.json").read_text() + ) + inventory = {name: row["sha256"] for name, row in records.items()} + effort_path = ROOT / "provenance/chat-effort.json" + effort = json.loads(effort_path.read_text()) + manifest = json.loads((ROOT / "provenance/hicache-wip.json").read_text()) + if digest(effort_path) != manifest["chat_effort_manifest_sha256"]: + raise ValueError("Chat-effort parent manifest digest mismatch") + for name, hashes in effort["files"].items(): + if inventory.get(name) != hashes["before"]: + raise ValueError("Chat-effort parent transition mismatch: " + name) + inventory[name] = hashes["after"] + return inventory + + +def apply_patch(tree: Path, patch: Path) -> None: + subprocess.run(["git", "apply", "--check", str(patch)], cwd=tree, check=True) + subprocess.run(["git", "apply", str(patch)], cwd=tree, check=True) + + +def package_records() -> tuple[dict, dict[str, str]]: + manifest_path = ROOT / "provenance/hicache-wip.json" + manifest = json.loads(manifest_path.read_text()) + base_path = ROOT / manifest["base_inventory"] + if digest(base_path) != manifest["base_inventory_sha256"]: + raise ValueError("Base inventory digest mismatch") + + inventory = base_inventory() + if len(inventory) != manifest["source_files_before"]: + raise ValueError("Base source count mismatch") + + series = (ROOT / "patches/series.hicache-wip").read_text().splitlines() + if series != [row["file"] for row in manifest["patches"]]: + raise ValueError("HiCache patch order differs") + + initial = dict(inventory) + changed_paths: set[str] = set() + for patch_record in manifest["patches"]: + patch = ROOT / "patches" / patch_record["file"] + if digest(patch) != patch_record["sha256"]: + raise ValueError("HiCache patch hash mismatch: " + patch.name) + for name, hashes in patch_record["files"].items(): + if inventory.get(name) != hashes["before"]: + raise ValueError("HiCache patch transition mismatch: " + name) + inventory[name] = hashes["after"] + changed_paths.add(name) + + if changed_paths != set(manifest["files"]): + raise ValueError("HiCache changed-path manifest differs") + for name, hashes in manifest["files"].items(): + if initial.get(name) != hashes["before"] or inventory[name] != hashes["after"]: + raise ValueError("HiCache cumulative file transition mismatch: " + name) + if len(inventory) != manifest["source_files_after"]: + raise ValueError("Result source count mismatch") + if inventory_hash(inventory) != manifest["result_inventory_sha256"]: + raise ValueError("Result inventory digest mismatch") + return manifest, inventory + + +def verify_tree(tree: Path, inventory: dict[str, str]) -> None: + actual = { + str(path.relative_to(tree)) + for path in (tree / "python/sglang").rglob("*") + if path.is_file() and "__pycache__" not in path.parts and path.suffix != ".pyc" + } + if actual != set(inventory): + raise ValueError("Full source inventory differs") + for name, expected in inventory.items(): + if digest(tree / name) != expected: + raise ValueError("Source hash mismatch: " + name) + + +def verify(tree: Path, should_apply: bool) -> int: + manifest, result = package_records() + if should_apply: + verify_tree(tree, base_inventory()) + for patch_record in manifest["patches"]: + apply_patch(tree, ROOT / "patches" / patch_record["file"]) + verify_tree(tree, result) + return len(result) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--tree", type=Path) + parser.add_argument("--apply", action="store_true") + args = parser.parse_args() + if args.apply and args.tree is None: + parser.error("--apply requires --tree") + if args.tree is None: + manifest, _ = package_records() + changed = len(manifest["files"]) + source_files = manifest["source_files_after"] + full_tree = False + else: + source_files = verify(args.tree.resolve(), args.apply) + changed = len(package_records()[0]["files"]) + full_tree = True + print( + json.dumps( + { + "profile": "hicache-wip", + "status": "unqualified", + "clean_patch_apply": bool(args.tree is not None and args.apply), + "patch_chain_verified": True, + "changed_source_files": changed, + "source_files": source_files, + "full_tree_verified": full_tree, + } + ) + ) diff --git a/tests/test_hicache_wip_packaging.py b/tests/test_hicache_wip_packaging.py new file mode 100644 index 0000000..deb0fc2 --- /dev/null +++ b/tests/test_hicache_wip_packaging.py @@ -0,0 +1,78 @@ +"""Fail-closed checks for the isolated, unqualified HiCache profile.""" + +import importlib.util +from pathlib import Path +import unittest +from unittest.mock import patch + + +ROOT = Path(__file__).resolve().parents[1] +SPEC = importlib.util.spec_from_file_location( + "hicache_wip_verifier", ROOT / "scripts/verify_hicache_wip.py" +) +assert SPEC is not None and SPEC.loader is not None +VERIFIER = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(VERIFIER) + + +class HiCacheWipPackagingTest(unittest.TestCase): + def test_patch_chain_and_result_inventory(self): + manifest, inventory = VERIFIER.package_records() + self.assertEqual(manifest["status"].split(":", 1)[0], "DRAFT / WIP") + self.assertEqual(len(inventory), 4392) + self.assertEqual( + [row["file"] for row in manifest["patches"]], + [ + "0020-hicache-ple-state.patch", + "0021-hicache-file-integrity.patch", + "0022-hicache-qsa-sidecar.patch", + ], + ) + + def test_new_qsa_sidecar_is_the_only_new_source(self): + manifest, _ = VERIFIER.package_records() + added = [name for name, row in manifest["files"].items() if row["before"] is None] + self.assertEqual( + added, ["python/sglang/srt/mem_cache/qsa_pool_host.py"] + ) + + def test_patch_paths_match_the_manifest(self): + manifest, _ = VERIFIER.package_records() + for row in manifest["patches"]: + with self.subTest(patch=row["file"]): + lines = (ROOT / "patches" / row["file"]).read_text().splitlines() + paths = { + line.removeprefix("+++ b/") + for line in lines + if line.startswith("+++ b/") + } + self.assertEqual(paths, set(row["files"])) + + def test_every_patch_fails_closed_on_drift(self): + manifest, _ = VERIFIER.package_records() + original = VERIFIER.digest + for row in manifest["patches"]: + with self.subTest(patch=row["file"]): + target = ROOT / "patches" / row["file"] + + def changed(path, *, target=target): + return "0" * 64 if path == target else original(path) + + with patch.object(VERIFIER, "digest", side_effect=changed): + with self.assertRaisesRegex(ValueError, "patch hash mismatch"): + VERIFIER.package_records() + + def test_default_profiles_do_not_include_hicache_wip(self): + for name in ("series", "series.production", "series.responses-compat"): + series = (ROOT / "patches" / name).read_text() + self.assertNotIn("hicache", series.lower()) + dockerfile = (ROOT / "Dockerfile.hicache-wip").read_text() + self.assertIn("EXPERIMENTAL", dockerfile) + self.assertIn( + "sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", + dockerfile, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/validation/hicache/test_hicache_file_gpu_local.py b/validation/hicache/test_hicache_file_gpu_local.py new file mode 100644 index 0000000..c25e3a4 --- /dev/null +++ b/validation/hicache/test_hicache_file_gpu_local.py @@ -0,0 +1,42 @@ +"""Real Qwen-shaped GPU↔RAM↔file checkpoints, including packed MTP and PLE.""" + +import os + +from sglang.srt.mem_cache.hicache_storage import PoolName, PoolTransfer +from test_hicache_file_local import storage +from test_hicache_ple_gpu_local import exercise_async_checkpoint + + +def test_gpu_disk_checkpoint_survives_backend_reconstruction(tmp_path): + rank = int(os.environ.get("QWEN_HICACHE_TP_RANK", "0")) + + def roundtrip(kv_host, state_host, kv_rows, state_rows, epoch): + def reopen(): + backend = storage(tmp_path, rank) + backend.register_mem_host_pool_v2(kv_host, PoolName.KV) + backend.register_mem_host_pool_v2(state_host, PoolName.MAMBA) + return backend + + transfers = [ + PoolTransfer(PoolName.KV, host_indices=kv_rows, keys=[str(epoch)]), + PoolTransfer(PoolName.MAMBA, host_indices=state_rows, keys=[str(epoch)]), + ] + assert reopen().batch_set_v2(transfers) == { + PoolName.KV: [True], + PoolName.MAMBA: [True], + } + kv_host.kv_buffer.zero_() + for tensor in state_host.get_hybrid_pool_buffer(): + tensor.zero_() + backend = reopen() + expected_bytes = (epoch + 1) * ( + 64 * kv_host.size_per_token + state_host.size_per_token + ) + assert backend._evictor._total_bytes == expected_bytes + assert backend._evictor._total_bytes <= backend._evictor.max_size_bytes + assert backend.batch_get_v2(transfers) == { + PoolName.KV: [True], + PoolName.MAMBA: [True], + } + + exercise_async_checkpoint(disk_roundtrip=roundtrip) diff --git a/validation/hicache/test_hicache_file_local.py b/validation/hicache/test_hicache_file_local.py new file mode 100644 index 0000000..b4c0e93 --- /dev/null +++ b/validation/hicache/test_hicache_file_local.py @@ -0,0 +1,237 @@ +"""Disk feasibility probes against the bundled file backend; no serving changes.""" + +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +from queue import Queue +import threading +from unittest.mock import Mock + +import pytest +import torch + +from sglang.srt.managers.cache_controller import HiCacheController, PrefetchOperation +from sglang.srt.mem_cache.hybrid_cache.hybrid_cache_controller import ( + HybridCacheController, +) +from sglang.srt.mem_cache.hicache_storage import ( + HiCacheFile, + HiCacheStorageConfig, + PoolName, + PoolTransfer, +) +from sglang.srt.mem_cache.memory_pool_host import HostPoolGroup, PoolEntry +from test_hicache_ple_local import assert_state, make_pool, poison, snapshot + +pytest_plugins = ["test_hicache_ple_local"] + + +def storage(path, rank=0, cap=256_000_000, metadata=True): + return HiCacheFile( + HiCacheStorageConfig( + tp_rank=rank, + tp_size=2, + pp_rank=0, + pp_size=1, + attn_cp_rank=0, + attn_cp_size=1, + is_mla_model=False, + enable_storage_metrics=False, + is_page_first_layout=True, + model_name="qwen-ple-file-probe", + extra_config={ + "max_size": cap, + "min_free_space": 0, + "eviction_ratio": 0.9, + "enable_metadata_cache": metadata, + }, + ), + file_path=str(path), + ) + + +@pytest.mark.parametrize("rank", [0, 1]) +@pytest.mark.parametrize("metadata", [False, True]) +def test_file_restart_restores_ple_and_recurrent_state( + tmp_path, device, host_factory, rank, metadata +): + tmp_path.mkdir(exist_ok=True) + pool = make_pool(device) + host = host_factory(pool) + src, dst = torch.tensor([1], device=device), torch.tensor([5], device=device) + rows = host.alloc(1) + expected = snapshot(pool, src) + host.backup_from_device_all_layer(pool, rows, src) + backend = storage(tmp_path, rank, metadata=metadata) + assert backend._evictor.max_size_bytes == 256_000_000 + backend.register_mem_host_pool_v2(host, PoolName.MAMBA) + transfer = PoolTransfer(PoolName.MAMBA, host_indices=rows, keys=["checkpoint"]) + assert backend.batch_set_v2([transfer]) == {PoolName.MAMBA: [True]} + for tensor in host.get_hybrid_pool_buffer(): + tensor.fill_(0) + poison(pool, dst) + + # Reconstruct storage metadata from disk; no in-memory backend state survives. + backend = storage(tmp_path, rank, metadata=metadata) + assert backend._evictor._total_bytes == host.size_per_token + backend.register_mem_host_pool_v2(host, PoolName.MAMBA) + assert backend.batch_get_v2([transfer]) == {PoolName.MAMBA: [True]} + for layer in range(pool.num_mamba_layers): + host.load_to_device_per_layer(pool, rows, dst, layer) + assert_state(pool, dst, expected) + + +def test_two_rank_limits_bound_aggregate_and_survive_restart(tmp_path): + per_rank = 1024 + ranks = [storage(tmp_path, rank, per_rank) for rank in (0, 1)] + + def fill(rank): + for i in range(20): + assert ranks[rank].set( + str(i), torch.full((128,), rank + 1, dtype=torch.uint8) + ) + assert ranks[rank]._evictor._total_bytes <= per_rank + + with ThreadPoolExecutor(max_workers=2) as executor: + list(executor.map(fill, (0, 1))) + assert sum(p.stat().st_size for p in tmp_path.glob("*.bin")) <= 2 * per_rank + assert not list(tmp_path.glob("*.tmp.*")) + for rank in (0, 1): + reopened = storage(tmp_path, rank, per_rank) + assert reopened._evictor._total_bytes <= per_rank + page = reopened.get("19", torch.zeros(128, dtype=torch.uint8)) + assert torch.all(page == rank + 1) + + +def test_rejects_value_larger_than_rank_cap(tmp_path): + backend = storage(tmp_path, cap=64) + assert not backend.set("oversized", torch.ones(65, dtype=torch.uint8)) + assert not list(tmp_path.glob("*.bin")) + assert backend._evictor._total_bytes == 0 + + +def test_missing_file_is_cache_miss(tmp_path): + assert storage(tmp_path).get("missing", torch.zeros(32, dtype=torch.uint8)) is None + + +def test_short_file_is_cache_miss(tmp_path): + backend = storage(tmp_path) + assert backend.set("short", torch.ones(16, dtype=torch.uint8)) + assert backend.get("short", torch.zeros(32, dtype=torch.uint8)) is None + + +def test_disk_read_error_is_cache_miss(tmp_path, monkeypatch): + backend = storage(tmp_path) + assert backend.set("io-error", torch.ones(16, dtype=torch.uint8)) + target = Path(backend._get_component_path("io-error")) + original = open + + def read_error(path, mode="r", *args, **kwargs): + if Path(path) == target and mode == "rb": + raise OSError(5, "injected disk read error") + return original(path, mode, *args, **kwargs) + + monkeypatch.setattr("builtins.open", read_error) + assert backend.get("io-error", torch.zeros(16, dtype=torch.uint8)) is None + + +def test_failed_write_rolls_back_reservation(tmp_path, monkeypatch): + backend = storage(tmp_path, cap=1024) + + def rename_error(*args): + raise OSError(28, "injected filesystem full") + + monkeypatch.setattr("os.replace", rename_error) + assert not backend.set("failed", torch.ones(128, dtype=torch.uint8)) + assert backend._evictor._total_bytes == 0 + assert not backend._evictor._pending_writes + assert not list(tmp_path.iterdir()) + + +def test_prefetch_worker_continues_after_short_read(tmp_path, device, host_factory): + host = host_factory(make_pool(device)) + rows = host.alloc(2) + backend = storage(tmp_path) + assert backend.set("broken", torch.zeros(1, dtype=torch.uint8)) + expected = torch.full_like(host.get_dummy_flat_data_page(), 17) + assert backend.set("valid", expected) + controller = HiCacheController.__new__(HiCacheController) + controller.storage_backend, controller.mem_pool_host = backend, host + controller.page_size, controller.has_draft = 1, False + controller.page_get_func = controller._generic_page_get + controller.storage_stop_event = threading.Event() + controller.prefetch_buffer, controller.host_mem_release_queue = Queue(), Queue() + operations = [] + for i, key in enumerate(["broken", "valid"]): + op = PrefetchOperation(key, [i]) + op.hash_value, op.host_indices = [key], rows[i : i + 1] + operations.append(op) + controller.prefetch_buffer.put(op) + finished = threading.Event() + increment = operations[1].increment + + def completed(n): + result = increment(n) + finished.set() + return result + + operations[1].increment = completed + errors = [] + + def work(): + try: + controller.prefetch_io_aux_func() + except Exception as error: + errors.append(error) + + worker = threading.Thread(target=work) + worker.start() + try: + assert finished.wait(3), ( + "Prefetch worker did not reach the next valid page", + errors, + ) + finally: + controller.storage_stop_event.set() + controller.prefetch_buffer.put(None) + worker.join(3) + assert not worker.is_alive() and not errors + assert operations[0].is_terminated() and operations[0].completed_tokens == 0 + assert operations[1].completed_tokens == 1 + assert controller.host_mem_release_queue.qsize() == 1 + assert torch.equal(host.get_data_page(rows[1].item()), expected) + + +@pytest.mark.parametrize("late", [False, True]) +def test_file_attachment_allows_complete_checkpoint( + tmp_path, device, host_factory, monkeypatch, late +): + host = host_factory(make_pool(device)) + backend = storage(tmp_path) + controller = HybridCacheController.__new__(HybridCacheController) + anchor = PoolEntry(PoolName.KV, host, host.device_pool, lambda n: n, True) + controller.mem_pool_host = HostPoolGroup([anchor]) + controller.storage_backend, controller.enable_storage = backend, True + controller.extra_host_mem_release_queues = {} + entry = PoolEntry(PoolName.MAMBA, host, host.device_pool, lambda n: n) + if late: + controller.register_host_pool_entry(entry) + assert controller.mem_pool_host.entry_map[PoolName.MAMBA] is entry + else: + base_attach = Mock() + monkeypatch.setattr( + HybridCacheController.__mro__[1], "attach_storage_backend", base_attach + ) + controller.attach_storage_backend("file", host_pools=[entry]) + base_attach.assert_called_once() + assert backend.registered_pools[PoolName.MAMBA] is host + + +def test_metadata_queries_do_not_scan_the_entire_cache(tmp_path, monkeypatch): + backend = storage(tmp_path) + assert backend.set("prefix", torch.ones(32, dtype=torch.uint8)) + scan = Mock( + side_effect=AssertionError("A prefix lookup must not scan a 512GB directory") + ) + monkeypatch.setattr("os.scandir", scan) + assert backend.batch_exists_v2(["prefix"]).kv_hit_pages == 1 + scan.assert_not_called() diff --git a/validation/hicache/test_hicache_ple_gpu_local.py b/validation/hicache/test_hicache_ple_gpu_local.py new file mode 100644 index 0000000..cc33c39 --- /dev/null +++ b/validation/hicache/test_hicache_ple_gpu_local.py @@ -0,0 +1,192 @@ +"""CUDA-only integration checks with Qwen TP2 state shapes and real transfers.""" + +import torch + +from sglang.srt.managers.cache_controller import CacheOperation, LayerDoneCounter +from sglang.srt.mem_cache.hicache_storage import PoolName, PoolTransfer +from sglang.srt.mem_cache.hybrid_cache.hybrid_cache_controller import ( + HybridCacheController, +) +from sglang.srt.mem_cache.l2_transfer import L2TransferEngine +from sglang.srt.mem_cache.memory_pool import ( + HybridReqToTokenPool, + MHATokenToKVPool, + MambaPool, +) +from sglang.srt.mem_cache.memory_pool_host import ( + HostPoolGroup, + MambaPoolHost, + PoolEntry, +) +from sglang.srt.mem_cache.ple_state_pool import NGramPool, ShortConvPool +from sglang.srt.mem_cache.pool_host.mha import MHATokenToKVPoolHost + +from test_hicache_ple_local import assert_state, poison, snapshot, tensors + + +def make_kv(layer_num): + # Synthetic values, but the serving pool's exact FP8 byte layout and geometry. + pool = MHATokenToKVPool.__new__(MHATokenToKVPool) + pool.size, pool.page_size = 256, 64 + pool.dtype, pool.store_dtype = torch.float8_e4m3fn, torch.uint8 + pool.layer_num, pool.start_layer, pool.end_layer = layer_num, 0, layer_num + pool.head_num, pool.head_dim, pool.device = 1, 256, "cuda" + pool.k_buffer = [ + torch.zeros((320, 1, 256), dtype=torch.uint8, device="cuda") + for _ in range(layer_num) + ] + pool.v_buffer = [torch.zeros_like(x) for x in pool.k_buffer] + pool.k_data_ptrs = torch.tensor( + [x.data_ptr() for x in pool.k_buffer], dtype=torch.uint64, device="cuda" + ) + pool.v_data_ptrs = torch.tensor( + [x.data_ptr() for x in pool.v_buffer], dtype=torch.uint64, device="cuda" + ) + return pool + + +def make_qwen_state(): + pool = MambaPool.__new__(MambaPool) + pool.size, pool.num_mamba_layers, pool.device = 7, 36, "cuda" + pool.mamba_layer_ids = [layer for layer in range(48) if layer % 4 != 3] + pool.mamba_cache = MambaPool.State( + conv=[torch.zeros((36, 8, 5120, 3), dtype=torch.bfloat16, device="cuda")], + temporal=torch.zeros( + (36, 8, 24, 128, 128), dtype=torch.bfloat16, device="cuda" + ), + ) + conv = ShortConvPool.__new__(ShortConvPool) + conv.conv_state = torch.zeros((1, 8, 10240, 9), dtype=torch.bfloat16, device="cuda") + conv.layer_map = {2: 0} + ngram = NGramPool.__new__(NGramPool) + ngram.context = torch.zeros((8, 2), dtype=torch.int64, device="cuda") + pool._slot_siblings, pool.replayssm_cache_base = [conv, ngram], None + return pool + + +def exercise_async_checkpoint(disk_roundtrip=None): + assert torch.cuda.is_available(), "This integration check requires real CUDA" + main, draft, recurrent = make_kv(12), make_kv(1), make_qwen_state() + made = [] + try: + kv_host = MHATokenToKVPoolHost( + main, 2, 0, 64, "page_first", mtp_draft_device_pools=(draft,) + ) + made.append(kv_host) + state_host = MambaPoolHost(recurrent, 2, 0, layout="page_first") + made.append(state_host) + kv_map = {layer: i for i, layer in enumerate(range(3, 48, 4))} + kv_map[48] = 12 + state_map = {layer: i for i, layer in enumerate(recurrent.mamba_layer_ids)} + controller = HybridCacheController.__new__(HybridCacheController) + controller.mem_pool_host = HostPoolGroup( + [ + PoolEntry(PoolName.KV, kv_host, main, kv_map.get, True), + PoolEntry(PoolName.MAMBA, state_host, recurrent, state_map.get), + ] + ) + controller.has_draft, controller.has_mtp_draft = False, True + controller.mtp_draft_device_pools = (draft,) + controller.layer_num, controller.io_backend, controller.device = ( + 48, + "kernel", + "cuda", + ) + counter, engine = LayerDoneCounter(48), L2TransferEngine("kernel") + request_pool = HybridReqToTokenPool.__new__(HybridReqToTokenPool) + request_pool.start_layer, request_pool.mamba_map = 0, state_map + request_pool.layer_transfer_counter = counter + request_pool.short_conv_pool, request_pool.ngram_pool = recurrent._slot_siblings + kv_rows, state_rows = kv_host.alloc(64), state_host.alloc(1) + kv_src, kv_dst = torch.arange(64, device="cuda"), torch.arange( + 128, 192, device="cuda" + ) + state_src, state_dst = torch.tensor([1], device="cuda"), torch.tensor( + [4, 5], device="cuda" + ) + all_kv = main.k_buffer + main.v_buffer + draft.k_buffer + draft.v_buffer + assert kv_host.layer_num == 13 + assert kv_host.size_per_token == 13 * 2 * 256 + assert ( + state_host.size_per_token + == 36 * (5120 * 3 + 24 * 128 * 128) * 2 + 10240 * 9 * 2 + 2 * 8 + ) + assert ( + sum( + t.numel() * t.element_size() + for t in state_host.get_hybrid_pool_buffer() + ) + == state_host.size * state_host.size_per_token + ) + + # Reuse slots and wrap the actual three-event producer/consumer ring. + for epoch in range(4): + for i, tensor in enumerate(all_kv): + tensor[kv_src] = ( + torch.arange(64, device="cuda")[:, None, None] + 7 * i + epoch + ).to(torch.uint8) + for i, tensor in enumerate(tensors(recurrent).values()): + tensor[:, state_src] = epoch + i + 21 + expected_kv = [t[kv_src].clone() for t in all_kv] + expected_state = { + k: v.repeat(1, 2, *([1] * (v.ndim - 2))) + for k, v in snapshot(recurrent, state_src).items() + } + write_op = CacheOperation( + kv_rows, + kv_src, + epoch, + pool_transfers=[PoolTransfer(PoolName.MAMBA, state_rows, state_src)], + ) + write_args = controller._move_write_operation(write_op) + written = engine.submit_device_to_host( + controller._l2_transfers(*write_args) + ) + written.finish_event.synchronize() + if disk_roundtrip is not None: + disk_roundtrip(kv_host, state_host, kv_rows, state_rows, epoch) + for tensor in all_kv: + tensor[kv_dst] = 255 + poison(recurrent, state_dst) + + load_op = CacheOperation( + kv_rows, + kv_dst, + epoch, + pool_transfers=[ + PoolTransfer(PoolName.MAMBA, state_rows.repeat(2), state_dst) + ], + ) + load_args = controller.move_hybrid_indices(load_op) + transfers = controller._l2_load_transfers(*load_args) + assert len(transfers) == 3 and transfers[-1].is_draft + event_index = counter.update_producer() + counter.set_consumer(event_index) + with torch.cuda.stream(engine.host_to_device_stream): + torch.cuda._sleep(20_000_000) + restored = engine.submit_host_to_device( + transfers, + layer_num=48, + on_layer_done=counter.events[event_index].complete, + ) + + # Capture PLE reads before any host-side synchronization of the restore. + early_ngram = request_pool.get_ngram_context(state_dst).clone() + early_conv = request_pool.short_conv_layer_cache(2)[state_dst].clone() + torch.cuda.current_stream().synchronize() + assert torch.equal(early_ngram, expected_state["ple_ngram"][0]) + assert torch.equal(early_conv, expected_state["ple_conv"][0]) + restored.finish_event.synchronize() + assert_state(recurrent, state_dst, expected_state) + for actual, expected in zip(all_kv, expected_kv): + assert torch.equal(actual[kv_dst], expected) + assert kv_host.available_size() == kv_host.size - 64 + assert state_host.available_size() == state_host.size - 1 + finally: + torch.cuda.synchronize() + for host in made: + host.destroy() + + +def test_async_qwen_main_draft_mamba_and_ple_checkpoint(): + exercise_async_checkpoint() diff --git a/validation/hicache/test_hicache_ple_local.py b/validation/hicache/test_hicache_ple_local.py new file mode 100644 index 0000000..b302938 --- /dev/null +++ b/validation/hicache/test_hicache_ple_local.py @@ -0,0 +1,420 @@ +"""PLE checkpoint correctness on CPU fixtures and real CUDA transfers.""" + +import os +from types import SimpleNamespace +from unittest.mock import Mock + +import pytest +import torch + +if os.environ.get("QWEN_HICACHE_TEST_DEVICE", "cpu") == "cpu": + from sglang.test.test_utils import maybe_stub_sgl_kernel + + maybe_stub_sgl_kernel() + +from sglang.srt.mem_cache import memory_pool_host as host_module +from sglang.srt.mem_cache.hybrid_cache.hybrid_cache_controller import ( + HybridCacheController, +) +from sglang.srt.mem_cache.memory_pool import HybridReqToTokenPool, MambaPool +from sglang.srt.mem_cache.memory_pool_host import HostPoolGroup, MambaPoolHost +from sglang.srt.mem_cache.ple_state_pool import NGramPool, ShortConvPool + + +@pytest.fixture +def device(): + d = torch.device(os.environ.get("QWEN_HICACHE_TEST_DEVICE", "cpu")) + if d.type == "cuda": + assert torch.cuda.is_available(), "Requested CUDA tests must run, not skip" + return d + + +def sync(device): + if device.type == "cuda": + torch.cuda.synchronize(device) + + +def io_indices(indices, backend): + # HiCacheController.move_indices keeps direct-copy indices on the CPU. + return indices.cpu() if backend == "direct" else indices + + +def pattern(shape, dtype, device, offset=0): + count = 1 + for n in shape: + count *= n + return ((torch.arange(count, device=device) % 97) + offset).to(dtype).reshape(shape) + + +def make_pool(device, companions=True): + pool = MambaPool.__new__(MambaPool) + pool.size = 7 + pool.num_mamba_layers = 3 + pool.mamba_layer_ids = [0, 2, 3] + pool.device = device.type + pool.mamba_cache = MambaPool.State( + conv=[pattern((3, 8, 12, 4), torch.bfloat16, device, 2)], + temporal=pattern((3, 8, 2, 8, 8), torch.bfloat16, device, 4), + ) + conv = ShortConvPool.__new__(ShortConvPool) + conv.conv_state = pattern((2, 8, 8, 4), torch.bfloat16, device, 6) + conv.layer_map = {1: 0, 3: 1} + ngram = NGramPool.__new__(NGramPool) + ngram.context = pattern((8, 2), torch.int64, device, 1000) + pool._slot_siblings = [conv, ngram] if companions else [] + pool.replayssm_cache_base = None + return pool + + +def tensors(pool): + result = {"conv": pool.mamba_cache.conv[0], "temporal": pool.mamba_cache.temporal} + if pool._slot_siblings: + result["ple_conv"] = pool._slot_siblings[0].conv_state + result["ple_ngram"] = pool._slot_siblings[1].context.unsqueeze(0) + return result + + +def snapshot(pool, indices): + return {name: tensor[:, indices].clone() for name, tensor in tensors(pool).items()} + + +def poison(pool, indices): + for i, tensor in enumerate(tensors(pool).values(), 1): + tensor[:, indices] = -100 * i + + +def assert_state(pool, indices, expected): + for name, tensor in tensors(pool).items(): + assert torch.equal(tensor[:, indices], expected[name]), name + + +@pytest.fixture(autouse=True) +def cpu_transport(monkeypatch, device): + if device.type != "cpu": + return + + def backup(*, src_layers, dst, src_indices, dst_indices, **kwargs): + dst[dst_indices, :, 0] = src_layers[:, src_indices].transpose(0, 1) + + def restore(*, src, dst, src_indices, dst_indices, layer_id, **kwargs): + dst[dst_indices] = src[src_indices, layer_id, 0] + + # Retain real construction, state selection, allocation and lifecycle. + # CUDA runs do not replace either transport function. + monkeypatch.setattr( + MambaPoolHost, "_copy_tensor_all_layers_lf_pf", staticmethod(backup) + ) + monkeypatch.setattr(MambaPoolHost, "_copy_tensor_pf_lf", staticmethod(restore)) + + +@pytest.fixture +def host_factory(device): + made = [] + + def create(pool, layout="page_first", **kwargs): + host = MambaPoolHost( + pool, + host_to_device_ratio=2, + host_size=kwargs.pop("host_size", 0), + layout=layout, + pin_memory=device.type == "cuda", + **kwargs, + ) + made.append(host) + return host + + yield create + sync(device) + for host in made: + host.destroy() + + +@pytest.mark.parametrize( + "layout,backend", [("page_first", "kernel"), ("page_first_direct", "direct")] +) +@pytest.mark.parametrize("companions", [True, False]) +@pytest.mark.parametrize("destination", [[1, 2], [4, 5]]) +def test_complete_state_roundtrip( + device, host_factory, layout, backend, companions, destination +): + pool = make_pool(device, companions) + host = host_factory(pool, layout) + src = torch.tensor([1, 2], device=device) + dst = torch.tensor(destination, device=device) + rows = host.alloc(2) + expected = snapshot(pool, src) + host.backup_from_device_all_layer(pool, rows, io_indices(src, backend), backend) + sync(device) + poison(pool, dst) + for layer in range(pool.num_mamba_layers): + host.load_to_device_per_layer( + pool, rows, io_indices(dst, backend), layer, backend + ) + sync(device) + assert_state(pool, dst, expected) + + +@pytest.mark.parametrize( + "layout,backend", [("page_first", "kernel"), ("page_first_direct", "direct")] +) +def test_one_host_checkpoint_restores_tree_and_request_slots( + device, host_factory, layout, backend +): + pool = make_pool(device) + host = host_factory(pool, layout) + src = torch.tensor([1], device=device) + dst = torch.tensor([4, 5], device=device) + rows = host.alloc(1) + expected = { + k: v.repeat(1, 2, *([1] * (v.ndim - 2))) for k, v in snapshot(pool, src).items() + } + host.backup_from_device_all_layer(pool, rows, io_indices(src, backend), backend) + sync(device) + poison(pool, dst) + for layer in range(pool.num_mamba_layers): + host.load_to_device_per_layer( + pool, rows.repeat(2), io_indices(dst, backend), layer, backend + ) + sync(device) + assert_state(pool, dst, expected) + + +@pytest.mark.parametrize("backend", ["kernel", "direct"]) +def test_companions_ready_at_first_layer_event(device, host_factory, backend): + pool = make_pool(device) + host = host_factory( + pool, "page_first" if backend == "kernel" else "page_first_direct" + ) + src, dst = torch.tensor([1], device=device), torch.tensor([4], device=device) + rows = host.alloc(1) + expected = snapshot(pool, src) + host.backup_from_device_all_layer(pool, rows, io_indices(src, backend), backend) + sync(device) + poison(pool, dst) + host.load_to_device_per_layer(pool, rows, io_indices(dst, backend), 0, backend) + sync(device) + actual = snapshot(pool, dst) + assert torch.equal(actual["ple_conv"], expected["ple_conv"]) + assert torch.equal(actual["ple_ngram"], expected["ple_ngram"]) + assert torch.equal(actual["temporal"][0], expected["temporal"][0]) + assert torch.all(actual["temporal"][1:] == -200) + + +@pytest.mark.parametrize("companions", [True, False]) +def test_fixed_budget_counts_every_buffer(device, host_factory, companions): + pool = make_pool(device, companions) + budget = 30000 + host = host_factory(pool, host_size=budget / 1e9) + allocated = sum(t.numel() * t.element_size() for t in host.get_hybrid_pool_buffer()) + bytes_per_slot = sum( + t[:, 0].numel() * t.element_size() for t in tensors(pool).values() + ) + assert allocated == host.size * bytes_per_slot + assert budget < allocated <= budget + bytes_per_slot + assert allocated == host.size * host.size_per_token + + +def test_capacity_is_bounded_across_reuse_and_reset(device, host_factory): + pool = make_pool(device) + host = host_factory(pool) + buffer_ids = [x.data_ptr() for x in host.get_hybrid_pool_buffer()] + all_rows = host.alloc(host.size) + assert host.alloc(1) is None + src, dst = torch.tensor([1, 2], device=device), torch.tensor([4, 5], device=device) + for epoch in range(3): + rows = all_rows[:2] + for tensor in tensors(pool).values(): + tensor[:, src] = epoch + 17 + host.backup_from_device_all_layer(pool, rows, src) + sync(device) + host.free(rows) + reused = host.alloc(2) + assert torch.equal(reused, rows) + for tensor in tensors(pool).values(): + tensor[:, src] = epoch + 77 + expected = snapshot(pool, src) + host.backup_from_device_all_layer(pool, reused, src) + sync(device) + poison(pool, dst) + for layer in range(pool.num_mamba_layers): + host.load_to_device_per_layer(pool, reused, dst, layer) + sync(device) + assert_state(pool, dst, expected) + assert [x.data_ptr() for x in host.get_hybrid_pool_buffer()] == buffer_ids + host.clear() + assert host.available_size() == host.size + assert len(torch.unique(host.alloc(host.size))) == host.size + + +def test_empty_transfers_do_not_change_state(device, host_factory): + pool = make_pool(device) + host = host_factory(pool) + all_rows = torch.arange(8, device=device) + before = snapshot(pool, all_rows) + empty_device = torch.empty(0, dtype=torch.int64, device=device) + empty_host = torch.empty(0, dtype=torch.int64) + host.backup_from_device_all_layer(pool, empty_host, empty_device) + for layer in range(pool.num_mamba_layers): + host.load_to_device_per_layer(pool, empty_host, empty_device, layer) + sync(device) + assert_state(pool, all_rows, before) + + +@pytest.mark.parametrize("kind", ["short_conv", "ngram"]) +def test_disabled_companions_have_no_transfer_tensors(kind): + pool = ( + ShortConvPool.__new__(ShortConvPool) + if kind == "short_conv" + else NGramPool.__new__(NGramPool) + ) + if kind == "short_conv": + pool.conv_state = None + else: + pool.context = None + assert pool.get_slot_tensors() == () + + +@pytest.mark.parametrize( + "start,layers,ple_layer", [(0, [0, 2, 3], 1), (16, [16, 18], 17), (0, [2, 3], 0)] +) +def test_readers_wait_before_reading_restored_state(start, layers, ple_layer): + calls = [] + pool = HybridReqToTokenPool.__new__(HybridReqToTokenPool) + pool.start_layer = start + pool.mamba_map = {layer: i for i, layer in enumerate(layers)} + pool.layer_transfer_counter = SimpleNamespace( + wait_until=lambda n: calls.append(("wait", n)) + ) + pool.ngram_pool = SimpleNamespace(get_context=lambda _: calls.append(("ngram",))) + pool.short_conv_pool = SimpleNamespace( + layer_cache=lambda _: calls.append(("conv",)) + ) + pool.get_ngram_context(torch.tensor([1])) + pool.short_conv_layer_cache(ple_layer) + assert calls == [ + ("wait", min(layers) - start), + ("ngram",), + ("wait", max(ple_layer, min(layers)) - start), + ("conv",), + ] + + +def test_no_hicache_has_no_read_barrier(): + pool = HybridReqToTokenPool.__new__(HybridReqToTokenPool) + pool.layer_transfer_counter = None + pool.ngram_pool = SimpleNamespace(get_context=lambda _: "history") + pool.short_conv_pool = SimpleNamespace(layer_cache=lambda _: "conv") + assert pool.get_ngram_context(torch.tensor([1])) == "history" + assert pool.short_conv_layer_cache(1) == "conv" + + +def test_host_memory_check_includes_companions(monkeypatch, device): + pool = make_pool(device) + main_bytes = sum( + t[:, 0].numel() * t.element_size() + for t in tensors(make_pool(device, False)).values() + ) + available = host_module.HICACHE_HOST_MEMORY_RESERVE_BYTES + 15 * main_bytes + 1 + monkeypatch.setattr( + host_module.psutil, + "virtual_memory", + lambda: SimpleNamespace(available=available), + ) + allocator = Mock(side_effect=AssertionError("Must reject before host allocation")) + monkeypatch.setitem(host_module.ALLOC_MEMORY_FUNCS, device.type, allocator) + with pytest.raises(ValueError, match="Not enough host memory"): + MambaPoolHost(pool, 2, 0, layout="page_first", pin_memory=False) + allocator.assert_not_called() + + +def test_partial_allocation_releases_all_pinned_buffers(monkeypatch): + pool = make_pool(torch.device("cpu")) + made, released = [], [] + + def allocate(dims, *, dtype, **kwargs): + if len(made) == 3: + raise MemoryError("companion allocation failure") + tensor = torch.empty(dims, dtype=dtype) + made.append(tensor) + return tensor + + monkeypatch.setattr(host_module, "_is_cuda", True) + monkeypatch.setattr( + host_module, "_cuda_host_unregister", lambda t: released.append(t.data_ptr()) + ) + monkeypatch.setitem(host_module.ALLOC_MEMORY_FUNCS, "cpu", allocate) + with pytest.raises(MemoryError, match="companion allocation"): + MambaPoolHost(pool, 2, 0, layout="page_first", pin_memory=True) + assert released == [t.data_ptr() for t in made] + + +def test_destroy_is_idempotent(monkeypatch, device, host_factory): + host = host_factory(make_pool(device)) + expected = [t.data_ptr() for t in host.get_hybrid_pool_buffer()] + original = host_module._cuda_host_unregister + released = [] + + def unregister(tensor): + released.append(tensor.data_ptr()) + if device.type == "cuda": + original(tensor) + + monkeypatch.setattr(host_module, "_is_cuda", True) + monkeypatch.setattr(host_module, "_cuda_host_unregister", unregister) + host.pin_memory = True + sync(device) + host.destroy() + host.destroy() + assert released == expected + assert host.sibling_buffers == [] + + +def test_flat_state_and_pointer_metadata_cover_companions(device, host_factory): + pool = make_pool(device) + host = host_factory(pool) + rows = host.alloc(2) + host.backup_from_device_all_layer(pool, rows, torch.tensor([1, 2], device=device)) + sync(device) + for row in rows.tolist(): + page = host.get_data_page(row) + assert page.numel() == host.size_per_token + saved = page.clone() + host.set_from_flat_data_page(row, torch.zeros_like(page)) + host.set_from_flat_data_page(row, saved) + assert torch.equal(saved, host.get_data_page(row)) + pointers, lengths = host.get_page_buffer_meta(rows) + assert sum(lengths) == len(rows) * host.size_per_token + expected = [t for row in rows.tolist() for t in host._iter_page_tensors(row)] + assert pointers == [t.data_ptr() for t in expected] + assert lengths == [t.numel() * t.element_size() for t in expected] + assert not host.is_stride_page_aligned() + + +@pytest.mark.parametrize("late", [False, True]) +def test_storage_attachment_rejected_before_side_effects( + device, host_factory, monkeypatch, late +): + host = host_factory(make_pool(device)) + controller = HybridCacheController.__new__(HybridCacheController) + entry = SimpleNamespace(host_pool=host) + controller.mem_pool_host = HostPoolGroup.__new__(HostPoolGroup) + controller.mem_pool_host.entries = [] if late else [entry] + controller.mem_pool_host.add_entry = Mock() + controller.enable_storage = True + controller.storage_backend = Mock() + base_attach = Mock(side_effect=AssertionError("Storage attachment must not start")) + monkeypatch.setattr( + HybridCacheController.__mro__[1], "attach_storage_backend", base_attach + ) + with pytest.raises(NotImplementedError, match="RAM and file storage only"): + if late: + controller.register_host_pool_entry(entry) + else: + controller.attach_storage_backend("mooncake") + base_attach.assert_not_called() + controller.mem_pool_host.add_entry.assert_not_called() + + +def test_non_ple_storage_guard_is_unchanged(device, host_factory): + HybridCacheController._check_storage_pool(host_factory(make_pool(device, False))) + HybridCacheController._check_storage_pool(SimpleNamespace()) diff --git a/validation/hicache/test_hicache_qsa_gpu_local.py b/validation/hicache/test_hicache_qsa_gpu_local.py new file mode 100644 index 0000000..3e54414 --- /dev/null +++ b/validation/hicache/test_hicache_qsa_gpu_local.py @@ -0,0 +1,163 @@ +"""Real target/draft index copies with relocation, file restart and layer waits.""" + +import os + +import pytest +import torch + +from sglang.srt.managers.cache_controller import CacheOperation, LayerDoneCounter +from sglang.srt.mem_cache.hicache_storage import PoolName, PoolTransfer +from sglang.srt.mem_cache.hybrid_cache.hybrid_cache_controller import ( + HybridCacheController, +) +from sglang.srt.mem_cache.l2_transfer import L2TransferEngine +from sglang.srt.mem_cache.memory_pool_host import HostPoolGroup, PoolEntry +from sglang.srt.mem_cache.pool_host.mha import MHATokenToKVPoolHost +from sglang.srt.mem_cache.qsa_pool_host import QSAPagedHostPool + +from test_hicache_file_local import storage +from test_hicache_ple_gpu_local import make_kv +from test_hicache_qsa_local import make_index_pool + + +@pytest.mark.parametrize("layout", ["layer_first", "page_first"]) +@pytest.mark.parametrize("on_disk", [False, True]) +def test_async_qsa_target_and_draft_relocation(tmp_path, layout, on_disk): + assert torch.cuda.is_available(), "Real CUDA is required for this gate" + main, draft = make_kv(12), make_kv(1) + qsa, draft_qsa = make_index_pool(12, "cuda"), make_index_pool(1, "cuda") + made = [] + try: + kv_host = MHATokenToKVPoolHost( + main, 2, 0, 64, layout, mtp_draft_device_pools=(draft,) + ) + made.append(kv_host) + index_host = QSAPagedHostPool((qsa, draft_qsa), kv_host.size, 64, layout) + made.append(index_host) + kv_map = {layer: i for i, layer in enumerate(range(3, 48, 4))} + kv_map[48] = 12 + controller = HybridCacheController.__new__(HybridCacheController) + controller.mem_pool_host = HostPoolGroup( + [ + PoolEntry(PoolName.KV, kv_host, main, kv_map.get, True), + PoolEntry(PoolName.QSA_INDEXER, index_host, qsa, kv_map.get), + ] + ) + controller.has_draft, controller.has_mtp_draft = False, True + controller.mtp_draft_device_pools = (draft,) + controller.layer_num, controller.io_backend, controller.device = ( + 48, + "kernel", + "cuda", + ) + counter, engine = LayerDoneCounter(48), L2TransferEngine("kernel") + qsa.layer_transfer_counter = counter + rows = kv_host.alloc(128) + source, destination = torch.arange(64, 192, device="cuda"), torch.arange( + 128, 256, device="cuda" + ) + source_index, dest_index = torch.arange(16, 48, device="cuda"), torch.arange( + 32, 64, device="cuda" + ) + all_kv = main.k_buffer + main.v_buffer + draft.k_buffer + draft.v_buffer + all_index = ( + qsa.qsa_compressed_k_buffer_pool + draft_qsa.qsa_compressed_k_buffer_pool + ) + assert index_host.layer_num == 13 and index_host.size_per_token == 13 * 64 + for epoch in range(4): + for i, buffer in enumerate(all_kv): + buffer[source] = ( + torch.arange(128, device="cuda")[:, None, None] + i * 7 + epoch + ).to(torch.uint8) + for i, buffer in enumerate(all_index): + buffer[source_index] = ( + torch.arange(32 * 128, device="cuda").reshape(32, 1, 128) % 191 + + i + + epoch + ).to(torch.bfloat16) + expected_kv = [x[source].clone() for x in all_kv] + expected_index = [x[source_index].clone() for x in all_index] + write = CacheOperation( + rows, + source, + epoch, + pool_transfers=[ + PoolTransfer( + PoolName.QSA_INDEXER, + rows, + source, + indices_from_pool=PoolName.KV, + ) + ], + ) + assert controller._transfer_num_bytes(write) == 128 * ( + kv_host.size_per_token + index_host.size_per_token + ) + copied = engine.submit_device_to_host( + controller._l2_transfers(*controller._move_write_operation(write)) + ) + copied.finish_event.synchronize() + if on_disk: + + def reopen(): + backend = storage( + tmp_path, int(os.environ.get("QWEN_HICACHE_TP_RANK", "0")) + ) + backend.register_mem_host_pool_v2(kv_host, PoolName.KV) + backend.register_mem_host_pool_v2(index_host, PoolName.QSA_INDEXER) + return backend + + keys = [f"{epoch}-{i}" for i in range(2)] + transfers = [ + PoolTransfer(name, rows, keys=keys) + for name in (PoolName.KV, PoolName.QSA_INDEXER) + ] + expected_hits = { + name: [True, True] for name in (PoolName.KV, PoolName.QSA_INDEXER) + } + assert reopen().batch_set_v2(transfers) == expected_hits + kv_host.kv_buffer.zero_() + for buffer in index_host.get_hybrid_pool_buffer(): + buffer.zero_() + assert reopen().batch_get_v2(transfers) == expected_hits + for buffer in all_kv: + buffer[destination] = 255 + for buffer in all_index: + buffer[dest_index] = -200 + load = CacheOperation( + rows, + destination, + epoch, + pool_transfers=[ + PoolTransfer( + PoolName.QSA_INDEXER, + rows, + destination, + indices_from_pool=PoolName.KV, + ) + ], + ) + transfers = controller._l2_load_transfers( + *controller.move_hybrid_indices(load) + ) + assert len(transfers) == 4 and sum(x.is_draft for x in transfers) == 2 + event_id = counter.update_producer() + counter.set_consumer(event_id) + with torch.cuda.stream(engine.host_to_device_stream): + torch.cuda._sleep(20_000_000) + restored = engine.submit_host_to_device( + transfers, layer_num=48, on_layer_done=counter.events[event_id].complete + ) + # This read must wait for the index copy, before a full-transfer sync. + early = qsa.get_qsa_compressed_k_buffer(3)[dest_index].clone() + torch.cuda.current_stream().synchronize() + assert torch.equal(early, expected_index[0]) + restored.finish_event.synchronize() + for actual, expected in zip(all_kv, expected_kv): + assert torch.equal(actual[destination], expected) + for actual, expected in zip(all_index, expected_index): + assert torch.equal(actual[dest_index], expected) + finally: + torch.cuda.synchronize() + for host in made: + host.destroy() diff --git a/validation/hicache/test_hicache_qsa_local.py b/validation/hicache/test_hicache_qsa_local.py new file mode 100644 index 0000000..61b80fe --- /dev/null +++ b/validation/hicache/test_hicache_qsa_local.py @@ -0,0 +1,254 @@ +"""Compressed QSA cache layout, budgeting and required disk-page coverage.""" + +from types import SimpleNamespace +from unittest.mock import Mock + +import pytest +import torch + +from sglang.srt.mem_cache.hicache_storage import PoolHitPolicy, PoolName, PoolTransfer +from sglang.srt.mem_cache.hybrid_cache import hybrid_pool_assembler as assembler +from sglang.srt.mem_cache.qsa_kv_pool import QSATokenToKVPool +from sglang.srt.mem_cache.qsa_pool_host import ( + QSAPagedHostPool, + qsa_index_bytes_per_token, +) + +from test_hicache_file_local import storage + + +def make_index_pool(layers=2, device="cpu", ratio=4, page_size=64): + pool = QSATokenToKVPool.__new__(QSATokenToKVPool) + pool.page_size, pool.qsa_compress_ratio = page_size, ratio + pool.qsa_compressed_k_buffer_pool = [ + ((torch.arange(80 * 128, device=device) % 173) + layer) + .to(torch.bfloat16) + .reshape(80, 1, 128) + for layer in range(layers) + ] + pool.full_attention_layer_id_mapping = {4 * i + 3: i for i in range(layers)} + pool.start_layer, pool.layer_transfer_counter = 0, None + return pool + + +@pytest.mark.parametrize("layout", ["layer_first", "page_first", "page_first_direct"]) +def test_flat_page_carries_every_target_and_draft_layer(layout): + pools = (make_index_pool(), make_index_pool(1)) + host = QSAPagedHostPool(pools, 192, 64, layout, pin_memory=False) + try: + assert host.size_per_token == 3 * 128 * 2 // 4 + assert host.get_size_per_token() == host.size_per_token + assert ( + sum(x.numel() * x.element_size() for x in host.get_hybrid_pool_buffer()) + == 192 * host.size_per_token + ) + expected = torch.arange(64 * host.size_per_token).to(torch.uint8) + host.set_from_flat_data_page(64, expected) + assert torch.equal(host.get_data_page(64), expected) + assert host.get_dummy_flat_data_page().shape == expected.shape + assert host._to_page_indices(torch.arange(64, 192)).tolist() == [1, 2] + finally: + host.destroy() + + +@pytest.mark.parametrize("ratio,page_size", [(0, 64), (3, 64), (4, 1)]) +def test_rejects_incomplete_compression_groups(ratio, page_size): + with pytest.raises(ValueError): + qsa_index_bytes_per_token((make_index_pool(ratio=ratio),), page_size) + + +def test_rejects_partial_copy_and_mismatched_draft(): + host = QSAPagedHostPool( + (make_index_pool(),), 192, 64, "page_first", pin_memory=False + ) + try: + with pytest.raises(ValueError, match="complete KV pages"): + host._has_transfer_indices(torch.arange(63), torch.arange(63)) + finally: + host.destroy() + with pytest.raises(ValueError, match="shapes must match"): + QSAPagedHostPool( + (make_index_pool(), make_index_pool(1, ratio=8)), + 192, + 64, + "page_first", + pin_memory=False, + ) + + +def test_index_read_waits_on_global_attention_layer(): + pool = make_index_pool() + pool.layer_transfer_counter = Mock() + result = pool.get_qsa_compressed_k_buffer(7) + pool.layer_transfer_counter.wait_until.assert_called_once_with(7) + assert result is pool.qsa_compressed_k_buffer_pool[1] + + +def test_file_requires_all_sparse_index_pages(tmp_path): + host = QSAPagedHostPool( + (make_index_pool(), make_index_pool(1)), 192, 64, "page_first", pin_memory=False + ) + try: + backend = storage(tmp_path) + backend.register_mem_host_pool_v2(host, PoolName.QSA_INDEXER) + keys = ["first", "second"] + for key in keys: + assert backend.set(key, torch.zeros(32, dtype=torch.uint8)) + transfer = PoolTransfer( + PoolName.QSA_INDEXER, + host_indices=torch.arange(128), + keys=keys, + hit_policy=PoolHitPolicy.ALL_PAGES, + indices_from_pool=PoolName.KV, + ) + assert backend.batch_exists_v2(keys, [transfer]).kv_hit_pages == 0 + expected = torch.arange(64 * host.size_per_token).to(torch.uint8) + host.set_from_flat_data_page(0, expected) + first = PoolTransfer( + PoolName.QSA_INDEXER, host_indices=torch.arange(64), keys=keys[:1] + ) + assert backend.batch_set_v2([first]) == {PoolName.QSA_INDEXER: [True]} + assert backend.batch_exists_v2(keys, [transfer]).kv_hit_pages == 1 + host.set_from_flat_data_page(64, expected.flip(0)) + assert backend.batch_set_v2([transfer]) == {PoolName.QSA_INDEXER: [True, True]} + host.kv_buffer.zero_() + reopened = storage(tmp_path) + reopened.register_mem_host_pool_v2(host, PoolName.QSA_INDEXER) + assert reopened.batch_get_v2([transfer]) == {PoolName.QSA_INDEXER: [True, True]} + assert torch.equal(host.get_data_page(0), expected) + assert torch.equal(host.get_data_page(64), expected.flip(0)) + finally: + host.destroy() + + +def test_mamba_strategy_registers_required_index_and_rejects_missing_draft(monkeypatch): + target, draft = make_index_pool(), make_index_pool(1) + for pool, count in ((target, 2), (draft, 1)): + pool.full_kv_pool = SimpleNamespace(layer_num=count) + target.use_mla = False + params = SimpleNamespace( + page_size=64, + mtp_draft_device_pools=(draft,), + req_to_token_pool=SimpleNamespace( + mamba_map={0: 0, 1: 1, 2: 2, 4: 3, 5: 4, 6: 5}, mamba_pool=object() + ), + ) + group, controller = Mock(), Mock() + build = Mock(return_value=(group, controller)) + monkeypatch.setattr(assembler, "build_hybrid_mamba_stack", build) + result = assembler._MambaStrategy().build( + cache=Mock(), + kvcache=target, + params=params, + server_args=Mock(), + load_cache_event=Mock(), + ) + assert build.call_args.kwargs["qsa_device_pools"] == (target, draft) + assert len(result.sidecars) == 1 + assert result.sidecars[0].pool_name == PoolName.QSA_INDEXER + assert result.sidecars[0].hit_policy == PoolHitPolicy.ALL_PAGES + assert result.sidecars[0].indices_from_pool == PoolName.KV + params.mtp_draft_device_pools = (SimpleNamespace(),) + with pytest.raises(ValueError, match="compressed QSA draft"): + assembler._MambaStrategy().build( + cache=Mock(), + kvcache=target, + params=params, + server_args=Mock(), + load_cache_event=Mock(), + ) + + +@pytest.mark.parametrize("with_draft", [False, True]) +def test_fixed_host_budget_includes_index_and_draft(monkeypatch, with_draft): + target, draft = make_index_pool(), make_index_pool(1) + kv = SimpleNamespace( + size=256, + page_size=64, + layer_num=2, + get_kv_size_bytes=lambda: (320 * 2 * 256, 320 * 2 * 256), + ) + draft.full_kv_pool = SimpleNamespace( + size=256, + page_size=64, + layer_num=1, + get_kv_size_bytes=lambda: (320 * 256, 320 * 256), + ) + state = SimpleNamespace(get_kv_size_bytes=lambda: 320 * 1024) + args = SimpleNamespace( + hicache_size=0.01, + hicache_ratio=2, + hicache_mem_layout="page_first", + hicache_write_policy="write_through", + hicache_io_backend="kernel", + ) + params = SimpleNamespace( + mtp_draft_device_pools=(draft,) if with_draft else (), + req_to_token_pool=SimpleNamespace(mamba_allocator=Mock()), + page_size=64, + token_to_kv_pool_allocator=Mock(), + tp_cache_group=None, + attn_cp_cache_group=None, + attn_tp_cache_group=None, + pp_cache_group=None, + ) + built = {} + + def kv_host(**kwargs): + built["kv_budget"] = kwargs["host_size"] * 1e9 + per_token = 1024 + (512 if with_draft else 0) + size = (int(built["kv_budget"] // per_token) // 64 + 1) * 64 + return SimpleNamespace( + size=size, + logical_size=size, + page_size=64, + layout="page_first", + device="cpu", + size_per_token=per_token, + can_use_write_back_jit=False, + ) + + def state_host(*args, **kwargs): + built["state_budget"] = args[2] * 1e9 + return SimpleNamespace(can_use_write_back_jit=False) + + monkeypatch.setattr(assembler, "build_kv_host_pool", kv_host) + monkeypatch.setattr(assembler, "MambaPoolHost", state_host) + monkeypatch.setattr(assembler, "HybridCacheController", Mock()) + monkeypatch.setattr(assembler, "_get_allocator_type", lambda args: "default") + from sglang.srt.mem_cache import qsa_pool_host as host_module + + monkeypatch.setattr( + host_module, + "QSAPagedHostPool", + lambda *args, **kwargs: QSAPagedHostPool(*args, pin_memory=False, **kwargs), + ) + group, _ = assembler.build_hybrid_mamba_stack( + params=params, + server_args=args, + kv_pool=kv, + mamba_pool=state, + full_layer_mapping={3: 0, 7: 1}, + mamba_layer_mapping={i: i for i in (0, 1, 2, 4, 5, 6)}, + load_cache_event=Mock(), + storage_backend=None, + use_mla=False, + qsa_device_pools=(target, draft) if with_draft else (target,), + ) + index = group.get_pool(PoolName.QSA_INDEXER) + try: + anchor = group.get_pool(PoolName.KV) + actual = ( + anchor.size * (anchor.size_per_token + index.size_per_token) + + built["state_budget"] + ) + assert ( + 10_000_000 + <= actual + <= 10_000_000 + 64 * (anchor.size_per_token + index.size_per_token) + ) + entry = group.entry_map[PoolName.QSA_INDEXER] + assert entry.layer_mapper(3) == 0 and entry.layer_mapper(7) == 1 + assert entry.layer_mapper(8) == (2 if with_draft else None) + finally: + index.destroy() From aa990bc1a30053b472fe7f547ca55089c426a149 Mon Sep 17 00:00:00 2001 From: ktsaou <2662304+ktsaou@users.noreply.github.com> Date: Mon, 14 Sep 2026 08:56:34 +0000 Subject: [PATCH 03/20] fix(responses): preserve Qwen phase and item order --- Dockerfile.responses-compat | 2 +- README.md | 6 +- docs/responses-compat.md | 24 +- patches/0017-responses-phase-order.patch | 701 +++ patches/series.responses-compat | 1 + .../responses-phase-order-runtime-files.json | 4394 +++++++++++++++++ provenance/responses-phase-order.json | 26 + .../sglang/srt/entrypoints/openai/protocol.py | 20 +- .../entrypoints/openai/serving_responses.py | 508 +- scripts/verify_responses_compat.py | 47 +- tests/runtime_responses_compat.py | 244 +- tests/test_responses_packaging.py | 22 +- 12 files changed, 5743 insertions(+), 252 deletions(-) create mode 100644 patches/0017-responses-phase-order.patch create mode 100644 provenance/responses-phase-order-runtime-files.json create mode 100644 provenance/responses-phase-order.json diff --git a/Dockerfile.responses-compat b/Dockerfile.responses-compat index 9b8af6c..9c51bcd 100644 --- a/Dockerfile.responses-compat +++ b/Dockerfile.responses-compat @@ -1,4 +1,4 @@ -# API-only compatibility overlay. All serving arguments remain external. +# API-only compatibility and phase/order overlay. All serving arguments remain external. # Immutable rollback/base; no private snapshot, checkpoint or docker commit. FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 ARG SOURCE_REVISION diff --git a/README.md b/README.md index c2bf16c..76ebd6a 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ # Qwen TP2 packed-PLE vision on SM120 -**Unpublished CPU candidate:** [Responses namespace/custom compatibility](docs/responses-compat.md) -adds a separately attested boundary backport after the effort-alias profile. -Historical production profiles below are unchanged; no deployment is implied. +**Unpublished CPU candidate:** [Responses compatibility and Qwen phase/order](docs/responses-compat.md) +adds separately attested boundary and streaming-order patches after the effort-alias +profile. Historical production profiles below are unchanged; no deployment is implied. Publishable source and deployment package for the locally accepted Qwen3.8 Flash-Next LIL NVFP4 stack. **No model weights, container archives, credentials, diff --git a/docs/responses-compat.md b/docs/responses-compat.md index 9575d4a..e6eb0c1 100644 --- a/docs/responses-compat.md +++ b/docs/responses-compat.md @@ -1,4 +1,4 @@ -# Responses namespace/custom boundary — CPU candidate only +# Responses compatibility and Qwen phase/order — CPU candidate only This profile follows alias commit `04e0816a68638e85ddd4ff8764b401d3ed27997e`. It does not upgrade the engine, change kernels/schedulers/checkpoints, or change @@ -9,7 +9,8 @@ The exact base image and upstream reference heads are recorded in `provenance/responses-compat.json`. References #39174, #38359, #38690 and #35216 informed the design; this is not a wholesale serving-file transplant. The serving file starts from the attested installed runtime; patch 0016 contains its narrow -delta. The only new installed module is `responses_compat.py`. +delta. Patch 0017 adds phase and ordering behavior on top of that exact result. +The only new installed module is `responses_compat.py`. ## Contract @@ -81,6 +82,19 @@ delta. The only new installed module is `responses_compat.py`. parser silently drops unknown names. Custom argument JSON is decoded only when complete, then emitted as a raw-input delta and done event. There is no claim of token-by-token custom-input latency. +- Response message items carry `phase="commentary"` or `phase="final_answer"`. + Streaming text is emitted immediately; an added message leaves phase unresolved + when later reasoning or tool output can still change it. The completed item sets + commentary when a tool call or renewed reasoning follows and final_answer when + the text ends the response. +- Qwen3.8 Flash-Next markup is fed to the existing reasoning and tool parsers at + markup boundaries. Coalesced and fragmented engine chunks therefore preserve + `reasoning -> text -> tool -> text` wire order instead of merging text across a + tool call. Literal angle-bracket text still passes through the parsers. +- Replay groups adjacent Qwen assistant items only while their stage order remains + renderable as one native assistant turn. Explicit phase changes and restarted + reasoning/tool sequences remain separate turns. Stored response replay retains + reasoning and phase fields as well as text and calls. ## CPU reproduction @@ -93,7 +107,7 @@ QWEN_TOKENIZER_PATH=/absolute/pinned/tokenizer bash scripts/test_qwen_effort_ali ``` The candidate runner verifies all five mounted runtime files against the cumulative -inventory, as well as patch/tokenizer hashes. It uses the exact +inventory, as well as all three patch and tokenizer hashes. It uses the exact existing image with no pull/network/GPU, read-only root and mounts, scratch caches, dropped capabilities and CPU/memory/PID limits. Tests import the actual serving modules and exercise `http_server.app` endpoints through ASGI TestClient. Only @@ -120,8 +134,8 @@ python3 scripts/verify_responses_compat.py --tree TREE --from-image python3 scripts/verify_responses_compat.py --tree TREE ``` -The verifier checks all 4,391 image files, applies 0015 then 0016, and checks all -4,392 resulting paths and hashes including the new module. Alternatively, `--apply` +The verifier checks all 4,391 image files, applies 0015, 0016, then 0017, and checks +all 4,392 resulting paths and hashes including the new module. Alternatively, `--apply` accepts a completely verified alias predecessor tree. Neither modifies historical profiles. Source equivalence is not byte-identical image reproduction. Do not use historical Dockerfiles with the changed overlay to claim reproduction of an diff --git a/patches/0017-responses-phase-order.patch b/patches/0017-responses-phase-order.patch new file mode 100644 index 0000000..0f837b0 --- /dev/null +++ b/patches/0017-responses-phase-order.patch @@ -0,0 +1,701 @@ +diff --git a/python/sglang/srt/entrypoints/openai/protocol.py b/python/sglang/srt/entrypoints/openai/protocol.py +index c120d0a..44c91a1 100644 +--- a/python/sglang/srt/entrypoints/openai/protocol.py ++++ b/python/sglang/srt/entrypoints/openai/protocol.py +@@ -39,11 +39,13 @@ from openai.types.responses import ( + ResponseFunctionToolCall, + ResponseInputItemParam, + ResponseOutputItem, +- ResponseOutputMessage, ++ ResponseOutputItemAddedEvent, ++ ResponseOutputItemDoneEvent, + ResponseOutputText, + ResponseReasoningItem, + ResponseTextConfig, + ) ++from openai.types.responses import ResponseOutputMessage as OpenAIResponseOutputMessage + from openai.types.responses.response import ToolChoice + from openai.types.responses.response_custom_tool_call import ResponseCustomToolCall + from openai.types.responses.response_format_text_json_schema_config import ( +@@ -630,6 +632,7 @@ class ChatCompletionMessageGenericParam(BaseModel): + ) + tool_call_id: Optional[str] = None + name: Optional[str] = None ++ phase: Optional[Literal["commentary", "final_answer"]] = None + reasoning_content: Optional[str] = None + tool_calls: Optional[List[ToolCall]] = Field(default=None, examples=[None]) + tools: Optional[List[Tool]] = Field(default=None, examples=[None]) +@@ -1789,6 +1792,18 @@ class ResponseNamespacedCustomToolCall(ResponseCustomToolCall): + namespace: str + + ++class ResponseOutputMessage(OpenAIResponseOutputMessage): ++ phase: Optional[Literal["commentary", "final_answer"]] = None ++ ++ ++class ResponsePhasedOutputItemAddedEvent(ResponseOutputItemAddedEvent): ++ item: Union[ResponseOutputMessage, ResponseOutputItem] ++ ++ ++class ResponsePhasedOutputItemDoneEvent(ResponseOutputItemDoneEvent): ++ item: Union[ResponseOutputMessage, ResponseOutputItem] ++ ++ + class ResponsesResponse(BaseModel): + """Response body for v1/responses endpoint.""" + +@@ -1799,6 +1814,7 @@ class ResponsesResponse(BaseModel): + + output: List[ + Union[ ++ ResponseOutputMessage, + ResponseNamespacedFunctionToolCall, + ResponseNamespacedCustomToolCall, + ResponseOutputItem, +@@ -1890,7 +1906,7 @@ class ResponsesResponse(BaseModel): + try: + if isinstance(it, ResponseOutputText): + continue +- elif isinstance(it, ResponseOutputMessage): ++ elif isinstance(it, OpenAIResponseOutputMessage): + if not it.content: + continue + for c in it.content: +diff --git a/python/sglang/srt/entrypoints/openai/serving_responses.py b/python/sglang/srt/entrypoints/openai/serving_responses.py +index 2fda942..18931fb 100644 +--- a/python/sglang/srt/entrypoints/openai/serving_responses.py ++++ b/python/sglang/srt/entrypoints/openai/serving_responses.py +@@ -7,6 +7,7 @@ from __future__ import annotations + import asyncio + import json + import logging ++import re + import time + from contextlib import AsyncExitStack + from http import HTTPStatus +@@ -18,7 +19,6 @@ import orjson + from fastapi import Request + from fastapi.responses import ORJSONResponse + from openai.types.responses import ( +- ResponseOutputMessage, + ResponseOutputText, + ResponseReasoningItem, + ) +@@ -61,6 +61,9 @@ from sglang.srt.entrypoints.openai.protocol import ( + MessageProcessingResult, + PromptTokenUsageInfo, + RequestResponseMetadata, ++ ResponseOutputMessage, ++ ResponsePhasedOutputItemAddedEvent, ++ ResponsePhasedOutputItemDoneEvent, + ResponsesRequest, + ResponsesResponse, + Tool, +@@ -1009,6 +1012,7 @@ class OpenAIServingResponses(OpenAIServingChat): + role="assistant", + status="completed", + type="message", ++ phase="commentary" if tool_call_items else "final_answer", + ) + output_items.append(message) + output_items.extend(tool_call_items) +@@ -1232,10 +1236,39 @@ class OpenAIServingResponses(OpenAIServingChat): + @staticmethod + def _merge_consecutive_assistant_messages( + messages: list, ++ *, ++ preserve_qwen_order: bool = False, + ) -> list: + """Collapse runs of consecutive ``assistant`` dicts into one entry, + joining ``content`` and concatenating ``tool_calls`` and + ``reasoning_content`` so a logical turn renders as a single block.""" ++ ++ def compatible(left: dict, right: dict) -> bool: ++ left_phase, right_phase = left.get("phase"), right.get("phase") ++ if not preserve_qwen_order: ++ return left_phase == right_phase ++ if ( ++ left_phase is not None ++ and right_phase is not None ++ and left_phase != right_phase ++ ): ++ return False ++ if left_phase == "final_answer" and ( ++ right.get("reasoning_content") or right.get("tool_calls") ++ ): ++ return False ++ ++ # Qwen renders reasoning, then content, then calls within each block. ++ # A restarted sequence must remain in a separate assistant block. ++ fields = ("reasoning_content", "content", "tool_calls") ++ left_stages = [i for i, field in enumerate(fields) if left.get(field)] ++ right_stages = [i for i, field in enumerate(fields) if right.get(field)] ++ return ( ++ not left_stages ++ or not right_stages ++ or max(left_stages) <= min(right_stages) ++ ) ++ + merged: list = [] + for msg in messages: + if ( +@@ -1244,8 +1277,16 @@ class OpenAIServingResponses(OpenAIServingChat): + and merged + and isinstance(merged[-1], dict) + and merged[-1].get("role") == "assistant" ++ and compatible(merged[-1], msg) + ): + prev = merged[-1] = dict(merged[-1]) ++ # Reasoning and calls have no phase; retain the text item's phase. ++ if ( ++ preserve_qwen_order ++ and prev.get("phase") is None ++ and msg.get("phase") is not None ++ ): ++ prev["phase"] = msg["phase"] + # Lift mixed str/list content to list parts so non-text parts + # (e.g. image_url) survive when the two sides differ in shape. + new_content = msg.get("content") +@@ -1305,13 +1346,9 @@ class OpenAIServingResponses(OpenAIServingChat): + messages.extend(prev_msg) + + for output_item in prev_response.output: +- if isinstance(output_item, ResponseFunctionToolCall): +- messages.append(self._normalize_response_message_for_chat(output_item)) +- continue +- assistant_text = self._output_message_text(output_item) +- if assistant_text is None: +- continue +- messages.append({"role": "assistant", "content": assistant_text}) ++ normalized = self._normalize_response_message_for_chat(output_item) ++ if normalized is not None: ++ messages.append(normalized) + + # Append the new input + # Responses API supports simple text inputs without chat format +@@ -1326,7 +1363,15 @@ class OpenAIServingResponses(OpenAIServingChat): + # One Responses-API assistant turn maps to multiple input items + # (message + function_call(s)); collapse them into one chat message + # so chat templates render a single assistant block per turn. +- messages = self._merge_consecutive_assistant_messages(messages) ++ is_qwen = self.tokenizer_manager.model_config.hf_config.model_type in { ++ "qwen3_8_flash_next", ++ "qwen3_8_flash_next_text", ++ "qwen4_exp", ++ } ++ messages = self._merge_consecutive_assistant_messages( ++ messages, ++ preserve_qwen_order=is_qwen, ++ ) + + # Most chat templates expect a single leading ``system`` message; + # coalesce any ``instructions`` + interleaved ``developer`` entries. +@@ -2091,6 +2136,16 @@ class OpenAIServingResponses(OpenAIServingChat): + tool_call_parser_active=isinstance(tool_parser, FunctionCallParser), + ) + ++ # These parsers return separate text and call collections. Feed Qwen ++ # markup boundaries separately so their original order remains visible. ++ split_qwen_markup = ( ++ self.tokenizer_manager.model_config.hf_config.model_type ++ in {"qwen3_8_flash_next", "qwen3_8_flash_next_text", "qwen4_exp"} ++ and self.reasoning_parser in {None, "qwen3", "qwen3-thinking"} ++ and self.tool_call_parser in {None, "qwen3_coder"} ++ and (reasoning_parser_obj is not None or tool_parser is not None) ++ ) ++ + current_output_index = -1 + reasoning_state = { + "open": False, +@@ -2211,7 +2266,7 @@ class OpenAIServingResponses(OpenAIServingChat): + ) + return item_id + +- def _close_message_item(): ++ def _close_message_item(phase: str = "final_answer"): + if not message_state["open"]: + return [] + text = message_state["text"] +@@ -2224,6 +2279,7 @@ class OpenAIServingResponses(OpenAIServingChat): + role="assistant", + content=[text_content], + status="completed", ++ phase=phase, + ) + events = [ + _send_event( +@@ -2248,7 +2304,7 @@ class OpenAIServingResponses(OpenAIServingChat): + ) + ), + _send_event( +- openai_responses_types.ResponseOutputItemDoneEvent( ++ ResponsePhasedOutputItemDoneEvent( + type="response.output_item.done", + sequence_number=-1, + output_index=message_state["output_index"], +@@ -2335,241 +2391,259 @@ class OpenAIServingResponses(OpenAIServingChat): + ) + flushed = flushed or flush + +- if reasoning_parser_obj is not None: +- reasoning_chunk, delta = reasoning_parser_obj.parse_stream_chunk( +- delta +- ) +- if flush: +- end_reasoning, end_normal = ( +- reasoning_parser_obj.parse_stream_end() +- ) +- if end_reasoning: +- reasoning_chunk = (reasoning_chunk or "") + end_reasoning +- if end_normal: +- delta = (delta or "") + end_normal +- else: +- reasoning_chunk = None +- +- if reasoning_chunk: +- if message_state["open"]: +- for ev in _close_message_item(): +- yield ev +- if not reasoning_state["open"]: +- item_id = _open_reasoning_item() +- yield _send_event( +- openai_responses_types.ResponseOutputItemAddedEvent( +- type="response.output_item.added", +- sequence_number=-1, +- output_index=reasoning_state["output_index"], +- item=ResponseReasoningItem( +- id=item_id, +- type="reasoning", +- summary=[], +- content=[], +- status="in_progress", +- ), +- ) ++ parts = ( ++ [part for part in re.split(r"(?=<)|(?<=>)", delta) if part] ++ or [""] ++ if split_qwen_markup ++ else [delta] ++ ) ++ flush_chunk = flush ++ for part_index, delta in enumerate(parts): ++ # Flush parser state once, after the terminal piece. ++ flush = flush_chunk and part_index == len(parts) - 1 ++ if reasoning_parser_obj is not None: ++ reasoning_chunk, delta = reasoning_parser_obj.parse_stream_chunk( ++ delta + ) +- # Clients that opt into ``reasoning.summary`` render +- # off the ``reasoning_summary_text.*`` event stream, +- # so mirror the trace into a summary part. +- if wants_summary: +- yield _send_event( +- openai_responses_types.ResponseReasoningSummaryPartAddedEvent( +- type="response.reasoning_summary_part.added", +- item_id=item_id, +- output_index=reasoning_state["output_index"], +- summary_index=0, +- part=ResponseReasoningSummaryAddedPart( +- type="summary_text", text="" +- ), +- sequence_number=-1, +- ) ++ if flush: ++ end_reasoning, end_normal = ( ++ reasoning_parser_obj.parse_stream_end() + ) +- reasoning_state["text"] += reasoning_chunk +- if wants_summary: +- yield _send_event( +- openai_responses_types.ResponseReasoningSummaryTextDeltaEvent( +- type="response.reasoning_summary_text.delta", +- item_id=reasoning_state["item_id"], +- output_index=reasoning_state["output_index"], +- summary_index=0, +- delta=reasoning_chunk, +- sequence_number=-1, +- ) +- ) ++ if end_reasoning: ++ reasoning_chunk = (reasoning_chunk or "") + end_reasoning ++ if end_normal: ++ delta = (delta or "") + end_normal + else: +- yield _send_event( +- openai_responses_types.ResponseReasoningTextDeltaEvent( +- type="response.reasoning_text.delta", +- item_id=reasoning_state["item_id"], +- output_index=reasoning_state["output_index"], +- content_index=0, +- delta=reasoning_chunk, +- sequence_number=-1, +- ) +- ) ++ reasoning_chunk = None + +- if not delta and not flush: +- continue +- +- if isinstance(tool_parser, JsonArrayParser): +- required_buffer += delta +- normal_text, tool_calls = "", [] +- if flush and required_buffer.strip(): +- tool_calls = [ +- ToolCallItem(tool_index=index, name=name, parameters=arguments) +- for index, (name, arguments) in enumerate( +- validated_json_calls(required_buffer, {tool.function.name for tool in chat_tools}) +- ) +- ] +- elif tool_parser is not None: +- normal_text, tool_calls = tool_parser.parse_stream_chunk(delta) +- if flush: +- end_text, end_calls = tool_parser.parse_stream_end() +- normal_text = (normal_text or "") + end_text +- tool_calls = list(tool_calls) + end_calls +- else: +- normal_text, tool_calls = delta, [] +- +- def _emit_tool_calls(calls): +- nonlocal current_output_index +- if calls: +- if reasoning_state["open"]: +- for ev in _close_reasoning_item(): +- yield ev ++ if reasoning_chunk: + if message_state["open"]: +- for ev in _close_message_item(): ++ for ev in _close_message_item(phase="commentary"): + yield ev +- +- for call in calls: +- tool_index = call.tool_index +- state = tool_call_states.get(tool_index) +- if state is None or state.get("done"): +- # Close other open calls first, so their +- # output_item.done precedes the next added. +- for other_index in list(tool_call_states): +- if other_index != tool_index: +- for ev in _close_tool_call_state(other_index): +- yield ev +- current_output_index += 1 +- item_id = f"fc_{random_uuid()[:8]}" +- call_id = f"call_{random_uuid()[:24]}" +- state = { +- "item_id": item_id, +- "call_id": call_id, +- "output_index": current_output_index, +- "name": call.name or "", +- "arguments": "", +- "added": False, +- "done": False, +- } +- tool_call_states[tool_index] = state +- if not state["added"]: +- if request._compat_registry is not None: +- request._compat_registry.output_identity(state["name"]) +- state["added"] = True ++ if not reasoning_state["open"]: ++ item_id = _open_reasoning_item() + yield _send_event( + openai_responses_types.ResponseOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, +- output_index=state["output_index"], +- item=ResponseFunctionToolCall( +- arguments="", +- call_id=state["call_id"], +- name=state["name"], +- type="function_call", +- id=state["item_id"], ++ output_index=reasoning_state["output_index"], ++ item=ResponseReasoningItem( ++ id=item_id, ++ type="reasoning", ++ summary=[], ++ content=[], + status="in_progress", + ), + ) + ) +- if call.parameters: +- state["arguments"] += call.parameters ++ # Clients that opt into ``reasoning.summary`` render ++ # off the ``reasoning_summary_text.*`` event stream, ++ # so mirror the trace into a summary part. ++ if wants_summary: ++ yield _send_event( ++ openai_responses_types.ResponseReasoningSummaryPartAddedEvent( ++ type="response.reasoning_summary_part.added", ++ item_id=item_id, ++ output_index=reasoning_state["output_index"], ++ summary_index=0, ++ part=ResponseReasoningSummaryAddedPart( ++ type="summary_text", text="" ++ ), ++ sequence_number=-1, ++ ) ++ ) ++ reasoning_state["text"] += reasoning_chunk ++ if wants_summary: + yield _send_event( +- openai_responses_types.ResponseFunctionCallArgumentsDeltaEvent( +- type="response.function_call_arguments.delta", ++ openai_responses_types.ResponseReasoningSummaryTextDeltaEvent( ++ type="response.reasoning_summary_text.delta", ++ item_id=reasoning_state["item_id"], ++ output_index=reasoning_state["output_index"], ++ summary_index=0, ++ delta=reasoning_chunk, + sequence_number=-1, +- item_id=state["item_id"], +- output_index=state["output_index"], +- delta=call.parameters, + ) + ) +- +- def _emit_normal_text(): +- if normal_text and _should_emit_normal_text_as_message( +- normal_text, +- any_tool_call_in_progress=any( +- not s.get("done") for s in tool_call_states.values() +- ), +- ): +- if reasoning_state["open"]: +- for ev in _close_reasoning_item(): +- yield ev +- for tool_index in list(tool_call_states): +- for ev in _close_tool_call_state(tool_index): +- yield ev +- if not message_state["open"]: +- item_id = _open_message_item() ++ else: + yield _send_event( +- openai_responses_types.ResponseOutputItemAddedEvent( +- type="response.output_item.added", ++ openai_responses_types.ResponseReasoningTextDeltaEvent( ++ type="response.reasoning_text.delta", ++ item_id=reasoning_state["item_id"], ++ output_index=reasoning_state["output_index"], ++ content_index=0, ++ delta=reasoning_chunk, + sequence_number=-1, +- output_index=message_state["output_index"], +- item=ResponseOutputMessage( +- id=item_id, +- type="message", +- role="assistant", +- content=[], +- status="in_progress", +- ), + ) + ) ++ ++ if not delta and not flush: ++ continue ++ ++ if isinstance(tool_parser, JsonArrayParser): ++ required_buffer += delta ++ normal_text, tool_calls = "", [] ++ if flush and required_buffer.strip(): ++ tool_calls = [ ++ ToolCallItem(tool_index=index, name=name, parameters=arguments) ++ for index, (name, arguments) in enumerate( ++ validated_json_calls(required_buffer, {tool.function.name for tool in chat_tools}) ++ ) ++ ] ++ elif tool_parser is not None: ++ normal_text, tool_calls = tool_parser.parse_stream_chunk(delta) ++ if flush: ++ end_text, end_calls = tool_parser.parse_stream_end() ++ normal_text = (normal_text or "") + end_text ++ tool_calls = list(tool_calls) + end_calls ++ else: ++ normal_text, tool_calls = delta, [] ++ ++ def _emit_tool_calls(calls): ++ nonlocal current_output_index ++ if calls: ++ if reasoning_state["open"]: ++ for ev in _close_reasoning_item(): ++ yield ev ++ if message_state["open"]: ++ for ev in _close_message_item(phase="commentary"): ++ yield ev ++ ++ for call in calls: ++ tool_index = call.tool_index ++ state = tool_call_states.get(tool_index) ++ if state is None or state.get("done"): ++ # Close other open calls first, so their ++ # output_item.done precedes the next added. ++ for other_index in list(tool_call_states): ++ if other_index != tool_index: ++ for ev in _close_tool_call_state(other_index): ++ yield ev ++ current_output_index += 1 ++ item_id = f"fc_{random_uuid()[:8]}" ++ call_id = f"call_{random_uuid()[:24]}" ++ state = { ++ "item_id": item_id, ++ "call_id": call_id, ++ "output_index": current_output_index, ++ "name": call.name or "", ++ "arguments": "", ++ "added": False, ++ "done": False, ++ } ++ tool_call_states[tool_index] = state ++ if not state["added"]: ++ if request._compat_registry is not None: ++ request._compat_registry.output_identity(state["name"]) ++ state["added"] = True ++ yield _send_event( ++ openai_responses_types.ResponseOutputItemAddedEvent( ++ type="response.output_item.added", ++ sequence_number=-1, ++ output_index=state["output_index"], ++ item=ResponseFunctionToolCall( ++ arguments="", ++ call_id=state["call_id"], ++ name=state["name"], ++ type="function_call", ++ id=state["item_id"], ++ status="in_progress", ++ ), ++ ) ++ ) ++ if call.parameters: ++ state["arguments"] += call.parameters ++ yield _send_event( ++ openai_responses_types.ResponseFunctionCallArgumentsDeltaEvent( ++ type="response.function_call_arguments.delta", ++ sequence_number=-1, ++ item_id=state["item_id"], ++ output_index=state["output_index"], ++ delta=call.parameters, ++ ) ++ ) ++ ++ def _emit_normal_text(): ++ if normal_text and _should_emit_normal_text_as_message( ++ normal_text, ++ any_tool_call_in_progress=any( ++ not s.get("done") for s in tool_call_states.values() ++ ), ++ ): ++ if reasoning_state["open"]: ++ for ev in _close_reasoning_item(): ++ yield ev ++ for tool_index in list(tool_call_states): ++ for ev in _close_tool_call_state(tool_index): ++ yield ev ++ if not message_state["open"]: ++ item_id = _open_message_item() ++ yield _send_event( ++ ResponsePhasedOutputItemAddedEvent( ++ type="response.output_item.added", ++ sequence_number=-1, ++ output_index=message_state["output_index"], ++ item=ResponseOutputMessage( ++ id=item_id, ++ type="message", ++ role="assistant", ++ content=[], ++ status="in_progress", ++ # Later reasoning or a tool call may make ++ # this message commentary. ++ phase=( ++ None ++ if tool_parser is not None ++ or reasoning_parser_obj is not None ++ else "final_answer" ++ ), ++ ), ++ ) ++ ) ++ yield _send_event( ++ openai_responses_types.ResponseContentPartAddedEvent( ++ type="response.content_part.added", ++ sequence_number=-1, ++ output_index=message_state["output_index"], ++ item_id=message_state["item_id"], ++ content_index=0, ++ part=openai_responses_types.ResponseOutputText( ++ type="output_text", ++ text="", ++ annotations=[], ++ logprobs=None, ++ ), ++ ) ++ ) ++ message_state["text"] += normal_text + yield _send_event( +- openai_responses_types.ResponseContentPartAddedEvent( +- type="response.content_part.added", ++ openai_responses_types.ResponseTextDeltaEvent( ++ type="response.output_text.delta", + sequence_number=-1, ++ content_index=0, + output_index=message_state["output_index"], + item_id=message_state["item_id"], +- content_index=0, +- part=openai_responses_types.ResponseOutputText( +- type="output_text", +- text="", +- annotations=[], +- logprobs=None, +- ), ++ delta=normal_text, ++ logprobs=[], + ) + ) +- message_state["text"] += normal_text +- yield _send_event( +- openai_responses_types.ResponseTextDeltaEvent( +- type="response.output_text.delta", +- sequence_number=-1, +- content_index=0, +- output_index=message_state["output_index"], +- item_id=message_state["item_id"], +- delta=normal_text, +- logprobs=[], +- ) +- ) +- +- # The parser's (text, calls) tuple is unordered, but positions +- # are recoverable: continuing arguments precede this delta's +- # text, a newly opened call follows it. Classify first -- +- # emitting mutates tool_call_states. +- def _is_continuing(call): +- state = tool_call_states.get(call.tool_index) +- return state is not None and not state.get("done") +- +- continuing = [c for c in tool_calls if _is_continuing(c)] +- opening = [c for c in tool_calls if not _is_continuing(c)] + +- for ev in _emit_tool_calls(continuing): +- yield ev +- for ev in _emit_normal_text(): +- yield ev +- for ev in _emit_tool_calls(opening): +- yield ev ++ # The parser's (text, calls) tuple is unordered, but positions ++ # are recoverable: continuing arguments precede this delta's ++ # text, a newly opened call follows it. Classify first -- ++ # emitting mutates tool_call_states. ++ def _is_continuing(call): ++ state = tool_call_states.get(call.tool_index) ++ return state is not None and not state.get("done") ++ ++ continuing = [c for c in tool_calls if _is_continuing(c)] ++ opening = [c for c in tool_calls if not _is_continuing(c)] ++ ++ for ev in _emit_tool_calls(continuing): ++ yield ev ++ for ev in _emit_normal_text(): ++ yield ev ++ for ev in _emit_tool_calls(opening): ++ yield ev + except Exception: + logger.exception("Error while streaming /v1/responses") + failed = _sanitize_response_dict( diff --git a/patches/series.responses-compat b/patches/series.responses-compat index 9719169..4790eae 100644 --- a/patches/series.responses-compat +++ b/patches/series.responses-compat @@ -1,2 +1,3 @@ 0015-qwen-flash-next-effort-alias.patch 0016-responses-namespace-custom-boundary.patch +0017-responses-phase-order.patch diff --git a/provenance/responses-phase-order-runtime-files.json b/provenance/responses-phase-order-runtime-files.json new file mode 100644 index 0000000..c5a0f70 --- /dev/null +++ b/provenance/responses-phase-order-runtime-files.json @@ -0,0 +1,4394 @@ +{ + "python/sglang/README.md": "becae5c300803f59e9b231a02b8a3bf93d71cc3b3456116fcd956da03721331b", + "python/sglang/__init__.py": "e54e5073b3d139f84b594bb23f7651a41a7c3d0148df980568928a070192ad5b", + "python/sglang/_mps_stub.py": "1cef5f18d926d6df10797de336d9548baca4278d2d0fba2f3a65280f45e11abe", + "python/sglang/_triton_stub.py": "2b6068eb75ee7e9a04fbf5539b6c05bedd24d8b54875c5e4576ba4661d628eae", + "python/sglang/_version.py": "ad6aabfc8c01600e574ad0d329b3740a975bf256d2cc9716d7145cb6843fb1a2", + "python/sglang/bench_offline_throughput.py": "fd5c5a9cdd91a19894916b85e2664c3fbdcdc32c3ec044bfd0cd9b0908cf167f", + "python/sglang/bench_one_batch.py": "2b062012b43493632ca6dbbb46aa783e235905c9da9cde94c23b6f6b3828ab55", + "python/sglang/bench_one_batch_server.py": "477b8710a3eb5d89d137344c6a45f839a6b3f2d73623f14b6aa9d8e44d9a03cb", + "python/sglang/bench_serving.py": "e2ed21f918212615d7aea997b858f8e7655c23923b968fa57a6b56559607bec7", + "python/sglang/benchmark/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/benchmark/bench_utils.py": "762496fd3514db0a5d73b48f16a5f981312355de0a04c5c4480cdbc0c8d8d0ec", + "python/sglang/benchmark/datasets/__init__.py": "2a3f8f837d621eea2e943d3b741777d15249b8dffa8af4e427492b75632eb8b6", + "python/sglang/benchmark/datasets/agentic_trace.py": "575d2580ca81f3cc267ad8f029efe0fb3a9ad3ca4db1a7e75db44402738f2a95", + "python/sglang/benchmark/datasets/common.py": "544b1b66c8be9cae6e870f3da337b8e3f356ec93ee9ea6c1ce700e1f55b3b442", + "python/sglang/benchmark/datasets/custom.py": "7f8460b6bfae2341d11270067620904f541315943ee94879d99cc227b4e2fc8e", + "python/sglang/benchmark/datasets/generated_shared_prefix.py": "80a581fdd819a159e1518fbfdabf1b62e3ecf6c6c65d4e8328276495f7e2e307", + "python/sglang/benchmark/datasets/image.py": "9ce6564aee48f9edc3b3aabf124e6ee55982891bcabef4700f774f8e254788c7", + "python/sglang/benchmark/datasets/longbench_v2.py": "44dc153dc559c3b968459e9b072b01113e7513720a11323f68754af9dbfbfec3", + "python/sglang/benchmark/datasets/mmmu.py": "a2c6ef7d4b77b884e3ca04e64fd01449985ea4a60544f437905734e20d924fa1", + "python/sglang/benchmark/datasets/mooncake.py": "dcdf06f19b0c06fde742f1bd36dadf0b69aafc07f5361ed84c447a47741db1ab", + "python/sglang/benchmark/datasets/openai_dataset.py": "ecee9f2971e916201c88657aca08e9d28efc0fefc3e10bb8f493c6d191cfed8c", + "python/sglang/benchmark/datasets/random.py": "a1242f133dfc3d4c5d30a396cedb5351e6d6b447a632091eaf6e6c403beada7c", + "python/sglang/benchmark/datasets/sharegpt.py": "1803646354f3a54f9ae87db0ad6235e7689038ff00303601aa84657075d929f4", + "python/sglang/benchmark/datasets/speed_bench.py": "b3d6962624838e7c4f3547414c84cb6e253e76b7d1be6dfa037e1b14d5b40c1b", + "python/sglang/benchmark/dspark_sps_profiler.py": "f8820ba461c7c0956a1e1a787e45de8c09f025e46ac2ae9d4d1d22f4076a1911", + "python/sglang/benchmark/dspark_sts_fit.py": "0c368ce43608db0134fabc8a75a16e86529df28b8c06aaec1d6ac146fcad5f1f", + "python/sglang/benchmark/endpoint.py": "23dc79ce3b56e3544e1b4efe535fd3ecb7fe9aa2bc2bb3ac77b741ea8f3ad843", + "python/sglang/benchmark/offline_throughput.py": "deb4dc80a68b92490775e27fc5913dfbe15e287c601b29ef082204f14f5ae252", + "python/sglang/benchmark/one_batch.py": "9e1fa97baaada1c02ba1bc03e61815146487dc5c611aa0a4f67712f69305cef5", + "python/sglang/benchmark/one_batch_server.py": "eec8240f8b34f973ced70734d9ce2b061ef8d875c87a032d871a7dab0df1b631", + "python/sglang/benchmark/serving.py": "0d65ec5e4490eaf5bc999cd11f045688b05ff6a040b6fabc4e5e60faf134e574", + "python/sglang/benchmark/utils.py": "c9a04dc801f0c0fd0497a0d1e358af2eaa9ae182c6ff6c829f01e8ced281a4a3", + "python/sglang/check_env.py": "afa60d7ea0f828469f861e8bfbc75fa07b373f6afaf7b7a9ece0793f07b9cc8b", + "python/sglang/cli/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/cli/generate.py": "655cdb99f497106f44f2b2bb17d094ecab91675d580a5b1180dcd167ca82e9ff", + "python/sglang/cli/killall.py": "c5cecb6ee74a649a472395ed8788e466ed26b0cdb2e06be49749788be327b561", + "python/sglang/cli/main.py": "0c371f7878d50444540d191aba82674322ebce2b61ad9f0da74cbbc3a84f4210", + "python/sglang/cli/serve.py": "75f8a6166bc38cd28c3085ea1d72cad4cd5aacd0ebd0b515ac39d1d817114f84", + "python/sglang/cli/serve_backends.py": "94c2793bfa5b3d3d509c1be48142630334771c4f10605d943aba97faa031113c", + "python/sglang/cli/utils.py": "cfab1d29aba4202d56d868959a5309fc51192e39b8f40b7aa882c2c87e3c0ce3", + "python/sglang/compile_deep_gemm.py": "b3553a22fe846987c4a2193b6c1186cd27849b8473fcf61696a789bfd816af9a", + "python/sglang/eval/llama3_eval.py": "c11ee8dea86b1f1a02fb520246e88072f38e22e2b847e484e1403d8510d25039", + "python/sglang/eval/loogle_eval.py": "f820b6b36921e6a5280eb1d19105640bf8cdbc180da235db7f8e7a9f2e6cefcb", + "python/sglang/global_config.py": "6d5a542ff80c480d05c0997ccbcb4fe4221aeddd3cde8e8371a93ec91cadcc6c", + "python/sglang/kernel_api_logging.py": "d3cfbaa939422f47b84b96a8878a98b178a7182a79656440c08938804517c4f7", + "python/sglang/kernels/README.md": "500616add2ba819eecbbcfdb8a4044b7d8eaf470d3461a921e9465aed52952a6", + "python/sglang/kernels/__init__.py": "8699543ca891f901b829d318d14314ce516a03a5814e27db02ecf09b49250faa", + "python/sglang/kernels/aot/.clang-format": "dc2a6c4be9a0951daedae7d3ba0955f2062b4f05ae165d812d1e8d3706ef6c15", + "python/sglang/kernels/aot/CMakeLists.txt": "273212caf91c528959e906df6750f004909bff0ed0d0214ef72d35918acab455", + "python/sglang/kernels/aot/Dockerfile": "fd49e7c9f12b9d3f7f96326ceb0c0b9eb1ad61163baa776b187918f99e6da535", + "python/sglang/kernels/aot/LICENSE": "1495e1e757ef4d0925a2350563cf5754bb23c51701a8ec4fb3c5cdcbedae6747", + "python/sglang/kernels/aot/Makefile": "b14809f758c33ee5814ed43da37a43e1b7135237a5251eb16fff0ca35cae7c4e", + "python/sglang/kernels/aot/README.md": "af8c7784ed9197eb548433af7587d37b180e708f0a17e13ce7c8bf10522faae2", + "python/sglang/kernels/aot/THIRDPARTYNOTICES.txt": "2e44e480eb9e4e9e1b98ea2c442a5fa5186ffaec9f9d8b178ec8e6617a05cfa8", + "python/sglang/kernels/aot/analyze_whl_kernel_sizes.py": "75aab9c50021e74f1827487831f1813bcd25c7126f032dc1e29874fdbb5ce125", + "python/sglang/kernels/aot/benchmark/bench_activation.py": "c421f2c2166e467069022af4bee9a7cccbb05e023363100099e4b277022a9388", + "python/sglang/kernels/aot/benchmark/bench_amd_deterministic_allreduce.py": "7e51006df02e58c9427f1009ed617374570efde5dcb596023bcce12785417be9", + "python/sglang/kernels/aot/benchmark/bench_awq_dequant.py": "6e0e965ddc33288cc801446c70e396421d0b6596f92f518e73af9bfb54b42ae3", + "python/sglang/kernels/aot/benchmark/bench_cutlass_mla.py": "cc5d29c56a25a40de5d95d3060e49ccf147b60c48df091ef1381249bc0d42479", + "python/sglang/kernels/aot/benchmark/bench_dsv4_norm_rope.py": "eca51f60e7caec0c32c429522b601ac56badee4e345bc7d85183775a5b62e744", + "python/sglang/kernels/aot/benchmark/bench_es_fp8_blockwise_grouped_gemm.py": "97383c2a26b99b4446aa099b69cd875e44d97ae8dba37ea8e2393a438515f737", + "python/sglang/kernels/aot/benchmark/bench_fp4_gemm.py": "8bf0ac09f60477662dae78313ed271c3dcce0a6c3a3b387554363de2e020284b", + "python/sglang/kernels/aot/benchmark/bench_fp8_blockwise_group_gemm.py": "03d043f711116afbf9247b0b02ec2fc9c6059f3786cbb8746fab55d030dbca25", + "python/sglang/kernels/aot/benchmark/bench_fp8_gemm.py": "73e7fbdd165efef169a2fe326ec16442f689976b444868c88ae27918d37f1317", + "python/sglang/kernels/aot/benchmark/bench_fp8_gemm_swap_ab.py": "5ee968be1921ce842ca624c0c58f0a65cf65d5ff4a9291f9f39e077d8afb84e7", + "python/sglang/kernels/aot/benchmark/bench_int8_gemm.py": "3c4f10853558afa793da791d1ee8691c62d5954fcd0f8cc3bcaeb33d8abc8f16", + "python/sglang/kernels/aot/benchmark/bench_moe_align_block_size.py": "8386b345ef536ee203566658249e82f4293fbe35e71b0ca58ad3e4623452a236", + "python/sglang/kernels/aot/benchmark/bench_moe_ep_post_reorder.py": "5d4f2896563650f3bb05a735d6101940856d3339de00812a9d1da66be02fcaca", + "python/sglang/kernels/aot/benchmark/bench_moe_topk_sigmoid.py": "73305c4e56d22fcd4a5debf1ce4c3f5a17aaecd24251a406243574a2babe9a91", + "python/sglang/kernels/aot/benchmark/bench_moe_topk_softmax.py": "254dc1895ba409fa1ff86f1381ebdb4001a488b441f0b3faf810a435268d50c4", + "python/sglang/kernels/aot/benchmark/bench_mrope.py": "a0774041acb66396d3e188cd8cf358c31ab2cdb19f5bec4554b581b5e3f2a472", + "python/sglang/kernels/aot/benchmark/bench_per_tensor_quant_fp8.py": "839732b35aeeaa36048b381295dfd5b06fa0f636407156fce33a43e270fac9ee", + "python/sglang/kernels/aot/benchmark/bench_per_token_group_quant_8bit.py": "5e655449992ce2975a5405c02ebafffadde9e7a32bbd80f17860df4e10f91d84", + "python/sglang/kernels/aot/benchmark/bench_rmsnorm.py": "4cb3c391b21d2780d9f9599092f276d3eeeb404a8b80ebe32f529f43e6dd2b0d", + "python/sglang/kernels/aot/benchmark/bench_rotary_embedding.py": "c31671792065aa7c4ff2fb8bffb48aec3bfbed58fb4a3cf210736899942ebf71", + "python/sglang/kernels/aot/benchmark/bench_sum_scale.py": "7c88fb44db929f77f507d5d27bd3b03ec27e6c5381528c7c376fe6f70fb7dca8", + "python/sglang/kernels/aot/benchmark/bench_top_k_top_p_sampling.py": "6c2015fbb141f89ba069cfe414c15355b8cbb8a68ed0f83f8de9aca8263befee", + "python/sglang/kernels/aot/build.sh": "b7019fba7e02354680e198c5f314442f61a3f8a77a5bc783e72403c5b5dac63b", + "python/sglang/kernels/aot/cmake/flashmla.cmake": "f8a31f77098c2e2e0dd6c478a3e4cc426825d3f51f8e8615b93266cd81d6c15d", + "python/sglang/kernels/aot/cmake/utils.cmake": "a4edb2f627936c18683b336ac8459f767c2abfabf84eda3e5d2a1dbf7e4edc25", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce.cu": "12b0101f40b045085a039e3ac4185e3d83547da8007c2a2a09d4d0b59c6785a1", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce.cuh": "1b9bbffb6592b5092caf83152d7277f8f8b935ea68ad3f73c4e88646503a2fb7", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce.hip": "bb461ec96c6a7e2b5dc26cdcd19e4a28452d100faae0be93653ff4cb501f8e62", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce_hip.cuh": "36a162c91ee3b302905936b337f195766c47bfc57365d0d9d264301758c6eb97", + "python/sglang/kernels/aot/csrc/allreduce/deterministic_all_reduce.hip": "5653edd5d3aa9e561ed64494ce6fb082164f62ae8652f681060dbf734b7fe66a", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce.cu": "3ad95ce83a50c546688b82fcb24038afbca9cfbedc62485e71eea2ee044d93f3", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce.cuh": "7dece95138d7d4494459ae346a3df7bcba33def4af3186ad34c6056f98331769", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce.h": "9a522ee8118418abaa414e637ad7d8913b89a8cd10c172096696bb8a24c49faf", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce_base.h": "f2f8b90c1bf6c2a02deb68c0b87899ef552252fa27d173b590b863b1102966d2", + "python/sglang/kernels/aot/csrc/attention/cutlass_mla_kernel.cu": "d22ff738ffd4e814fd0215f928385aaa959b121595ace21e55d22d2884694606", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/device/sm100_mla.hpp": "f411088638eab8ee0d22d7160779fe0c0830006c0184e09d3298d140df0bdbd2", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/kernel/sm100_fmha_mla_reduction.hpp": "01b0d650bbbf16b0d150ea634e5a4e92dbfd37d0a442a9b88701f15c1a32b929", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/kernel/sm100_fmha_mla_tma_warpspecialized.hpp": "644c75a7cb55eed77ee85b8b05cd784dd8aa9e80b9944e640e40a231a7f42231", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/kernel/sm100_mla_tile_scheduler.hpp": "e664316462e86130992aa56675efece67fc0b10504550d686f2257a29f392d60", + "python/sglang/kernels/aot/csrc/attention/merge_attn_states.cu": "9616eeea04989a033d4c26cc37887ecba926841d59965f2d443bcfe53038c5a8", + "python/sglang/kernels/aot/csrc/attention/vertical_slash_index.cu": "eb0e6cf3b48ead871cd662de53ae240c4a3da4bf07e9fe1db0e141ec08bffbed", + "python/sglang/kernels/aot/csrc/common_extension.cc": "7952111e8d8ffa20ca51e625f6e713eb93ff3b08f4a6f9bfcd482954b19c0520", + "python/sglang/kernels/aot/csrc/common_extension_musa.cc": "7048ae3e73d91f7fb8aaf83ba4fc26ce498ce555396bef8afe748fc224378d95", + "python/sglang/kernels/aot/csrc/common_extension_rocm.cc": "f0eb606c3d889206790c9debe54e8610f87cdeaa5dd618fca89a55e66e792eb4", + "python/sglang/kernels/aot/csrc/cpu/CMakeLists.txt": "606b7db5e872f2672cd1f156c89cd1514b21602c2c8073dbe6a14d8a3197fe1f", + "python/sglang/kernels/aot/csrc/cpu/aarch64/gemm_int8.cpp": "dbefb9838d6f10525de74e7c00b2d8b9cf94a95129352bdd636258128414418d", + "python/sglang/kernels/aot/csrc/cpu/aarch64/moe.cpp": "dc131c60f62c90d708fcf54bdb3b1a920c63697b16290ca508a8e3d58510e931", + "python/sglang/kernels/aot/csrc/cpu/aarch64/op.h": "f027911f459726a2d141c242b9fd15193928dbf81aa04c3259e80ac5092aa007", + "python/sglang/kernels/aot/csrc/cpu/aarch64/shm.h": "ebc2f3b2901168505609a51a9a95e76849546169e9a8dfd31eeaf6c9961e58ec", + "python/sglang/kernels/aot/csrc/cpu/activation.cpp": "85814e5f2cdc8396e958f8dbffa274b46db63d1e86c551f52b2db62b5b30cf1b", + "python/sglang/kernels/aot/csrc/cpu/bmm.cpp": "41d34a5b54926cc2ca769af4b4297b67ecdd25c7bcf51ac5720dc09297672b31", + "python/sglang/kernels/aot/csrc/cpu/common.h": "65384338e96d0c596a92ee17fc28ea51ee0e8c3b8832742327a7c2f0362b0783", + "python/sglang/kernels/aot/csrc/cpu/conv3d.cpp": "a167ebb92a6eef845dab2959f2304bca6b5fea62f6579b4f3df2b328537537a9", + "python/sglang/kernels/aot/csrc/cpu/decode.cpp": "c723317aaaf49b1c689c86313a85d1cd37caf7824e4f498429701cfb4c573dd0", + "python/sglang/kernels/aot/csrc/cpu/extend.cpp": "413e617fb3fe74ebe114730b4ef2aa560bceec5037f29dd740fc4cdc1fed663d", + "python/sglang/kernels/aot/csrc/cpu/flash_attn.cpp": "8f43a9cb15e3b9b9ec290c6ecb060f2f2aea16cb2bc46748b096702bd6904932", + "python/sglang/kernels/aot/csrc/cpu/flash_attn.h": "b4fe6bfab2545db10e104989d2f9b5686d5648fbc8740e3ff8aeffe4e3807aa6", + "python/sglang/kernels/aot/csrc/cpu/gemm.cpp": "82f2fb0b47e7d70247f83d4eb461dc804530706e2b6f629160b04cb6df175dca", + "python/sglang/kernels/aot/csrc/cpu/gemm.h": "b5b24090f2c17bce33250902942212008fa8ec5e69a163693b6aa8d990c7c7f0", + "python/sglang/kernels/aot/csrc/cpu/gemm_fp8.cpp": "db88e0528acada85b4c2c76e051e857663559a54d24a1b2bb4ee4165ed1faeb1", + "python/sglang/kernels/aot/csrc/cpu/gemm_int4.cpp": "ccabaffb60f3e70c66c98dfaa13109d241d207c528e7fce79570bd42d9626e0d", + "python/sglang/kernels/aot/csrc/cpu/gemm_int8.cpp": "bb57e5ce69c6bcf0e22d6fb934168c4dd680dfd666307c19f8911673ca6b4311", + "python/sglang/kernels/aot/csrc/cpu/interface.cpp": "0098034a6959b3c25db5896d32c16d8c605fe6e73ae91316498e2d3093428c40", + "python/sglang/kernels/aot/csrc/cpu/kvcache.cpp": "e08fd253f6c61989c714e01420fcf80b322714e958d7dee6d239b20891b9f310", + "python/sglang/kernels/aot/csrc/cpu/mamba/conv.cpp": "8a2a6eee0c6d83e3622ec5f74019b24cdd48f16dca9ccacc89d94ce4a6862efe", + "python/sglang/kernels/aot/csrc/cpu/mamba/fla.cpp": "415c55a0f61bc87073b7ea414e5315e20f8df9fa5542670ef2ad9894847b34d5", + "python/sglang/kernels/aot/csrc/cpu/model/qwen3.cpp": "a232f51d423ff7d88d5624777f3f6567b25c8458faf17a465a8a42a614c687b7", + "python/sglang/kernels/aot/csrc/cpu/moe.cpp": "afaed65c3b6c31855a5cc4800a4bfa240c525d73ebbe6e1fad430bb4594c15ae", + "python/sglang/kernels/aot/csrc/cpu/moe.h": "7b4f9244b5eb2d8d103fea74df8d15929073664aa87eddf25bcfbf276cd5d3b3", + "python/sglang/kernels/aot/csrc/cpu/moe_fp8.cpp": "bb37c7f2771f99202e2e72397d822e9caaaa598d8d53a84cd7ef158275c8b1bb", + "python/sglang/kernels/aot/csrc/cpu/moe_int4.cpp": "5401578cb03b5da19c713def8aa7a747e611093493c37a76e5c521dee9f6b624", + "python/sglang/kernels/aot/csrc/cpu/moe_int8.cpp": "6a3f61e38f1863381cfd9f3a2bda123945f9a062398fc1cf462bebc6be94239e", + "python/sglang/kernels/aot/csrc/cpu/norm.cpp": "6a75bcc1e1b5e94f75cbd8496a743f4abe808a5d09eb4108265e10329bc13a50", + "python/sglang/kernels/aot/csrc/cpu/numa_utils.cpp": "32bdc91aa9cbf9fd00777adb19954a0a10952e8d46314234c718ed75699c765d", + "python/sglang/kernels/aot/csrc/cpu/preprocessor.cpp": "410442288042cd40bca0dc19918cf587d2572d3dcb4e70d796d9b126dfb9b81c", + "python/sglang/kernels/aot/csrc/cpu/qkv_proj.cpp": "1c5a16226a392583d5666e73e96f29472efb5c885b4033b703d373e5ffdb836d", + "python/sglang/kernels/aot/csrc/cpu/rope.cpp": "6bc1264bcfcfd25663db5e6135d30fdecaff10382286655588d7c7f5dc5d2406", + "python/sglang/kernels/aot/csrc/cpu/shm.cpp": "f5249b7279391a710178e3fdd8192b5e9c9a07f68535fa66fc5af5a9926f1b4b", + "python/sglang/kernels/aot/csrc/cpu/shm.h": "c034540e6a55470a679177ca4d53425d7de821e1342e10e97762008e75cae379", + "python/sglang/kernels/aot/csrc/cpu/spec.cpp": "7459e239ce4a2f35d58c962b36adafa5884f4259ee99f74b4065eee36d51dc73", + "python/sglang/kernels/aot/csrc/cpu/topk.cpp": "a67c7b12b57d8e1631976d2a167acd1609ffeeace4f3fd336263ac8bf1ac085f", + "python/sglang/kernels/aot/csrc/cpu/torch_extension_cpu.cpp": "5976e8571ce8bc074431e4230d85f7defd46bf1f6bc725404b19853980849a0e", + "python/sglang/kernels/aot/csrc/cpu/vec.h": "72d9318916091d8372c7e6d0a6e69bd71817440edc98eef80f463a5449a1cf04", + "python/sglang/kernels/aot/csrc/cpu/vec_pack.h": "9487659e2354abf11ab2d989f6028fc977c356949eca27e315ba28a97c2df227", + "python/sglang/kernels/aot/csrc/cpu/x86_64/shm.h": "5d52546edfdf191ee10f84d2f87bf44f4684f7fef4f8929a280772fe20d19c94", + "python/sglang/kernels/aot/csrc/cutlass_extensions/common.hpp": "5de164ba11f88ce97abf986b0a856a72b95564ff6079d0541b75c5d38c545ec1", + "python/sglang/kernels/aot/csrc/cutlass_extensions/detail/collective/mixed_input_utils.hpp": "5e6c0d9a009a87677cb6958c41f8d9f371714beb0978d172ce59519bb38f8697", + "python/sglang/kernels/aot/csrc/cutlass_extensions/epilogue/broadcast_load_epilogue_c3x.hpp": "4f342e9ab7305df18424d859c4aa25a6811d3c6516dcaa79a15079621b6c6913", + "python/sglang/kernels/aot/csrc/cutlass_extensions/epilogue/epilogue_per_row_per_col_scale.h": "e28464d5dbd99c91a815b3dce5c12ac43000487fc8c87ea350253caa383c6b7a", + "python/sglang/kernels/aot/csrc/cutlass_extensions/epilogue/scaled_mm_epilogues_c3x.hpp": "128ccc10afb20f0b4493cb0f7d076fb647e3396ebeae8524b167d87bdf65032d", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/builders/sm90_gmma_builder_mixed_input.inl": "a55bf4d13931215540082d2b3e9d31f5260e284eb7246e83d5a4549095161ca0", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/collective_builder_mixed_input.hpp": "0a88dd2755576dba7ab85c9c175efbd2e5e41735443786c9c1f50b660e511f94", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/collective_mma_array_mixed_input.hpp": "c177521617b5626ab1c1ac05312d284f815db68eac2fb348fbae08fee18c7690", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/sm90_mma_array_tma_gmma_rs_warpspecialized_mixed_input_.hpp": "3646b448374d4e2bb35c29b64b00cb4a2ed11ec2086f01fe8a8ef78e13f1bfb3", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/cutlass_gemm_caller.cuh": "cfcb02916adbeb21878a5dacdd20b6b06bd24f9a6ada3f95254bf0e667e2b89d", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/fp8_gemm_sm90_dispatch.cuh": "549d3c1c5c13d67e7309cf50610a51c9485eb181b3a17423247287abd1a0b038", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/gemm_universal_base_compat.h": "468650577a2d861baa3fe2e20540003fcfc362742c1c53836a7cce44f32c3b4d", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/gemm_with_epilogue_visitor.h": "28fe0ba488957b5091fe43dcec6a4379ed95afd449b63437a61dd683d76e6cd4", + "python/sglang/kernels/aot/csrc/elementwise/activation.cu": "dffb5a9cbbb4d26a75e7e8aea0c0acfa2e68c64158466854fd6d54262103a7d6", + "python/sglang/kernels/aot/csrc/elementwise/concat_mla.cu": "f41395045b483ac3528e46a1d80ea9cfbf40d744123db9dfbfc011189a37addf", + "python/sglang/kernels/aot/csrc/elementwise/copy.cu": "a194cd8cd7756453781f9b719794e73ceec3434b794fbc6528e1be548d6f76c0", + "python/sglang/kernels/aot/csrc/elementwise/deepseek_v4_topk.cu": "c9cb9025efaee27c88c257fef446d9d17b40fd9588f5a1d928d62d8a1d4a3067", + "python/sglang/kernels/aot/csrc/elementwise/dsv4_norm_rope.cu": "b7ce890d1edf72b627088f8de94912ca6f63f82bfe3df752530ca58df0a7c538", + "python/sglang/kernels/aot/csrc/elementwise/fused_add_rms_norm_kernel.cu": "91173e4c7d1139209dbe60ada9f6c160cc579e64d6e2bc6093b19489f194d893", + "python/sglang/kernels/aot/csrc/elementwise/fused_add_rms_norm_kernel.mu": "14f903ee5446cc4ed670a928b2050cac50cd9a2b125ff37fea1aaf942e6fd5f0", + "python/sglang/kernels/aot/csrc/elementwise/pos_enc.cu": "bcb566f16d4b280ad970929cf588b887670cf9412cb44c45ca6ec6487c123017", + "python/sglang/kernels/aot/csrc/elementwise/topk.cu": "f899cb9d2db331f2315e84f89c48716863870082f76ae65428ae4d865b0205d7", + "python/sglang/kernels/aot/csrc/elementwise/utils.cuh": "e1f8762cebe626fd0a4014db77af2dc3a03a754fb086344bd8df35c5e9d34987", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise.cu": "1588e12f0577d71c8d0444ee93bea01d66aef4af1985ee41dd7e0d343437114b", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise_functor.cuh": "20a9ff701eb620020b543571c4a308b73aabae0adeb6b02ed4eb6795fda8279c", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise_launcher.cuh": "1e74f78bdcdde807ffb4a31a96d9439360f1fb709812e157a2c0e5feea81cdae", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise_traits.cuh": "2b4dc917c37799228adf58881815ca2307e527b8211df5c52b698ab297a29131", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled.cu": "62351cae829471d4e2f1140c284ef71fdd9b2f2ac9739e08657d3feaea73cc43", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_functor.cuh": "7b04f268f0a05a931f0c666d139cbdc3b54a427b556357514162821839cf7bd8", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_group_quant.cu": "7a682171f357b4eaefcaf94aca7c827598e97c6eadeaa3120068c82d61495379", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_group_quant.cuh": "8a386c3336f37540b8e0b91c87f0f21eb7f7de3e48b02c3b8d19456691aaea23", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_launcher.cuh": "aca30ab23b21cb1c3805f3b33a00f9b4517d7307e47f38d534c44e7cadbb0008", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_traits.cuh": "1c4fbbc2d1e5c8d605cce7b46d59c56675f7e0172fc35fbe5cd3582db7dab9ff", + "python/sglang/kernels/aot/csrc/flash_extension.cc": "9c237be7a8fe53b3785472c6ee1fdb0636023d8006cab281bc565389e7dfe78a", + "python/sglang/kernels/aot/csrc/flashmla_extension.cc": "aa4b35b211026318df6a5481f57ff32741bb90d9cfb955b8e83eaf8dde93dd77", + "python/sglang/kernels/aot/csrc/gemm/awq_kernel.cu": "06bf26e1fce3ab5a70fb2f66a95d51b6461a2fdae11df5f423a3353eeda397ad", + "python/sglang/kernels/aot/csrc/gemm/fp8_gemm_kernel.cu": "681c8afd21ddd78fb656ce9643b4988743faa64f178f48d55b87dfb8be9217ad", + "python/sglang/kernels/aot/csrc/gemm/gptq/compat.cuh": "4a2d33e68e4930293d32475a6f57edd5e42d343dd642cbf1f5a492558e505374", + "python/sglang/kernels/aot/csrc/gemm/gptq/gptq_kernel.cu": "6f726c7687d5721d645759dae892b70ccf18cccc929cca31f5f0b1fae986de64", + "python/sglang/kernels/aot/csrc/gemm/gptq/matrix_view.cuh": "efb127be9bbeded2111ecefd4df9d2b5eb625c0ffefab904cef21ef1b1657aa3", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_2.cuh": "1a706e6266736241be7f851697c4c4ecd685c9f0b0894436530eebd81761000d", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_3.cuh": "f7fae2447ef01c66d3b62758a860e041ae3b6477714846a8be5834215aa23a51", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_4.cuh": "7fb89f88bc54d7df14293c272694bd984e987f62d569ab7408c484d403058494", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_8.cuh": "a65c9207b4dd8815680cf525155ead154b3ce098251073adb6138b876ff56f7f", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_util.cuh": "3a0712467f6daae5e3ab86027091048aeb5aae39a0213b0b44e361d3393398c7", + "python/sglang/kernels/aot/csrc/gemm/int8_gemm_kernel.cu": "e328045120e3c884e33bb905ab646df6cc0a1544ffb7ba838c945136fea0c2f3", + "python/sglang/kernels/aot/csrc/gemm/math.hpp": "b80a3ffbbe5944c865331da95261696e430981b623d447adf24f272241104f59", + "python/sglang/kernels/aot/csrc/gemm/per_token_group_quant_8bit.cu": "fbc0d20e0bb890b0c84b665c92069399e2fd9ae6d9ab6fed4487ddd9ae43fc54", + "python/sglang/kernels/aot/csrc/gemm/per_token_group_quant_8bit_v2.cu": "66c638e069dae59e6c1f9a618299199d86f0963eca57cd26517a71d4596bca62", + "python/sglang/kernels/aot/csrc/gemm/per_token_quant_fp8.cu": "c8a3e755dc165cecfa09232bed58e8b36010061f050acf2f82722b75c3c1edb8", + "python/sglang/kernels/aot/csrc/grammar/apply_token_bitmask_inplace_cuda.cu": "72610dc5e2effa6b8e46518dc398cd9320f251a444b1a03026f44d80d70ce194", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/flash_api.cpp": "cb99aa9ae74fe2514e4103d76b549a57a1b3b0805ee8823792bc63c547d74f59", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/block_info.h": "338f8246268db78724cbd7720c553247b302ee6002db1ba8b643ed4586309608", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/dropout.h": "02efa0d8584b2ab0793a9e40c69d13d49ee07b66f91f573f56ab42786af9e4ec", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash.h": "72c173aba8ffa52627ce9ed74c82deb03dc3f53c61a380825fec277e4f07de59", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_blockmask.h": "e0fb10597a7e22170d3e6e4e20b7aabc24543f3f24bd8a2f4369cd6236478a9e", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_kernel.h": "768fc27a85ac26c311def3e5c3c7f49cf0df3e4e0fe60ee00347f93bb3b97371", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_launch_template.h": "f8ba739ac0af00da53a7737aa954b4ab693690cfe23ff28ae8e5770985eb6c51", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim128_bf16_causal_sm80.cu": "206684211db2830b101122c741da0d0a7cf96a1219ae1a79012fe9fd0e04cd4f", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim128_bf16_sm80.cu": "ce345f08360f2112b4e1cc3646bf1efaa4afaccb4a12db6cd661ea84ea8868c8", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim64_bf16_causal_sm80.cu": "bb1d25fffadb5393500e2502a5cf3650720187ecbe227f9a174934364356e2c0", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim64_bf16_sm80.cu": "bf75ee560818988da58a2cbdef13e60185dbcee9577f14e0e042ab3f4f4cf385", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/hardware_info.h": "3adb689a79f653b97b19ad0cd5a25d8b44d71dda43c55cf774ca9f698d61fe74", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/kernel_traits.h": "440f8322a0e9b2b07c165fd0b62360bfbc28e1640944b1b5c54dfe31b6fee367", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/mask.h": "50637532c664222e24d0e42d916c3bdd9382e05ee8241d0bb30cdee85c929493", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/philox.cuh": "131c4da3f06a3122242878bed3574e2e2353ae6d4eb228aba5028204a5232a4b", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/philox_unpack.cuh": "14d35e2e51b5f248d7007d4f783c46c29f5803444ba7d4e30204a50fd6811ac5", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/rotary.h": "f616830da4716124b6962eb200a3fb5c26e22bf4b13c0aa7ada6f17f73adae49", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/softmax.h": "8d61de3d1cdd8dbffd506c63f9231626b133b2db54cae93a71f3607d3753d691", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/static_switch.h": "b873eca73e4826d2da525405a80a16fcb23cd6a416c2b94b99c35646ac4f8ffc", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/utils.h": "c7d40d5605abb766478d1f2cbb2691eabcf376a4dd03d609732eb8b6671583ba", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_extension.cc": "968bdf8e0b951ca19a97c2ae9c36e9c938dc7df1fc6ff92e7e6a2d03e11fce92", + "python/sglang/kernels/aot/csrc/infllm_v2/max_pooling.cu": "3376def6b26d2f527e51adfad1a8dd8f5f8fa22f29dd3d6352e765d0f043cad4", + "python/sglang/kernels/aot/csrc/kvcacheio/transfer.cu": "9e45665fcb3652683948754449f4d31e91117f53874bedd1285d67f7127b285f", + "python/sglang/kernels/aot/csrc/mamba/causal_conv1d.cu": "93421646032517ce921319ea86a78086de164de5dd7c7fc95ddaa075d2c1c8c5", + "python/sglang/kernels/aot/csrc/mamba/causal_conv1d.h": "2e4bfde82f89142647170a7812270b42f487627c6032fc735da52ecb43e006f7", + "python/sglang/kernels/aot/csrc/memory/weak_ref_tensor.cpp": "f8aed1facc79cd1e7f15cec7e8b5ece97cc12d0569a4183a0a69925ed5b24d80", + "python/sglang/kernels/aot/csrc/metal/README.md": "fe9699f735ffbb368fefb831a7a64b27ee5049b21cd9656493a8de53e696e697", + "python/sglang/kernels/aot/csrc/metal/rope_pool_fused.cpp": "2df146a113b9590d1cf575b65af28a0c454ac2e59365b90abcadccd50075e116", + "python/sglang/kernels/aot/csrc/metal/rope_pool_fused.metal": "b35b95a18d956288360b571a9d08cb3765dff377df7c202d39385ba9bf8f50d6", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/scaled_mm_entry.cu": "96c8953053bd1206bbe90f57e43ca6ae5f5467e561dceba7c3bdf9cbaa08a93e", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_get_group_starts.cuh": "f254d94fdd77acbc221a587f9e82589c3c9cb85ab45d6cb4ff339a0e783e749a", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_grouped_mm_c3x.cu": "5569ab6a80fc6d9fefbc986edbb61ca67bd9c44b0c7be453916aaf163aaf78ec", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_grouped_mm_c3x.cuh": "e8dae3c98e24e4285b22efd97524ba612b1706e089707792ca0c2d9c1a5c1d41", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_moe_data.cu": "3198cea71295f8dc474e9ea0bfb837bb76ecb4fa2988e6c6e4593c4ca53af6a7", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe_helper.cu": "44a65aea73b94d50d7ae15aadecb27df8907139f83ffba0c2726f50f2929773e", + "python/sglang/kernels/aot/csrc/moe/fp8_blockwise_moe_kernel.cu": "b812c2972bff64e1571d22d7313efbe330c3322d06cfd25e50b098f418a3fdfb", + "python/sglang/kernels/aot/csrc/moe/fused_qknorm_rope_kernel.cu": "bedd99015a68a39175c20b07c917046d7ee25b268aed9a998fab01a3423455b2", + "python/sglang/kernels/aot/csrc/moe/moe_align_kernel.cu": "4f1afca3ec9687272213e4dcae2570fbb0ff98e418a0d73e542850d245969feb", + "python/sglang/kernels/aot/csrc/moe/moe_sum.cu": "d34f734c50db73d52100a03ff0c958f7216301f376f8aa4625fe810ea002993c", + "python/sglang/kernels/aot/csrc/moe/moe_sum_reduce.cu": "03717a4617562fb7704854dc276568c587e998f248b6addcf25e12d9fe2ffef8", + "python/sglang/kernels/aot/csrc/moe/moe_topk_sigmoid_kernels.cu": "4b8eadf84561c8b71c31893508caacc2c132a15510c725385616775a59e16ce3", + "python/sglang/kernels/aot/csrc/moe/moe_topk_softmax_kernels.cu": "e1ba39d23e79b5a209f8ea6adddb283170055f1d5523e63298a8aa1e70ba0e9c", + "python/sglang/kernels/aot/csrc/moe/prepare_moe_input.cu": "811aa0a3bb94ceb65cd2d156a79d8355e1477c35177ef0b60fe3a74e90b26be5", + "python/sglang/kernels/aot/csrc/musa/common.muh": "23faabc0b5750254f7e36666677aa5c7d13dffde67444939f8af4b4dfe38d7c5", + "python/sglang/kernels/aot/csrc/musa/dtype.muh": "49646e157e5b9d1adc5123c90d51bf72f5b0e21e9cddf0204b6389d865149e39", + "python/sglang/kernels/aot/csrc/musa/moe_gemv_swiglu.mu": "35d8a2e327fd4a27f77e9043a3e29c29efd21a792d64b30887c1a0826b9e6268", + "python/sglang/kernels/aot/csrc/musa/pos_encoding_contiguous.mu": "a29f93eecbe8364f7553ec33957d597b03caaf068095b7806c94bc1a26a97dcb", + "python/sglang/kernels/aot/csrc/musa/ternary.mu": "fa932c991708954f91be0f1027ea0908d801f5d001262234084bd7f4cb28cd85", + "python/sglang/kernels/aot/csrc/musa/top_k_top_p_sampling.mu": "789b4a6c5cb4db331d3dab2b27f27a0e6d45a948e84674bb4a01ca20b4f6219c", + "python/sglang/kernels/aot/csrc/quantization/gguf/dequantize.cuh": "e43f4899fecbb4a3f0f9bc1cf4ba9d5febed22c109caf8ed4174b1c3f2d17aba", + "python/sglang/kernels/aot/csrc/quantization/gguf/ggml-common.h": "9bd236e5116402243ff4b243fb8a8e42056ff1ae825be12a7b6da2fb108e8698", + "python/sglang/kernels/aot/csrc/quantization/gguf/gguf_kernel.cu": "9905943cd6987a139bf75753b0d2480bcfc5396f8cc9f0fe08d224451f098f32", + "python/sglang/kernels/aot/csrc/quantization/gguf/mmq.cuh": "442bb32c4becd009c0925811d800d52378a5c41188ab2b3958b82033ccd02a17", + "python/sglang/kernels/aot/csrc/quantization/gguf/mmvq.cuh": "ba9b2f97e6ba383f0650b3833311e28a7906f2de1fb98635c09f3e268abf253d", + "python/sglang/kernels/aot/csrc/quantization/gguf/moe.cuh": "6f96c93d0d35989037422e4ae5cf88ed7d3a01da8ce6449649d2ee109700c1ca", + "python/sglang/kernels/aot/csrc/quantization/gguf/moe_vec.cuh": "99573567e402824b589a10362ec9e820b6072e1ad453e739de8fc2f4557d60c1", + "python/sglang/kernels/aot/csrc/quantization/gguf/vecdotq.cuh": "7c544d85fbcd3cb6ddc1c67ff6ef1315e390d62cc92a4af0021f9690129adf67", + "python/sglang/kernels/aot/csrc/spatial/cuda_utils.h": "b2373c5172585e7ed3f289d6b95e5c5176db48bf0a5c9f155b1aa9fc7b76e0c6", + "python/sglang/kernels/aot/csrc/spatial/greenctx_stream.cu": "de20703fc8a6f359ecbcfa2d91f6556b61fa94cc605e2d606a3e075d0d898305", + "python/sglang/kernels/aot/csrc/spatial/greenctx_stream.h": "35982dff2acf36ef001c05fe220ede5984e1ad3606f0733d520f5ba4b4bd4cd5", + "python/sglang/kernels/aot/csrc/spatial_extension.cc": "5f4f6abcf0f2f47a49bd17c9f238f6cafe1824cf1b9eca4d098c4b971499fb7b", + "python/sglang/kernels/aot/csrc/speculative/eagle_utils.cu": "734d7bac46bad97d8c6446234c4875f4e8d7bc2816358eed56847d926b8ddaa2", + "python/sglang/kernels/aot/csrc/speculative/ngram_utils.cu": "d5afce91de182f915cb9ed3fe6d02c0e3c31ca3409ed87202fbb0e9783f8edf4", + "python/sglang/kernels/aot/csrc/speculative/packbit.cu": "9484696972ed750f8737a0512eb9246090383f7b0793b38b06fdfb85ecaf44d7", + "python/sglang/kernels/aot/csrc/speculative/speculative_sampling.cu": "a572115a4467989a78a3833c2b47b4097886d2d2a7c31391b714b8adcc394413", + "python/sglang/kernels/aot/csrc/speculative/speculative_sampling.cuh": "2ba289074e83f1df6cefa219b674b08c3c20061d0b5b328bf2681be7b88cbe2e", + "python/sglang/kernels/aot/include/hip/hip_act_and_mul.cuh": "854254686226b67592f6eb8562fdd8af48f8be8f09bc703ec08228cb09c73003", + "python/sglang/kernels/aot/include/hip/hip_math_def.h": "c8f8e302aebb1b187355f39d3dfd63703618c7946b66a2e5dee252881e36a69c", + "python/sglang/kernels/aot/include/hip/hip_vec_dtypes.h": "a1267963adc88ef49bfa017b4bf24fde8f4848c93e0ab7da5c5a3a4d55155aee", + "python/sglang/kernels/aot/include/hip/impl/hip_vec_bf16_impl.h": "f02542bee4e9551b17c94fa37a25cfeb94ab221ba29aaaab12e72312f5c26667", + "python/sglang/kernels/aot/include/hip/impl/hip_vec_fp32_impl.h": "d53b84a3aadc4c5789beb3a8bb1bf65a3b77f09d0659a0bc3eec451bf559a17e", + "python/sglang/kernels/aot/include/hip/impl/hip_vec_half_impl.h": "4c0ad29942f1dc2026bd838d7eba9e243d8bceef8449e5d32cd8c7e6e175d6a9", + "python/sglang/kernels/aot/include/musa/dispatch_utils.h": "ecaccdd4d957e209e9ecb09f5bc062f81d89954464ccf57ce5a78a9d66452b1f", + "python/sglang/kernels/aot/include/musa/integer_subbyte.h": "c025fa298197df52096c40141d6ee448bae96d3e1648b75225c7826e46eae0ee", + "python/sglang/kernels/aot/include/pytorch_extension_utils_rocm.h": "e23b3520c211db5334bf9cb3977f6d6d617766e63a89eeb708474c4cdd58d5b4", + "python/sglang/kernels/aot/include/scalar_type.hpp": "16333e83eb1a6a46bcbc14fca3c49249db80083b7c0bf7afee96114f94c5443c", + "python/sglang/kernels/aot/include/sgl_flash_kernel_ops.h": "895e3d6ba3ebfbe70c49a70cc96bb3745d9c2a8a35f3b64d19c7c9e54c961664", + "python/sglang/kernels/aot/include/sgl_kernel_musa_ops.h": "f68a29838d3f39ca0db23fdc3439039f374ccef429f8252d99cbc58deca417f1", + "python/sglang/kernels/aot/include/sgl_kernel_ops.h": "c26e4df2fdb420856f18c3b28276deda346fbc0f4195b7f2066960abfae078dc", + "python/sglang/kernels/aot/include/sgl_kernel_torch_shim.h": "af561b9c374499cf463f2302f7a52d0e7af0d4039e2b1db6c73292ede3a62700", + "python/sglang/kernels/aot/include/utils.h": "442a8e60bed72f78886ad23ea478b00bd0e0a21421c845bec8b035b24c6caf1c", + "python/sglang/kernels/aot/kernel-runner-setup.sh": "a975029ef18a2d93d9edc6afd3919f45c5996d9825b731208c127994aebb929d", + "python/sglang/kernels/aot/pyproject.toml": "58c174b9a07901f09528cbc6f0bc29977b93019a1b5d4201f4012bc7d39faecd", + "python/sglang/kernels/aot/pyproject_cpu.toml": "6ef324147d97db4b5ec653c2f7159195aa1df47834b0686dbd13e08eb9259f7d", + "python/sglang/kernels/aot/pyproject_musa.toml": "4794ea61ab60e421be123b6d624a8c59f0594b90ef6b3455ddae914e9d0d49cf", + "python/sglang/kernels/aot/pyproject_rocm.toml": "d7d4d7203dbf53092951d62c0966b205fddcbb015455f55c1aa642bd8ed37d10", + "python/sglang/kernels/aot/python/sgl_kernel/__init__.py": "a912485cfac6a2f28b4407807ef66d31d05e140ad79a4b7e8a009d358c49706e", + "python/sglang/kernels/aot/python/sgl_kernel/allreduce.py": "89acec7bb9a4538a82eaaadb67057ec4825b4bd2b13b1e5508f0dc441515348e", + "python/sglang/kernels/aot/python/sgl_kernel/attention.py": "b7363f7e3a976ade65d62f2cdbddf27dc7d2659df623a3f16045780d359c37e4", + "python/sglang/kernels/aot/python/sgl_kernel/cutlass_moe.py": "38a92f0897ab45242ec2e75e3faf84f8b5668abcb7a4d894c58c2de2b4f3b221", + "python/sglang/kernels/aot/python/sgl_kernel/debug_utils.py": "096c0dd0dee4fd57cbf00d6b0fa734f44b25403d627f40bf95fdd7e26fd1759f", + "python/sglang/kernels/aot/python/sgl_kernel/elementwise.py": "5af8a849dff586835b679618c568940afe8d6859b329268311ff5538f1b7356a", + "python/sglang/kernels/aot/python/sgl_kernel/expert_specialization.py": "c03ff2d24672ad0656870387671437c3e247a571dd39e9768cd4f40cb0d182c9", + "python/sglang/kernels/aot/python/sgl_kernel/flash_attn.py": "610747f2c68495c5f3ba67f1247f0a1b4e4f7df116e2f89cd8e8983f0271f9ac", + "python/sglang/kernels/aot/python/sgl_kernel/flash_mla.py": "7b4d4830a23b6349db5d530ba34920337e26b814b11f79c15e0c797054e26386", + "python/sglang/kernels/aot/python/sgl_kernel/gemm.py": "bcc6815ae2bd529f7aa8e0c4649557f85f4f3a30a52a0b267c516653701dc809", + "python/sglang/kernels/aot/python/sgl_kernel/grammar.py": "3345ab05c87474b7286d606a3ecd2b3216ed2ef1a4dbde3781e597d6491f12d4", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/__init__.py": "80528ed06dc2d02295d55cd9e906574bc28a3637bf36ce993d9b58029656c40e", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/_loader.py": "2ccca1059382518cc0d8b9057aed9c178924fd9bf34ce453e420002254437ef7", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/attention.py": "98d9b084a9c7cff0902fbb7e5e8d6dc6301b517245b47cb15f68916e4a4aed24", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/max_pooling.py": "72c09227a77aaf532d7276a1d9438e19060cf211dacb66c734bdf50273e92782", + "python/sglang/kernels/aot/python/sgl_kernel/kvcacheio.py": "76378182be4f3bf06fc88acaa7a4a5803d302cc6279c4cb2a75960273a988dd1", + "python/sglang/kernels/aot/python/sgl_kernel/load_utils.py": "e7db471562b3fa3748af4793fc1647f23d9dd2142249d6cccd6bbe671a38c5c2", + "python/sglang/kernels/aot/python/sgl_kernel/mamba.py": "451bcf76c35cc191eb440df80918920b52abe14f39baf6b6d225068e9a008e6e", + "python/sglang/kernels/aot/python/sgl_kernel/memory.py": "1d20daaa7336a20049c310f86a18ef5bd5f39844541cc91c5b66288375383c97", + "python/sglang/kernels/aot/python/sgl_kernel/metal.py": "b4851811dac0bcef891655288617f9a0cc3288995cb1739361e8d5abb03266ac", + "python/sglang/kernels/aot/python/sgl_kernel/moe.py": "7d2b3862905962127f89eda91a537ab4e522dc251cdc404631762f166a57bbf4", + "python/sglang/kernels/aot/python/sgl_kernel/musa.py": "b9efc53b00c0b47d85026aad0a2ae639d74ea66493cdc80a8b62902e5ef5acf4", + "python/sglang/kernels/aot/python/sgl_kernel/quantization/__init__.py": "a7d723f109f161665b6b741016e9dbc5bea724919f2019e68f29054b9f94cc51", + "python/sglang/kernels/aot/python/sgl_kernel/quantization/gguf.py": "6c924e2261309dd8ebf92bdbef4b71a00a2d716faf7fb23656011dbca7f35fce", + "python/sglang/kernels/aot/python/sgl_kernel/sampling.py": "80f01a3812ff7be617c169ab82828a09fa4f22969c42cdcaedf3a01c628bfdf8", + "python/sglang/kernels/aot/python/sgl_kernel/scalar_type.py": "ca0c5beb5cc3dd2b3c02b51dfd75d2fd9f8fafb143e063be855f8d3f4012b305", + "python/sglang/kernels/aot/python/sgl_kernel/sparse_flash_attn.py": "9211e2a98615c98e0edc69232fdccb22c8a01dd2c4e822c099e2b9e689ab5561", + "python/sglang/kernels/aot/python/sgl_kernel/spatial.py": "687898eefeb3b267ce9c0476b2877b72ff7fa8308d9cbe369294fe9893686aa3", + "python/sglang/kernels/aot/python/sgl_kernel/speculative.py": "2af216aec3e41d0c3240dcc131a0017ff734f93008f99d62d4ac30d06e1f4b46", + "python/sglang/kernels/aot/python/sgl_kernel/test_utils.py": "615d5d2124c69e20504223712ec6a12a93d4da6ab97b502f5f198209faa848d1", + "python/sglang/kernels/aot/python/sgl_kernel/testing/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/aot/python/sgl_kernel/testing/rotary_embedding.py": "3300617a366ad038b1d22002a4d9a66f3fcc04ac4eed484e4044f94c3d9c1c26", + "python/sglang/kernels/aot/python/sgl_kernel/top_k.py": "567c1c5725fad322b6e7b2d54b216a48740c9c66b58af6ed8f45a944c67fda56", + "python/sglang/kernels/aot/python/sgl_kernel/utils.py": "cc778f3a0da90fa453f684086b32c9d426fad752787f899b584431f086e13f68", + "python/sglang/kernels/aot/python/sgl_kernel/version.py": "99bedc65616d05360f828b675ffd6801969d1484cb1eb017c134acd846f576f5", + "python/sglang/kernels/aot/rename_wheels.sh": "868e715de2c2947ebaaab15ee6b2017ee2eff196630732ecaa74fd6e218fbf51", + "python/sglang/kernels/aot/setup_metal.py": "b7a37c3ba45d36562ffc75b3404044db9d38aa1f8a4c53fa0fc1121f6a828bc8", + "python/sglang/kernels/aot/setup_musa.py": "0ebaff2ca7a3b0aa518d98d45a43602f3ff965eec7f51f5268493439c76a5679", + "python/sglang/kernels/aot/setup_rocm.py": "87a8171878c36d18452d24a4efdcf9eb1cf09bcd1692042a788673749e6eb4c5", + "python/sglang/kernels/aot/tests/conftest.py": "d915f91707370a962671a554241a2bbf96ba3fae0c2a7a6e3d2aaf159d6a2f61", + "python/sglang/kernels/aot/tests/spatial/test_greenctx_stream.py": "aed5808c6fb05e60b00640e7d825f65c59f3a4e97b0e6656e8a84c594761a39f", + "python/sglang/kernels/aot/tests/speculative/test_eagle_utils.py": "198d47ad4b4f81b2f5d8a8ad4161bf857c87e86c9a2b5746291f6245ddecdb6c", + "python/sglang/kernels/aot/tests/speculative/test_ngram_utils.py": "d71a84b5cab3a98e09b92b6d6c6b5b6ecf0a235387dc124d083ca93c0b90128e", + "python/sglang/kernels/aot/tests/speculative/test_speculative_sampling.py": "f59059195c8c31159833d779e8a0bc988ca233112f65d75af24ea72d0db60d29", + "python/sglang/kernels/aot/tests/test_activation.py": "2fd80bbccd5e429138a0d163d46ba79f497d6fb947040b43d6f346d6bba905c3", + "python/sglang/kernels/aot/tests/test_apply_token_bitmask_inplace.py": "bfbbc29e342aa0c44c2646aa654f9445cf91aa2dd2d24b499d937a86a5a61872", + "python/sglang/kernels/aot/tests/test_awq_dequant.py": "2873ca279cf90b1734b7c96df358e9c62929adab9bf0f3be93bd036f2754e6cd", + "python/sglang/kernels/aot/tests/test_causal_conv1d.py": "252f9b9dd90dbbdb58360c88bafc018048b8a1c4e90b81fc46fdfef59acc65c4", + "python/sglang/kernels/aot/tests/test_copy.py": "71312e5fc1f2579a676bee1769edc52e486c95412b45d93b7bdc56d1008a0f95", + "python/sglang/kernels/aot/tests/test_custom_allreduce.py": "d2ae02bbfdd1cddf07fd1bc508d0f29094215530a12bda655670b0011beef501", + "python/sglang/kernels/aot/tests/test_cutlass_mla.py": "decea5a2a956b9e109e9c0d1f5eda558f6fb3c183eb67052385e32c8496e7331", + "python/sglang/kernels/aot/tests/test_cutlass_w4a8_moe_mm.py": "f02124611a58312fb7f9dceeeebf396a2f14ee6e73341ab7f43460925ed79618", + "python/sglang/kernels/aot/tests/test_dsv4_norm_rope.py": "9e42901508a5611132a4c95e14746395964557cb87ed56c44f6a9c9956686434", + "python/sglang/kernels/aot/tests/test_es_fp8_blockwise_moe.py": "925515f5ac77f3e9e0b303896d8bd379fec655efdc5c2c38354d6a6ed52dec8b", + "python/sglang/kernels/aot/tests/test_es_mxfp8_blockscaled_moe.py": "0843eb2853ebc8858525fb86ad9142a85594bdab8f4b247c957ec9e04369c8d6", + "python/sglang/kernels/aot/tests/test_flash_attention.py": "fd827e844ec95d5def4eb24882735c5b2b9edbba1d5beacf70b05ed847db99ee", + "python/sglang/kernels/aot/tests/test_flash_attn_sparse.py": "9f0681803e24ba629229eccaa7bc5843f9e019570fd358901926a714f87ae06c", + "python/sglang/kernels/aot/tests/test_flashmla.py": "6a50b68e252985dd01cfb24530786090a5f67f223f2613f21488ce22d88af4db", + "python/sglang/kernels/aot/tests/test_fp8_blockwise_moe.py": "157c42ae1101f32e077514acaf3c0c4c166a130d7a8bc020906db5a6ce60ed40", + "python/sglang/kernels/aot/tests/test_fp8_gemm.py": "16e23f28db3968e23553049076e6848139828543d2e78b8f30e3a651bc430c65", + "python/sglang/kernels/aot/tests/test_fused_qk_norm_rope.py": "36d4692e2e514e1638c96e3bb5bf143ba325c44fe451b56271583a69c7c3d288", + "python/sglang/kernels/aot/tests/test_gguf.py": "bc903b715cddbe06a9080f85628e6fcfaabe6e4ff0a10c6a08d71076c97f588e", + "python/sglang/kernels/aot/tests/test_gptq_kernel.py": "4c629a9dfd8a89fe08231897853f1c5d6c697d38e708cc4e3d884c2058a78315", + "python/sglang/kernels/aot/tests/test_infllm_v2_attention.py": "892f282cb77b8b80a7a1bf75a2e26f87bcf19c452fcb194cf0229ddd738c8115", + "python/sglang/kernels/aot/tests/test_infllm_v2_max_pooling.py": "43da1a8132e025def95070b081dc53a396288b461cfbf67968f6b755631a2052", + "python/sglang/kernels/aot/tests/test_int8_gemm.py": "c881c4cc6b0683b8857cae1bb5641a043b58646d70ccf6d22ae402ae4045cfac", + "python/sglang/kernels/aot/tests/test_kvcacheio.py": "48cfc734b01177d941e033e05ecf060682961b212287fb84abb78bd521602d57", + "python/sglang/kernels/aot/tests/test_merge_state_v2.py": "2d057b965a2fcbd9a7771e543b911374f7cd1ce2ab7bd7a0cd09a9b751c77af3", + "python/sglang/kernels/aot/tests/test_moe_align.py": "66a80d5dc4e874f528dc3b83e06adc3f261674b9d5d86eaf6de4b33dae5f6f48", + "python/sglang/kernels/aot/tests/test_moe_topk_sigmoid.py": "70d79d86a51976b4cdd24a2794549483f4c8164fa6dd25176fe6a316d38331c0", + "python/sglang/kernels/aot/tests/test_moe_topk_softmax.py": "2ed1ebc5cf07b4dc1d99588c2d551f9b4d142985d38a50ae0e66426224d343da", + "python/sglang/kernels/aot/tests/test_norm.py": "58f5d01b30699b221faabba56cfb8e8ce1dcaab6db227ce3734b8a3fb4bdad70", + "python/sglang/kernels/aot/tests/test_per_token_group_quant_8bit.py": "db350e50d381e3e0d44dd92128862cf4301d0d9edda09ef9658f0cc84fb0d9f7", + "python/sglang/kernels/aot/tests/test_sampling.py": "4835c5e20778b0e223893aa517ce8846955ae1282651ed5545f26c70c0f5be1b", + "python/sglang/kernels/aot/tests/test_topk.py": "c59211e1480251cdb0d4d8ecf3a05838388764bb7d8d0dd8e9bab0e7e4e7b16a", + "python/sglang/kernels/aot/tests/test_torch_defaults_reset.py": "c6f480087adb952a8a4c48d889de38f084609e3282e9e83320940ea932da8b5d", + "python/sglang/kernels/aot/tests/utils.py": "59593109617eccbd0c9a23bc52f1a167437005cddbe0576fcee904307f1e2f30", + "python/sglang/kernels/fused_op.py": "d676a11cc7a68eb4e4e3fb096454b18279719df0c681562036b9db595dd65c4f", + "python/sglang/kernels/jit/.clang-format": "ff10f2f096ddc386f50248987d484d915b9c82f142e970c7af2537baba88f9e9", + "python/sglang/kernels/jit/__init__.py": "7d3a182933356ee4a73edae72cde73251f9b4ba13b7a1b1731b6bc8acae20f5c", + "python/sglang/kernels/jit/__main__.py": "fabf3deb09e00dd8d745c1a2cd5873549601acc9b71f66619866853a24bdd96c", + "python/sglang/kernels/jit/benchmark/kv_canary/utils.py": "46c598858d164bfce232eb48bfc5916aa80e3f41fd27744ab7b282af58ae1c35", + "python/sglang/kernels/jit/benchmark/marker.py": "7fbf26e2007cea158de50a593efcf8ef8ee69e60b509cfd6df89156eaf12bc5a", + "python/sglang/kernels/jit/benchmark/utils.py": "24c533e70352bf94b9a12d6185384b4305be1f4e1e1a566bcfd47fe9d1c92690", + "python/sglang/kernels/jit/csrc/add_constant.cuh": "ad1e5219cf6eb63f5affe92cb782576cc1f238d11f39c6fbaadf757b3b88fdcb", + "python/sglang/kernels/jit/csrc/attention/fixup_zero_kv.cuh": "66695df6792a2a1dc913da535cfa5df61f011ca8e553a7efaeef7f9e794cd11b", + "python/sglang/kernels/jit/csrc/attention/fused_fp8_qkv_kv_cache.cuh": "b28e18d57ce7def3e593a8f2c29364ca8a87044c8814487ca1d079dced8fb595", + "python/sglang/kernels/jit/csrc/attention/kda_fused_decode.cuh": "d0a2078431d967efd252aa8f4a003d08fce03a34b5860d8ef5b922004d11f53e", + "python/sglang/kernels/jit/csrc/attention/kda_packed_decode.cuh": "22bd2d7675b5dcdd623d4354418073aee9686951cf7a8710b27a0ce6c65e8ca3", + "python/sglang/kernels/jit/csrc/attention/kda_prefill.cu": "9d918668ab24c4c4bd9c74c193040e97af1a91f657eff8822fc94bf4d2dbbabd", + "python/sglang/kernels/jit/csrc/attention/qsa_indexer.cuh": "672290ad5594ba94e0006f73c9d1f341ba768a9adfddbc9296b94a88d4feb77c", + "python/sglang/kernels/jit/csrc/deepseek_v32/indexer_k.cuh": "18b93a66c8d194a00c2c4010059839c9a1439d36292d834b62068e6e570987a5", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128.cuh": "5b9cd573814ad422b6ea74749bf85a6d7fb572a6c8d33b706255727318b71f1c", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128_online.cuh": "56b7d8ea4c8fc3f155c0d6d40752c57b952aaa750538af39e0b6a1c2a74589d6", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128_online_v2.cuh": "8d300e8943fd6e3d7c2ccfa21e8f80489295bee411fc2f84294f8f9842ea15a7", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128_v2.cuh": "e8ee36b093eca277d2fe37f51ae21d26695e135be09da518fb82d52a17fbf953", + "python/sglang/kernels/jit/csrc/deepseek_v4/c4.cuh": "16cbbc7075baeffe17067d92ca9ff2d7bb94be6812edcece91d1b5c29173054f", + "python/sglang/kernels/jit/csrc/deepseek_v4/c4_v2.cuh": "051c7de8c9ca0c22d13215905ce99b44f2b500adc9ca7eec141f9b2211715642", + "python/sglang/kernels/jit/csrc/deepseek_v4/c_plan.cuh": "b0d792dc409ea18a8d0fe9eabe26be7b338ab86da496b588ecfb93da7ad4159a", + "python/sglang/kernels/jit/csrc/deepseek_v4/common.cuh": "793ff2ce21920bb1a62531ae5355b58a69fafd6e476d9e1dac203cbc5e261ce6", + "python/sglang/kernels/jit/csrc/deepseek_v4/fp8_wo_a_group_major_quant.cuh": "afb56b97c677475c667e0399c9b7af6c1ca222577a15a4950d57bc5acf88eba2", + "python/sglang/kernels/jit/csrc/deepseek_v4/fused_norm_rope.cuh": "97f6bb13534724cde2658a88e7dd77df12273742d241252911a44222db9b3bf2", + "python/sglang/kernels/jit/csrc/deepseek_v4/fused_norm_rope_v2.cuh": "d3215e51ee7204ed78d6800705d61ff395558e264d2e75e065b3396f6c6ca34d", + "python/sglang/kernels/jit/csrc/deepseek_v4/hash_topk.cuh": "7830147cefd0b95254242883dff567549987e50dcd81b7c6dac4a89198d260f2", + "python/sglang/kernels/jit/csrc/deepseek_v4/main_norm_rope.cuh": "133631596f649104ded59981bc2c0c51f9590bde40e8097e6c64a9a7177add88", + "python/sglang/kernels/jit/csrc/deepseek_v4/mega_moe_pre_dispatch.cuh": "715272b21652502dd619ec9e9d96c8d7b20ab3ae686a78b7ecefd45aa7b128f5", + "python/sglang/kernels/jit/csrc/deepseek_v4/online_c128_mtp.cuh": "dc5eea6ac0bc4ccc9b686e6a5dd7427fce25e750b02501079b00bf7cccc49286", + "python/sglang/kernels/jit/csrc/deepseek_v4/paged_mqa_metadata.cuh": "77168812edde134a14d98f9b6a24a140cf391c5c101addf07e716c7b02270227", + "python/sglang/kernels/jit/csrc/deepseek_v4/rope.cuh": "c599b6d5bce1f3e7cfd0422707cd1a1ad33ea676493c9fe36d73810834e88103", + "python/sglang/kernels/jit/csrc/deepseek_v4/silu_and_mul_masked_post_quant.cuh": "c3330410de115d91eb14b1f395365b9243a3403453e1ee5e0a99c3715edfbb7c", + "python/sglang/kernels/jit/csrc/deepseek_v4/store.cuh": "022addf9eece267bf8962ebd0414a2945fc6b72349bcbd35be5a45be3535cbeb", + "python/sglang/kernels/jit/csrc/deepseek_v4/topk_v1.cuh": "e0bd5e43e045d2b263b4796449e513f93f0fd50a522ed5c81ce42385850e0802", + "python/sglang/kernels/jit/csrc/deepseek_v4/topk_v2.cuh": "3b2d091c830698a6ef2820eab66da83e17788ddcc72101694850f440e1ad17f7", + "python/sglang/kernels/jit/csrc/diffusion/causal_conv3d_cat_pad.cuh": "c0091f6d158cf2ec919ed981d416b40f144e3f02ea1eb55acfaf68ac5ab55f9a", + "python/sglang/kernels/jit/csrc/diffusion/ltx2_qknorm_split_rope.cuh": "cdc91194188f11eefe18df510d54f6bf53b736d0cce3610f7484225bb5aa17a5", + "python/sglang/kernels/jit/csrc/diffusion/modulate_scale_shift.cuh": "33570b4d2adc897ed2a91d95a4e5f0e6681f8504904d699a3d9da48ebac3e7a5", + "python/sglang/kernels/jit/csrc/diffusion/norm_scale_shift.cuh": "ee74320288d630067af17dcf4bcf6c93d05fa3e16fb1e04d4f8086f8e97bb09b", + "python/sglang/kernels/jit/csrc/diffusion/qknorm_rope.cuh": "4d2f194e5100beb87ae555bfe68d9188a87b24c0ae59de75ccdfd287bfa12a5a", + "python/sglang/kernels/jit/csrc/diffusion/residual_gate_add.cuh": "19f008a703f5f0181a321628e9b62113701ae97cdfd77cd1d871c0c574047fa3", + "python/sglang/kernels/jit/csrc/diffusion/timestep_embedding.cuh": "59f4d6c7e0c470b92cc0da405db6aaef11e3092cd1b7b388e91c2031e25be252", + "python/sglang/kernels/jit/csrc/diffusion/usp_relayout.cuh": "3de2834c294e709027f68a3d526cc403442c64cae101d055565f4274c606ba34", + "python/sglang/kernels/jit/csrc/distributed/communicator.cuh": "b6aa6fa2dc87103fd8cfd32a9e7e8b822d5b28c8e78b98473fa646579ff81309", + "python/sglang/kernels/jit/csrc/distributed/custom_all_reduce.cuh": "07b0e6bec91da8f83f5c59e1f8da669e42df076f2c032932baca3bb8ab31e306", + "python/sglang/kernels/jit/csrc/distributed/ipc.cuh": "6f3aa5350b9b9daf596429b57db4b43d3584862d446d869e87cd73d38b393a72", + "python/sglang/kernels/jit/csrc/distributed/tp_qknorm.cuh": "eb461062686d3294d62637c73423b3421aacd4f70d42b5ab88ae2d2d2825502d", + "python/sglang/kernels/jit/csrc/dsa/fused_store_index_cache.cuh": "1a6d0b7b9cb9c200bfa573ed99f25c4502a0d2024400d7a2923453c4a77eaa8a", + "python/sglang/kernels/jit/csrc/elementwise/activation.cuh": "f1b56af7476695688d11bb004dc6cee144cd8922a56683a12c504c53aec26c47", + "python/sglang/kernels/jit/csrc/elementwise/add3.cuh": "ff31c39fca59586f43ed78198bfc035981dd4e49b4bd924ac3f8bc57807307c7", + "python/sglang/kernels/jit/csrc/elementwise/clamp_position.cuh": "71ed5158000a33330b8fcf8d1cb7603aa0d45f9e5c5381e4beaf652a8ee20a9e", + "python/sglang/kernels/jit/csrc/elementwise/concat_mla.cuh": "ae7e5e72f33ad0a2af0933a23a4cc46230310253d69be464c72d2fb5f46e1ea0", + "python/sglang/kernels/jit/csrc/elementwise/fast_topk.cuh": "8f2dd6ae5647f44473a1666978906581c635ebc44d4e8ff6c7977d5522ab911f", + "python/sglang/kernels/jit/csrc/elementwise/fused_add_rmsnorm.cuh": "31f906f1b51f64e6c5cf57e79f8d6acb0278ccd2547349aaf133b3fe4457bcee", + "python/sglang/kernels/jit/csrc/elementwise/fused_eh_norm.cuh": "6589eefbaab4ed170cce6bc000a49b06ba3c84bf05646d109c504d06983f420b", + "python/sglang/kernels/jit/csrc/elementwise/fused_metadata_copy.cuh": "a5ed33f509938790e0561e342ca879871133f481cb922927ba99955027d4b16f", + "python/sglang/kernels/jit/csrc/elementwise/fused_qknorm_rope.cuh": "bac3d717589496835368e3a571c7592610a8d9e43b7f25dd1d37a10b61fdd10b", + "python/sglang/kernels/jit/csrc/elementwise/grouped_gemma_rmsnorm.cuh": "acd83fd2cbd5ca4f3c6ca5362560954812ca87237b48cae80e44cb0958b849ec", + "python/sglang/kernels/jit/csrc/elementwise/hc_combine.cuh": "e251e31ad2a0bf5193abbcb0b95becc3721e26c2af69d321a517e741d35e7ee3", + "python/sglang/kernels/jit/csrc/elementwise/kvcache.cuh": "987d1a3e5d8a8a288572e31a148cebc8ab435def2378fdb828ed4e6ebf9aa39a", + "python/sglang/kernels/jit/csrc/elementwise/pos_enc.cuh": "8f77ea7925da40905fe178a038b012adcc34407c653e5a37be2cf8707a9badeb", + "python/sglang/kernels/jit/csrc/elementwise/qknorm.cuh": "ce585aaa8ed461bed8cd58424c4979204f3f346af7389918fc3594b4342429cb", + "python/sglang/kernels/jit/csrc/elementwise/qknorm_across_heads.cuh": "a3accd93f8afa05d836814f7df4f83aa8c68a807ca157c2bbe35a0a7e7c53745", + "python/sglang/kernels/jit/csrc/elementwise/rmsnorm.cuh": "52f4acbc6c5f82dabb90ac1ef80d8e030e69be68c1790583f462a9d641eb8410", + "python/sglang/kernels/jit/csrc/elementwise/rmsnorm_hf.cuh": "e20a3900bc88be6979efb4abf2f74cdc71572458e10f6be0a32ee109d9c68fbf", + "python/sglang/kernels/jit/csrc/elementwise/rope.cuh": "46780a3c1b3339a5f925f463f9589b39b95cc1f6689c3b7e3384eccc0b35ac73", + "python/sglang/kernels/jit/csrc/elementwise/set_mla_kv_buffer.cuh": "6fb00d6bfd8976292624f2889fdb353692c930422a56f348c18559985494a6f9", + "python/sglang/kernels/jit/csrc/elementwise/set_mla_kv_concat_q.cuh": "1a9173ed21bc156714a8dd7e8afb38fe231150d2ea9ee794b76bb34790692ae2", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/code_gen.py": "a98b3dd290b3d51ba9fa8ff37017f3004571b4dcb1d4775a7058999e120c8792", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/fast_hadamard_transform.h": "a172ebb9e66aef598c329a5e66198123e17663bbf8cb5b2df994f164d8eae54e", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/fast_hadamard_transform_common.h": "9142ca8c99423ae5e16cbd2016baa1d1d914c70c5fade96d26cb67c8aa1bd9f0", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/fast_hadamard_transform_special.h": "3a780812ee6425803095087b2548a26998a6e4ec8410290ee0ae57af634bbabe", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/hadamard_jit.cuh": "8d9614c3b1b2ed698242dc4241102a9d6aa5b4db06efb0c9f63057cf80c9f573", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/static_switch.h": "d5563e8b2e4d240ed5b64520d550116897d3132b892bf304e6d949042596ecaa", + "python/sglang/kernels/jit/csrc/gemm/awq_dequantize.cuh": "0269dd78d136acd8cc96deff925b02b187a2b8b86c535c4944f2ddda9a1a4840", + "python/sglang/kernels/jit/csrc/gemm/dsv3_fused_a_gemm.cuh": "32e77bc885be4c51c734119ec44f56623691c17850a3e598f0846dd20d79528b", + "python/sglang/kernels/jit/csrc/gemm/dsv3_router_gemm.cuh": "dafb382089f6ecb2c2497613caf6cd135d16307c13e45683a0bf1ab670d0874b", + "python/sglang/kernels/jit/csrc/gemm/fp8_blockwise/fp8_blockwise_scaled_mm_entry.cuh": "33d41c2ef4fe7f752b3ee571697c4cff5f4a1c061c0a6b0f20f7693eef9763f6", + "python/sglang/kernels/jit/csrc/gemm/fp8_blockwise/fp8_blockwise_scaled_mm_sm120.cuh": "57c41c6d9eb62cae7fbaa4bd65a5c1cfc63c28c133f592cf8ce8ac2088825e6d", + "python/sglang/kernels/jit/csrc/gemm/marlin/awq_marlin_repack.cuh": "15e0041d645d198c49303769a1a664bf9ed77d94b2dd7aa2e6c83277bb0db9b3", + "python/sglang/kernels/jit/csrc/gemm/marlin/dequant.h": "f07f0e1284431bd630d605b438c054509573c495d66d3a2b2e017396d84887a0", + "python/sglang/kernels/jit/csrc/gemm/marlin/gptq_marlin.cuh": "00fb263e7308b2d2cf2ec180ec53b3ea18c66ce5fef993efcafe0872b8950247", + "python/sglang/kernels/jit/csrc/gemm/marlin/gptq_marlin_repack.cuh": "baf9c493860b8f2d7af160c82a65b5b963f1da77afb02adfeb9b266435c72aaa", + "python/sglang/kernels/jit/csrc/gemm/marlin/kernel.h": "d2866eb1ad6342a106bdbc4edc87b5b3a8139d652af5bde4ca3f3d4d1ef69518", + "python/sglang/kernels/jit/csrc/gemm/marlin/marlin.cuh": "bce2c9316e047749af8553b35a30a9d5decb062d174952b6d5e46f9096494419", + "python/sglang/kernels/jit/csrc/gemm/marlin/marlin_dtypes.cuh": "fbddccaab5802b44e6167ee3747a207b88defeda2addbb04f737b85843b36185", + "python/sglang/kernels/jit/csrc/gemm/marlin/marlin_template.h": "c314a899e797b788dc3b0cf7e79d2ba2bd839a8338181e4c6c06942d15e8797b", + "python/sglang/kernels/jit/csrc/gemm/marlin_moe/kernel.h": "b7a0dfdbe8bd12dd4cf87236a0c7e102b8668e5d328b7ec2d8542b942fab4ec2", + "python/sglang/kernels/jit/csrc/gemm/marlin_moe/marlin_template.h": "6b43bc72d64a591bc86f62df2db14bdea5adce7b70b00af1a3e601a3c0d24fdb", + "python/sglang/kernels/jit/csrc/gemm/marlin_moe/moe_wna16_marlin.cuh": "a8c60a970f55eb28ea5673b471a40fe1374a6578d6b8ab3427148e1587309d0d", + "python/sglang/kernels/jit/csrc/gemm/per_tensor_quant_fp8.cuh": "a482dd40cbed6f7ea40b84d1c30d46b8e137a728d1ab1575b2497a0c8268066b", + "python/sglang/kernels/jit/csrc/gemm/per_token_group_quant.cuh": "238d3d4db7a36ae36e118bed8d37aeb9893cb40d0f5c2670cb307416499e9678", + "python/sglang/kernels/jit/csrc/gemm/per_token_group_quant_8bit_v2.cuh": "7719545131a8f77de08213f347f7b6ae242dcfb4ff2b9c4b25e42f0ad1e62020", + "python/sglang/kernels/jit/csrc/gemm/per_token_quant_fp8.cuh": "1b0603ace7a61533c9ecaefc77129cf75d459b6f1f7866cd3437e686d8024342", + "python/sglang/kernels/jit/csrc/gemm/tiny_gemm.cuh": "b6fd96712b080383cfa407b72e3516720e5283c65642ba4edb5b765e4d85fccc", + "python/sglang/kernels/jit/csrc/hisparse.cuh": "58b4d685eca4506e37b50b90e3b84a97e60481913fe274bbdb6266b3ae3efa4b", + "python/sglang/kernels/jit/csrc/inkling/causal_conv1d.cuh": "8185ba6e936a3333270082de515107ac511c0b20f05d281ed7169481f284a3f8", + "python/sglang/kernels/jit/csrc/inkling/draft_extend_sconv.cuh": "81072166e47849c0f17f6002378be5fb46649d1cfaaf261752bf3c60ebede3f1", + "python/sglang/kernels/jit/csrc/inkling/fused_decode_update.cuh": "c0f8f07a69182dacc7a857198190446ac56805844c2433c677f0bb3e8da5cc9f", + "python/sglang/kernels/jit/csrc/inkling/gather_scatter_sconv.cuh": "858d9657ba459bc79be42a48ce19cc3a93e701117395f14b1fbba83a192314cb", + "python/sglang/kernels/jit/csrc/inkling/inkling_all_reduce.cuh": "7df29829abf216717ee03cfa7fafe0abaf0e8a5be19dfed872b6a64de5d3bd88", + "python/sglang/kernels/jit/csrc/inkling/inkling_ar_barrier.cuh": "ed2c9fe6fc05c5e97d51ad7c501f6ddf5cd48e2de19cad93d4bbce57b19dc907", + "python/sglang/kernels/jit/csrc/inkling/inkling_ar_fused_decode.cuh": "2538a37b776d2d3c9c99de9f49dc5af3e5d171e5ac863861aca2e85150daf9b5", + "python/sglang/kernels/jit/csrc/inkling/inkling_ar_scattered_sconv.cuh": "3fd31b83efe21ac944b9fc872dee33cb50cf68bb08989cceb61616bd55218132", + "python/sglang/kernels/jit/csrc/inkling/inkling_attn_prologue_fused.cuh": "8d4d4bfba861b2dc20265f242a2f65a6a20dce63e2ed9cfbb7cd7a8785605822", + "python/sglang/kernels/jit/csrc/inkling/inkling_rel_proj.cuh": "c3c2b11b1fea4d191c7c2ffea9f09a4c1870eb618230fcb32421b084f51e61e8", + "python/sglang/kernels/jit/csrc/inkling/inkling_row_scale.cuh": "e7ae0573ba97ffeeefda8de155f40e8c03b8262f50b722e8f7154dc33b4a993d", + "python/sglang/kernels/jit/csrc/inkling/update_sconv_cache.cuh": "ed171c22a99ae7675d080044a4bfd4dbf32535b9686696c2829706a7f4d7fbf7", + "python/sglang/kernels/jit/csrc/kimi_k3/attn_res/fused_tma.cuh": "c67a610f15cb4faf6f4797fae052340ca6b93805774cac92a95f6b602b42f64f", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/ar_fusion.cuh": "c232ca37e83915c843b6e2dcaaa94b676eca034886f04c8a7118ca17553b65cc", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/gemm_ag.cuh": "094807027542cbdd9908c8bd00fc048c2e0577ba466787d9a0112579fcce6266", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/gemm_ar.cuh": "e04b083b051ee38d98d0445cbd7483f6d75247f0d95e75fa6eb1912e829c63c8", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/ptx_sys.cuh": "3e774aafe8c524fec8b0b7744b330fc292f50ed205ea5d01814f35080fc75d34", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/sp_collective.cuh": "47fbc28a578db6566206531a4f625c4b09c90026653d7ed07c3964e44709555f", + "python/sglang/kernels/jit/csrc/kimi_k3/mla_output_gate.cuh": "a898572ee61e6d5ed092508e6317c4e049453b4a3055a27b1b09f6b6e6d7d596", + "python/sglang/kernels/jit/csrc/kimi_k3/situ_and_mul.cuh": "f115fe9d64db37ab1deb85e481d98240c436a8e4236cf95fc74146726dff797d", + "python/sglang/kernels/jit/csrc/kv_canary/canary_common.cuh": "6da3c1d349c1360694ce842cb3626d24db5039916fbd21217ded985810f21a27", + "python/sglang/kernels/jit/csrc/kv_canary/canary_plan_entries.cuh": "50e31d69f717651c4699ce50bb74bbd17ff5b3ed7329179ca827944b867ad9bc", + "python/sglang/kernels/jit/csrc/kv_canary/canary_verify.cuh": "e3f4ff7b9debe237d02cbdc13014f718031735073a11c11b19d5b7761e48b4d4", + "python/sglang/kernels/jit/csrc/kv_canary/canary_write.cuh": "a70eb75252982eb80f8c886cab052b3051aa3abadefbe15b0deedd978a3b7af0", + "python/sglang/kernels/jit/csrc/kv_canary/consts.cuh": "026e2d43e2b28ffdb031a20ebb4e2096ed77be6739444aa114b84628fa334d3e", + "python/sglang/kernels/jit/csrc/kvcacheio/hicache.cuh": "dc34f219c0c18c9111df0383db55e88bd59ed0717c139f4907096202036b7dcc", + "python/sglang/kernels/jit/csrc/kvcacheio/relayout.cuh": "5eef475951686a10fad64c2fca749935fd32a4e5ec9fe544de1bb0fb11a3436a", + "python/sglang/kernels/jit/csrc/kvcacheio/staged_write_back.cuh": "1794e12145ff90d65c32fcbb276b95c912683bbc60403dbc9f4a39b8017dea91", + "python/sglang/kernels/jit/csrc/kvcacheio/transfer_mamba.cuh": "21928b36df0588cddb62e0571bd3772a82faa4c2a3b415f094c509913388e9c8", + "python/sglang/kernels/jit/csrc/lora/moe_lora_align_kernel.cu": "406a8ae7ba84990a0864906b623f7dc46e68094587a5391d660dfe81a9cd6179", + "python/sglang/kernels/jit/csrc/lplb/dispatch_probability.cuh": "7a599a45668e1f0ba5a9b818298ed96405da81a55070184a4e5845a66714a53f", + "python/sglang/kernels/jit/csrc/lplb/ipm.cuh": "57a5f55eb0747aa72454fe65ba323a8fd31e8d716c8027f982bfec01c2ca2af5", + "python/sglang/kernels/jit/csrc/lplb/lp_post.cuh": "1932e8ef7ac2158f0dd75b6c6738acf3f701798a9423479a930cd9416ad7eab2", + "python/sglang/kernels/jit/csrc/lplb/lp_prep.cuh": "7d88b8b81de7bf0587f1068f7ed05b07382afdf681056fdd58e6867d2a2cd1c0", + "python/sglang/kernels/jit/csrc/minimax/fused_gemma_qknorm_rope.cuh": "336de8cd9adb1b78dc532e5734a99b5122e288cdd220bafb563381d4cfd770de", + "python/sglang/kernels/jit/csrc/minimax/fused_store_kv_index.cuh": "e09124ed2d1a9b2a91a1264d4d03fe8d0730b6ef91d602319cd5bf441aa678fb", + "python/sglang/kernels/jit/csrc/minimax/minimax_decode_topk.cuh": "1ff9ab6bf3079cca673799943efd6c5c9ac7cc7f33cc6ac5f5bbe5dfc369612e", + "python/sglang/kernels/jit/csrc/minimax/per_token_quant_ue8m0.cuh": "10d7e1ab1bf2a23c8a3984cf2b5c80d541b8e17911acdd5cf589943bd5b6c623", + "python/sglang/kernels/jit/csrc/moe/align_single_token.cuh": "284a9e08472d44beb552c7f13c2ed5b61c893561b95227ed49dae15e08e09ee3", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_group_quant.cuh": "398d73664bb560c2a0e1f99a5788b939793093dff2f1740a318569f7cfe6d7c2", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_moe_group_gemm.cuh": "abb556104569a0d6138516d187d1fc769fa81b613d07334eefb1744a382f26ee", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_moe_group_gemm_functor.cuh": "e4c2e9a37b380465b0eb2a8a12a0730c7e5a87ef4d66f8583918cae0715cdf53", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_moe_group_gemm_traits.cuh": "a50295047703237a860b9a87d348891e130fd49dbcf943bf2f60ddc65e2828dd", + "python/sglang/kernels/jit/csrc/moe/inkling_gate_topk_renorm.cuh": "cff262d7fd533cced45dce24c24e4a86a08bba5599b75f62e59e7022d67a9020", + "python/sglang/kernels/jit/csrc/moe/moe_align_kernel.cu": "2c17adf81459e91fd7ad149d63ef95dcc75eb5246859c83999785003e1e72770", + "python/sglang/kernels/jit/csrc/moe/moe_finalize_fuse_shared.cu": "e2fcd4ff823725a3b0d773b9c83f4c90a964e0d2c496e3a676baa143fee77970", + "python/sglang/kernels/jit/csrc/moe/moe_fused_gate.cuh": "d336c973d0491090f236e2f4585b0974452ad9f9a6260f11af2ce7627c00ff49", + "python/sglang/kernels/jit/csrc/moe/moe_permute_prepare.cu": "e58d9bab7cd10f0cd4871008a3dfac42ab5afff3e36236ba6015c0afdd168191", + "python/sglang/kernels/jit/csrc/moe/moe_topk_sigmoid.cuh": "fee82bba2fb4ca0f4e5bed7763141ea838808d37f4f771a36a52e0833b0d0c2f", + "python/sglang/kernels/jit/csrc/moe/moe_topk_softmax.cuh": "f9c8ee1f1e9af1037612418cda472b907c6455262c93a5d1e20764cf065fb55a", + "python/sglang/kernels/jit/csrc/moe/route_quant_fused.cuh": "00a830f28c924f2bc89ac280ddee233b0d2ba701850e6bfa4d140fb4960e688e", + "python/sglang/kernels/jit/csrc/moe/route_radix.cuh": "f93a2c03c15bf98203b0412b96aee97422020e4c3d22b55416afb99dd42e0c29", + "python/sglang/kernels/jit/csrc/moe/topk_sum.cuh": "7490919bf896fff6b5edae2819c675fdb526b90fdeeaeda1fd6679d8441f36f5", + "python/sglang/kernels/jit/csrc/moe/tvm_ffi_utils.h": "58649a287b1daecf47a996dcf5ff97d225181bfb6880303b60745a606fdd1757", + "python/sglang/kernels/jit/csrc/ngram_corpus/ngram.cpp": "b7300b2911647871022f10a49cdd37736f84778bf96736234bec51a307c1a8f0", + "python/sglang/kernels/jit/csrc/ngram_corpus/ngram.h": "6f0d5387ad103989b306029a9471b205b5f8ef198c68686afa430d5c22f93f4a", + "python/sglang/kernels/jit/csrc/ngram_corpus/ngram_corpus_ffi.cpp": "a2d4a93da60bdf3c6c36c439a8afaa70bf6ff3de6ba24558177348376c7e580e", + "python/sglang/kernels/jit/csrc/ngram_corpus/param.h": "659ba17b9f053a8aac36d8d3ffe30e87e781cebffe6ff9554adad8681913b112", + "python/sglang/kernels/jit/csrc/ngram_corpus/queue.h": "682d35035db7c33fd84d576b8a5d352abeb24ed422b04de5aae180d8d7586b53", + "python/sglang/kernels/jit/csrc/ngram_corpus/result.cpp": "9964b88c15f50bd3fc27fffa94d097858a5b63b3cdda2076b66bc6c85aec7fcb", + "python/sglang/kernels/jit/csrc/ngram_corpus/result.h": "fcd172342fae7beb50cd4e164caadc41908685b0ae183664331bd900bf1402e9", + "python/sglang/kernels/jit/csrc/ngram_corpus/suffix_automaton.cpp": "368f4ea6dcd5500324097171cd1b9e0cb7a0879bee227c7cc5236c7ab525fcdb", + "python/sglang/kernels/jit/csrc/ngram_corpus/suffix_automaton.h": "acc2a2f5c9b3f89546062f283910b56cd59c3be6c0cf29c35f53da38d82f76ca", + "python/sglang/kernels/jit/csrc/ngram_corpus/trie.cpp": "371ac7f5fdf9d6c55ff894a5ae668d7168257257fb484bf661f4bf0cb65ddb68", + "python/sglang/kernels/jit/csrc/ngram_corpus/trie.h": "4e72052b2c6070a923b8124f4a4d61d4424e20aad5d7190ad10c83ef564847de", + "python/sglang/kernels/jit/csrc/ngram_embedding.cuh": "90556360102cbf1ac47eaac5ab500a9ea07a924ed273fa56ab21a63c23967a02", + "python/sglang/kernels/jit/csrc/qprep_bf16_fp8_sm90/entry.cuh": "4c42ac4c702e7162acc1b36a98e8c694b8d4a1f134b2de18ea4451a224808280", + "python/sglang/kernels/jit/csrc/qprep_bf16_fp8_sm90/kernel.cuh": "4023069a19b12db9ce3489fc591e63e44aea7c4317a784f9485c5d34cbfbba11", + "python/sglang/kernels/jit/csrc/qprep_bf16_fp8_sm90/params.h": "2e37fa9934e1555f888b9c40eb9106d64ec9cd088b35c7c4b8d84d1301b20914", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/config.h": "cf5ac5b5f0f8d69f4a6d093a51df08be7f8ec1a7137508c6f6ade32431a5759b", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/defines.h": "89c365d662f0f15e264999b5556a6627f6c61a254411ab28de79853e4a98bf1a", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/dense_fp8_transpose_v.h": "42330889541bf80258014c8984fcc1b2c9dc42bdbc64018a06f6fb58db5fdaf0", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/dense_fp8_utils.h": "34165574c9498c1fc2189b495f36d7177eb6ca113dfdcc68800e3f60fba87443", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/entry.cuh": "e30b002075802d045fe5813936d1951baf5c7d3073c0f51f6fe12d1c845a1830", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/helpers.h": "331ff0405e757a62c53cc21e0936b399725e8395165803e1d65f392090c811c9", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/kernel.cuh": "a5894c569493eef70582cb18b7920bb69285fdcee6919c6946b9836872fa2032", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/params.h": "e4dd80e30f31c1ac368ce6f5c1bd95e2b2e4d753d0853c1dd4309e498bfcf0c9", + "python/sglang/kernels/jit/csrc/trtllm_lora_temp/kimi_k2_moe_fused_gate.cuh": "f9bc440197f1e297f8773ab0892e99800d16233f936950314b06dfbf3c34e5bc", + "python/sglang/kernels/jit/csrc/trtllm_lora_temp/moe_lora_merged_align_kernel.cu": "cc39fdf9fd8df60afad33c3c263b659d62d8961a3a5aaaac965bf0a4df50d0f1", + "python/sglang/kernels/jit/csrc/trtllm_lora_temp/topk_softmax_pack.cuh": "727b05ce97d9fae8c98d878fa552f6cecd7fc3832a705e2208ac26dae415034b", + "python/sglang/kernels/jit/include/sgl_kernel/atomic.cuh": "c6027db53247cef8de1176fa5ef4b3e1aa459a468014ad90fbde67712917a572", + "python/sglang/kernels/jit/include/sgl_kernel/cta.cuh": "591d5f3014a43cc6bef5e5e86cf8b0304f79a86e35f4fd015585bb33b7c8079a", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/compress.cuh": "fb90d430136a949651c6f56316bca5134e2e3366b6edbfa7dbeef858a4b09b46", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/compress_v2.cuh": "33c3b30c05894ec589a7dc1d377e557c6193f42603324b8ce43fab5e3b37cd09", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/fp8_utils.cuh": "18fc737eccaeb4a6d657ab601361b3391082385d0e808c9393159c932918985d", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/kvcacheio.cuh": "be8387ed456d64f9fe707a02708d541ac7793723619af63d36d2206f0ebc16bc", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/topk_impl.cuh": "8b4842c35f2c6a733c15c4c0e2e6e3f6d5800fb5694ae075659ea71e5afa3935", + "python/sglang/kernels/jit/include/sgl_kernel/distributed/communicator.cuh": "6cd35c7716eaf20d184abd4ed238074042a96fef0c18e18200dda0761f03c192", + "python/sglang/kernels/jit/include/sgl_kernel/ffi.h": "def534f44595978151e47056ea77c9eb91c9c1ebdd8f8145425704846f756a8e", + "python/sglang/kernels/jit/include/sgl_kernel/impl/norm.cuh": "d8dbe98b5a69faf48aa39f13c73306c0882dd92cfaea2fbdb42541692283c0cd", + "python/sglang/kernels/jit/include/sgl_kernel/math.cuh": "9e63daa4b29bd93bee873eabc7e374636c6c28de237d8b63beb70cca755bdff5", + "python/sglang/kernels/jit/include/sgl_kernel/mbarrier.cuh": "51153324b76e8683c9127ddfbccc3c0503e39d7192c7fd4c93cb0c68142584a0", + "python/sglang/kernels/jit/include/sgl_kernel/runtime.cuh": "f5d625427f6a78ea945adafe1eb0c9af35c5a46ae36ebe20d073756db7b04654", + "python/sglang/kernels/jit/include/sgl_kernel/scalar_type.hpp": "e1c15e090e603b230c14b0589455217773c4565b432549aed8126dfdffaa3e7b", + "python/sglang/kernels/jit/include/sgl_kernel/source_location.h": "300026cbeeabe03b10b0c46b70e2e85b19a743cbe9ff462faa1dff4268cf806e", + "python/sglang/kernels/jit/include/sgl_kernel/tensor.h": "61747de0460e2075dc6bd298212d860b4bb9812645b33b48316b3648d9ec3d40", + "python/sglang/kernels/jit/include/sgl_kernel/tile.cuh": "3ecd35d51d4198d568906d7a8db30b8b4b5fed07e6c6f722710a9ce2d9619d5f", + "python/sglang/kernels/jit/include/sgl_kernel/type.cuh": "4c72b0892e8d003490bdab2633056172a674bc6a9689be552861564c7aaf8edc", + "python/sglang/kernels/jit/include/sgl_kernel/utils.cuh": "f87eafb71f39b9428ec4b3b524c95634f794b4256a6b240a17f2aa5339d92f8b", + "python/sglang/kernels/jit/include/sgl_kernel/utils.h": "68cd3ec640f9ceaf66f46be99b1e025c2a70dde32ea95ce462a1558af78d3515", + "python/sglang/kernels/jit/include/sgl_kernel/vec.cuh": "ba4ea5d07aa1a2722b48d690462c90cf4d3af2c608de1b97897d38ffb4d3965f", + "python/sglang/kernels/jit/include/sgl_kernel/warp.cuh": "6c911f6e53045e54f1119e6219cc455e0ba2cf9205cf8cdadec81dcfc030c633", + "python/sglang/kernels/jit/utils/__init__.py": "143200928e33d8630ca5b9a38cac8e4d0f37bd4657c0d6ca9bc4bd5581d6fc7e", + "python/sglang/kernels/jit/utils/arch.py": "b24cdb3c2e0f8187b188253ca47f666725b521f911690f5a4246f528e8917290", + "python/sglang/kernels/jit/utils/common.py": "cdaab0ec52cd48eddf527e03e3c109745f2bf882751802407bc51b7e7ad4c22b", + "python/sglang/kernels/jit/utils/compile/__init__.py": "7e1aaa05da2f5c814e4d2b6452a37f270d0acefe2d4b47c5dc87f5931f1e1e88", + "python/sglang/kernels/jit/utils/compile/cache.py": "45d4b3ae569886b2ea286b6feef93e618153386776c3d563a08e1fb0028f9157", + "python/sglang/kernels/jit/utils/compile/cpp_args.py": "84be4f6ab4b3a435a424e2762cf2f48c25ccf57119e6971e83f4856d779757c3", + "python/sglang/kernels/jit/utils/compile/loader.py": "00b0fcb4d284fad3d0b82c5880487434c387f6f4343afff745e44892aaa61564", + "python/sglang/kernels/jit/utils/compile/ninja.py": "68b9ff31d0fd43bf281741bef4d2a0a53cb8463a754078d2ca2085f6d6b628b1", + "python/sglang/kernels/jit/utils/compile/paths.py": "bfa8a912174607c74237f1b5f45b0a87dc8da8b5f1f5be39868966787fae76e2", + "python/sglang/kernels/jit/utils/compile/spec.py": "f762d7d90adb2770988ab0d17b444496d9d611531ab136eb37b8c8707dd42b2f", + "python/sglang/kernels/jit/utils/compile/toolchain.py": "d75ec06b9b323b0567970a1aae9c2a49ad320b88d0352bc19f18198f6f8ba41f", + "python/sglang/kernels/jit/utils/deps.py": "6c5312bba714e3d89c441002848cfe21963d91547cf8f9b0627a9f8612488922", + "python/sglang/kernels/ops/__init__.py": "17dff6cbcab853740d5c74243a33ca7151d1efa300db6b3e2f42704052270598", + "python/sglang/kernels/ops/activation/__init__.py": "3ffae92048c328bbe02761dd0765f4720be4e01a92d6298a373ad2390236a75c", + "python/sglang/kernels/ops/activation/activation.py": "1b938a3778c68ce5f24af370c674097dd9b0dd0771d960262369a200b35cd5d4", + "python/sglang/kernels/ops/activation/softcap.py": "6137b3c2d33a4d208e44bd5a32a77c349cafe56b79b78e1f092fd980e26807a5", + "python/sglang/kernels/ops/attention/__init__.py": "9c656a6e4f908e4117aad6a826e37625b511d9b86498e18ee763237d49e1e34f", + "python/sglang/kernels/ops/attention/clamp_position.py": "3b242de474485634cfc500cb5f0bdf19b44f3dc046172f6eafea93dcb87d9228", + "python/sglang/kernels/ops/attention/concat_mla.py": "78e47bfd60ed0036d211dcdc601efd90ecc2eb08358f3dd11ad9bb911a966b2b", + "python/sglang/kernels/ops/attention/cute_utils/__init__.py": "bae5c59b81a21abc499713696addc9e0f9480b0edfafd8e8b291368b91eae261", + "python/sglang/kernels/ops/attention/cute_utils/_tcgen05.py": "72673dc0362510d25f5a800a24cfd92a329170aad0c7b33005d1e70737906d05", + "python/sglang/kernels/ops/attention/cute_utils/cvt.py": "592eb52223e0e2e1525d179a75430f109b329ce87cada679b9b1b84d5172a257", + "python/sglang/kernels/ops/attention/cutedsl_fp8_paged_mqa_logits.py": "a2cee285a395159a1003530d14791b151df242ff5d36d77e0f9e3cf0b97ef061", + "python/sglang/kernels/ops/attention/cutedsl_gdn.py": "309913901b7f9787d3e5066bb3417f4d7e5412267562acbbfa9d3b6294961866", + "python/sglang/kernels/ops/attention/cutedsl_gdn_mtp_ring.py": "f5e8eb4af1a67288103e4b9af3c9a34c0483838baa9b559a0c55de0f71ca5ebf", + "python/sglang/kernels/ops/attention/cutedsl_kda.py": "c77b7c1632d281a7745d6c10fbafcfd7f6e2f10a741ad0ef0da1bdb552af0a0c", + "python/sglang/kernels/ops/attention/dcp_kernels.py": "491b0fd6db3c8fd04d1b287026f1e9108a58e217eeeeb5e6519efeaef0984736", + "python/sglang/kernels/ops/attention/decode_attention.py": "7833f6d06115dfd54b384d9ce907a012fa2f568083d90fc0f259e9ef24bf5311", + "python/sglang/kernels/ops/attention/deepseek_v4_rope.py": "dbba9685fd108c5e1d5d8e1fb824405d396c5efe3e7f1aba786740919e72abfa", + "python/sglang/kernels/ops/attention/dsa/__init__.py": "e5a6166b0b49aa607226067dde70ae0bb447aca2e44e3d8df1652d826efdfd3d", + "python/sglang/kernels/ops/attention/dsa/cp_split.py": "d41738790eb2bef1e723b59efb87bcb60d5670c8f79ea854a8b3d13c53ad1585", + "python/sglang/kernels/ops/attention/dsa/cutedsl_paged_mqa_logits.py": "ee74a18a516ae9233f5400c5373d365993c93cf1b58106ec724dba662ec293e3", + "python/sglang/kernels/ops/attention/dsa/dequant_k_cache.py": "9fb188edb6230dab5841e3f14990cc6cf2e49c120dc26400b04fcc7bcc69426a", + "python/sglang/kernels/ops/attention/dsa/index_buf_accessor.py": "5ce7ff62b2843dae6e03601708c59078de9f3ed23562210b92f007f64e4ebdd4", + "python/sglang/kernels/ops/attention/dsa/paged_mqa_logits.py": "51591504130457f6e423f8930749ab8744e4bece16ca0cd19c79d2196634807e", + "python/sglang/kernels/ops/attention/dsa/quant_k_cache.py": "23dccba0f293449067a25b90e4ac009ce4e1d424c3358aedd9396fd35c995fc6", + "python/sglang/kernels/ops/attention/dsa/tilelang_kernel.py": "29ab236ef60c67b6e20d7d89afc972e40e31336251195b6221cc529c44ab004d", + "python/sglang/kernels/ops/attention/dsa/transform_index.py": "fe6b45fe4b764e97c012c31d774041a9ad8bfacd99725196bbefbaec993ae5cd", + "python/sglang/kernels/ops/attention/dsa/triton_kernel.py": "58c0924b2c5f5ea3febeeb490fb64a9ee205d98ec142047dd1a6860a53680f28", + "python/sglang/kernels/ops/attention/dsa/triton_sparse_mla.py": "4fd8beada8f58a93a32dedbe70283b651d6e56b8dbf3035225647f3465d9d623", + "python/sglang/kernels/ops/attention/dsa_metadata.py": "4efaefe6d925b4d5f73e7baef69a63f5cec35d5fd72c06aea8bbbcbb812b53ab", + "python/sglang/kernels/ops/attention/dsv4/__init__.py": "3c54a9103bf88ec2502024fd7f5860ec6283a5250a2fe1deeb51872535ab2e53", + "python/sglang/kernels/ops/attention/dsv4/attn.py": "4efb7a3dc9ec56b81e117c9c383dd08cf153b12c95d4f3ed2137efb0689754e2", + "python/sglang/kernels/ops/attention/dsv4/c128_cleanup.py": "140a1760c899abe8968189dd7fcad026b534c889954d8967888c25f4b1d8477b", + "python/sglang/kernels/ops/attention/dsv4/compress.py": "f010f91edc9cffe44e975a2bd628fd90998cae0c502052a61da2936b4e9ee271", + "python/sglang/kernels/ops/attention/dsv4/compress_old.py": "8717e962fe937958c68e44334ad5b81006adf93bd574a364a1c912ab603182ca", + "python/sglang/kernels/ops/attention/dsv4/dequant_k_cache.py": "d11a3b063006d8454e875d5a42398c0711f16f1287bd65956262f90a19912de0", + "python/sglang/kernels/ops/attention/dsv4/elementwise.py": "883e36339a2db3f8a8b978431bb82b080d4781568c965d4564eacb2da41b5b94", + "python/sglang/kernels/ops/attention/dsv4/fp4_indexer.py": "b69452017774f74740cbe7ccfb4030607ce15858a812a3f661636e370aa844b4", + "python/sglang/kernels/ops/attention/dsv4/fp8_wo_a.py": "cba3e8d702771b3f9e01d43f2ffa322c6a13ff29c0b2cb518b322d4dfb21cb49", + "python/sglang/kernels/ops/attention/dsv4/fused_compress_triton.py": "4e17f79ed97e57f972f1fb37fbaa59e6160b66e0aaf2fb4806b9da19c04f7081", + "python/sglang/kernels/ops/attention/dsv4/gemm.py": "7d08628d9f298c404afe3201552b8c39df5a1f8718db2c1f3dc36b3a2659d428", + "python/sglang/kernels/ops/attention/dsv4/index_buf_accessor.py": "0922ebb9bdde82b115ee9ae17ca604b5c7e55a357e2fdd54f16942eece50290b", + "python/sglang/kernels/ops/attention/dsv4/metadata_kernel.py": "c9edb7c07a5189c67ea2cf55cd6c2d60a6de5b629fcd9aba6de0b8016c7192de", + "python/sglang/kernels/ops/attention/dsv4/moe.py": "13d01b06131160266ffbd560f91a6cba515483a0c48199e9f41e466763bd8eb3", + "python/sglang/kernels/ops/attention/dsv4/online_c128_mtp.py": "3d84de7e3aee335a3ec51a49a326a340bb4bd8ea74cc2d5d45b24fbb28899aa9", + "python/sglang/kernels/ops/attention/dsv4/quant_k_cache.py": "d557c3b3b7a0062dbeee5c24d6c0499e5fecb0b10a1e3b07756a0870a024764e", + "python/sglang/kernels/ops/attention/dsv4/rms_normalize_hip.py": "435e8f05d62266fc37db9956963616bc406844d984df9bfcda36dab4f215ac79", + "python/sglang/kernels/ops/attention/dsv4/sparse_prefill_kernels.py": "74bdd03e419233ed17b7070f625ba2959299fa6419c5e0cdb8911bde5baddcbc", + "python/sglang/kernels/ops/attention/dsv4/topk.py": "bbfa1356f1a65aecdeac7ca2f23436bddcc0c30d7b5c3d2d25016732a5097c49", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/env_gate.py": "a395164121f06b671c138595abb23d6d57cdf9bbf3fa121a002aba99b211707c", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/paged_decode.py": "ca49b68c9151df67919a9fbf2247828b0ab79785466959c7c8a7eda2f69e4d35", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/paged_decode_indices.py": "f008dfe6cf2332921cc613a24fc835c9746694836242ab776a451d51eb503d45", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/paged_prefill.py": "20379961e07ffc613e4ed1f0171da22ce641d697bf722f88fa65c541d30ce419", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/runtime.py": "eff745080c1c530b613465f8b8ce061e1cc74371984e41615cf9b42e8bc86969", + "python/sglang/kernels/ops/attention/dsv4/utils.py": "14c23af783cf8c301b9a125f689fb97447574778de7c433263b0a656e6e051f8", + "python/sglang/kernels/ops/attention/dsv4_attn_metadata_kernels.py": "4276de2afa328739ddcbecf7d8a48f273fddfa8d8a029e7024b82e7dacb91969", + "python/sglang/kernels/ops/attention/extend_attention.py": "8aa8d01f0a73a144f51a8b7e8dae94a96c227b1dc6b6397ab8ff03116514dfd9", + "python/sglang/kernels/ops/attention/fa4_sm120/__init__.py": "05622241f5ba038d487f91084605c66360d3e59a3cd9e2830ad08c1587cd19d5", + "python/sglang/kernels/ops/attention/fa4_sm120/dispatch.py": "f317529e990321f64bc41705a6069b37c30765ec4c780601b3e0411414ff5b1f", + "python/sglang/kernels/ops/attention/fa4_sm120/flash_fwd.py": "3ccdfba82570f26eb812808fe4aad34dc4d3efc036cd78931a17af2d429cb995", + "python/sglang/kernels/ops/attention/fa4_sm120/flash_fwd_decode.py": "0623ee03ad82f3ed9d602227931870361879ea008aabc48e74e506258a337113", + "python/sglang/kernels/ops/attention/fa4_sm120/paged_kv.py": "99d640185f7e29fd80afd387032da6f998989dfb5fa21afe9b5dac01e45f263e", + "python/sglang/kernels/ops/attention/fa4_sm120/policy.py": "58bff198c322d87166f6d7330df81e7fc3073353e277641d39c66ca3ea4269dc", + "python/sglang/kernels/ops/attention/fa4_sm120/runtime.py": "560875edbed63a59d2060dc4adff839566ff603e0e8f3443181d04785c0e71fe", + "python/sglang/kernels/ops/attention/fa4_sm120/scheduler.py": "d5dd1d29975f3e07a042ba7b509ed14269103bd3dd087494d10f55e85c08d771", + "python/sglang/kernels/ops/attention/fixup_zero_kv.py": "b5d30088d783c3f9099de0151e454258013d4427e5277ac6ec7ae9dd86965024", + "python/sglang/kernels/ops/attention/fla/bench_gdn_replayssm_fold.py": "ff66ca4c761ef052e5ed10d772e27282e5a5791f45c78bed6d3c9638e9b8704a", + "python/sglang/kernels/ops/attention/fla/chunk.py": "8edab1f6fc35b86300a91dc6afd61c2456bd7a4ed3986564456977fdb098f2b2", + "python/sglang/kernels/ops/attention/fla/chunk_delta_h.py": "580a24d2e91c885ef180f5135978c3cc35f01e96a17776baa4b13fe06533bb60", + "python/sglang/kernels/ops/attention/fla/chunk_fwd.py": "e6ee7b4601ca12ccda6fd93050acedae25d2b6e6a27a27ebf194a58533a4140c", + "python/sglang/kernels/ops/attention/fla/chunk_intra.py": "1ea350047ddada714183928ff30199796817e3b6c7907557af6f6cfe00fe1b38", + "python/sglang/kernels/ops/attention/fla/chunk_intra_token_parallel.py": "b66650b2b1299a76d471a2d026aac638727431f2786ace32eb745b9c9bab41f0", + "python/sglang/kernels/ops/attention/fla/chunk_o.py": "c5e5b0f7ccdaa744c5e0eede8ec73a5767b322132a72ce46a56f04bfe4c07564", + "python/sglang/kernels/ops/attention/fla/cumsum.py": "4f5efb6cfdf25137bbdde22c84fe28783b5fc4b6bd83ce4b57ffee1924ef7a78", + "python/sglang/kernels/ops/attention/fla/fused_gdn_gating.py": "c7736d1e506fb2c3e5c0496a2ed8c23347c2507ebe73c08bc6745517495d0957", + "python/sglang/kernels/ops/attention/fla/fused_norm_gate.py": "9110a606a057c6268932cd51a3f88ffdf419f063407559805e9b4fd2211fce7c", + "python/sglang/kernels/ops/attention/fla/fused_recurrent.py": "cf5e980d86174a631bcd0872f8ebf7a6ab7c21c3435c097f66f8ba0e686debc0", + "python/sglang/kernels/ops/attention/fla/fused_recurrent_linear_replayssm.py": "a8824a71ab49fde1f070c325c89603e6198928bdcb2238f2d6e9ef8fb7247f62", + "python/sglang/kernels/ops/attention/fla/fused_sigmoid_gating_recurrent.py": "c0142cf78d5374cbff285d8d46b39710b2eed42620d41fbd93e518104cce1695", + "python/sglang/kernels/ops/attention/fla/gdn_replayssm_spec_decode.py": "74043400ac0cf1ea5dd9b30ee1fd79ad0db2f22843c0333d8611f1ca20a4d26d", + "python/sglang/kernels/ops/attention/fla/gdn_replayssm_spec_fold.py": "fb79ad9e12ec1e485cc65e12d6394debee69fb21a14c50e1bb84a809f6a46e28", + "python/sglang/kernels/ops/attention/fla/index.py": "bb0b99067ba9f2f24d4c52fa75e6c008ce3837c519e20c18c0bad1e4a3c5db0e", + "python/sglang/kernels/ops/attention/fla/kda.py": "6d37f8f7bdfc5d430090f99106448f4051a9076c6df166fd2b96bafc61c601eb", + "python/sglang/kernels/ops/attention/fla/kda_replayssm_spec_decode.py": "bb51f807c932bc19b45eedc2a6dd3d1f6533389b3d788e0b91901b4208d6f331", + "python/sglang/kernels/ops/attention/fla/l2norm.py": "b1323047a7c7f46268a9c295f4fea5c53a210ebfb04db5b17d7ce6ff4b24b7f7", + "python/sglang/kernels/ops/attention/fla/layernorm_gated.py": "3ce4895e768aead4f12031b37fc0ee511d783b9ec476016c85b715c2dcf84988", + "python/sglang/kernels/ops/attention/fla/op.py": "592dc573983a1a20a00e1cea3b2d5a2a43ec8881d6bb45ad7a1f1faebb1cb7d0", + "python/sglang/kernels/ops/attention/fla/utils.py": "72afecb7e66a2f3bed4058901859dbab6aec233ecf7ddc595a9d21e123ead20f", + "python/sglang/kernels/ops/attention/fla/wy_fast.py": "067afef050b30951d6e24f08ada0fbd1434acdd0fb6f4f253c8f5c40c363b50c", + "python/sglang/kernels/ops/attention/flash_attention.py": "a45762ec7756a436a74f94d47b4ca2bf386976edd49001547e9600a7f652e19b", + "python/sglang/kernels/ops/attention/flash_attention_v3.py": "b77ed59eb5f8d27b32eb92eaa54bdbb229fe6d3dcd4ac2be85f43682136bc47d", + "python/sglang/kernels/ops/attention/flash_attention_v4.py": "53b5fd198ebbbd67cb65dc4d783d35b03826e18010576c350a7f32fcd8d05497", + "python/sglang/kernels/ops/attention/flash_attention_v4_sm120.py": "880ac1dde246b93bc237ed05462e030dba61886aa3ffeb892ec100459e3e298a", + "python/sglang/kernels/ops/attention/flash_attn/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/ops/attention/flash_attn/cute/.flake8": "8cb396353fbdedf8028792aa3428849e7bd9c724a6ea4953da32737860570ec9", + "python/sglang/kernels/ops/attention/flash_attn/cute/AUTHORS": "82b4aba3841946660c3d8be4b565b94477af318dd185368cf1a76aa40d7d84a5", + "python/sglang/kernels/ops/attention/flash_attn/cute/LICENSE": "8c9ccb96c065e706135b6cbad279b721da6156e51f3a5f27c6b3329af9416d73", + "python/sglang/kernels/ops/attention/flash_attn/cute/MANIFEST.in": "a9c54041b68b5e51a5ba1a3942b0eed6b39ba1b8575dd83512ca1a4584ac3ec1", + "python/sglang/kernels/ops/attention/flash_attn/cute/README.md": "69e70ec669e9a5e1b843e5b8e5e8ec1366c67e70098b84ee0d79b612cb9bad1d", + "python/sglang/kernels/ops/attention/flash_attn/cute/__init__.py": "50713012c3a5e8045f368672342aea6eeeb3b3ce0968cb5639b1f158b9499487", + "python/sglang/kernels/ops/attention/flash_attn/cute/ampere_helpers.py": "0fb11626d3d68849220d251a5ee5fa1790e599cdbf0f62817e6b4e2b2f05400f", + "python/sglang/kernels/ops/attention/flash_attn/cute/batch_invariance.py": "0d47e270bc35458417609e980b9be1c26cfd54e0d91f326fa51e7aa360309a5e", + "python/sglang/kernels/ops/attention/flash_attn/cute/blackwell_helpers.py": "e36bc15d0dbcb2e91ae99541c7275aceaade0f96b471075b43e31cef065b22b0", + "python/sglang/kernels/ops/attention/flash_attn/cute/block_info.py": "607c304d0cd123595188537a9815d69282d3a7419cb457768d8c31993f25b359", + "python/sglang/kernels/ops/attention/flash_attn/cute/block_sparse_utils.py": "2b3e749380f21d6fb77853ca4270f0c9005aad52225632202d3ee442af2f7cd4", + "python/sglang/kernels/ops/attention/flash_attn/cute/block_sparsity.py": "9ca21cf8b9ae5f7c44023df646f70b793667cdce2bbb09ba15f5f7a3a19a4c26", + "python/sglang/kernels/ops/attention/flash_attn/cute/cache_utils.py": "c34ec6747921a83f4e1fa6838fb42e694a36d5f1a4b3b3a4af3e4e68d25971a9", + "python/sglang/kernels/ops/attention/flash_attn/cute/copy_utils.py": "43ae6db77b9e48280ba7b6e7413ed24929430b8a53015bc5ea9dffad57d1e9ad", + "python/sglang/kernels/ops/attention/flash_attn/cute/cu_blocks_kernels.py": "31a4b3dd15457c0fda258931544bed4ae859c71de2775bc9679ebd544aeca388", + "python/sglang/kernels/ops/attention/flash_attn/cute/cute_dsl_ptxas.py": "acc3f18e41bca5555505dc79129e45eae6a3a5510d0b9e93fc1614bdad242776", + "python/sglang/kernels/ops/attention/flash_attn/cute/cute_dsl_utils.py": "03520beefd65d44c5bb1d3420e18664f0202b3c7926ea9d5dd8c97a983ef2583", + "python/sglang/kernels/ops/attention/flash_attn/cute/fa_logging.py": "bc71edfa4b1cb7af64b78def09e790ff4c6fe64ab4fcf8e3d9699f44e8d3c0a0", + "python/sglang/kernels/ops/attention/flash_attn/cute/fast_math.py": "7e5f822bf4d0ba36967558f3ae9a1408b410cb726c31222cd61703569d1be738", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd.py": "97edf14f4be14d83176efc816f867c0bf751ae65b380942da9147932ce959ea4", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_combine.py": "b604abd7f3aa747451a733bb98ec2cb159febbc0140c58a16fba56e415b170ed", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_mla_sm100.py": "5b180193a2f3ad7c0d87fb19b7d6ea1985bf2d70102e4abbb34ab8c09015e573", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_sm100.py": "37e40dbaae7d22c87210c4e0541790e9ace2d66e469259faf5b299f746403dfd", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_sm90.py": "16815521b74bfc9e5fc16411e503da6ff5b4146a0d40e0563073bafcc90d61c1", + "python/sglang/kernels/ops/attention/flash_attn/cute/interface.py": "4d74a7506b635f9890daa6705784148a71bd0bce22e0c21ecbbc3d5090f76368", + "python/sglang/kernels/ops/attention/flash_attn/cute/mask.py": "1f4a0980b684083ab4d8bd90dc617bc9f2b6ce8074532d9d5814e76230f413d9", + "python/sglang/kernels/ops/attention/flash_attn/cute/mma_sm100_desc.py": "3f87737997bd1e589500ca8b3b8e6e56fb466760b4eb63eeaa332bbf1bd8b6f9", + "python/sglang/kernels/ops/attention/flash_attn/cute/named_barrier.py": "729f4581800b31e1b6116bc44c0f9f5268b986cd7ed108d407d4bee4441ece46", + "python/sglang/kernels/ops/attention/flash_attn/cute/pack_gqa.py": "71b087e2f1d299a8c9e5181e6d083444e9a421f749b7cb51c5129abeef0aadf8", + "python/sglang/kernels/ops/attention/flash_attn/cute/paged_kv.py": "a80b0cafdca4a570722d6d4edaf9a35e5ec31d535360b14a931bbc393d51a359", + "python/sglang/kernels/ops/attention/flash_attn/cute/pipeline.py": "71f7416f99bd187758e940d51094e881a0e485c96d5fad5224830c7d5fa1f846", + "python/sglang/kernels/ops/attention/flash_attn/cute/pyproject.toml": "ab14226518b1a9121bbd2ac19794d7babebf1a89a2e25790e94ea8f2a397d646", + "python/sglang/kernels/ops/attention/flash_attn/cute/seqlen_info.py": "e2444eb09131f12dddf4444e54985e60435b877012ea90e73ae4b8da6483e6d3", + "python/sglang/kernels/ops/attention/flash_attn/cute/shearing_bias.py": "2c1d13ab9b569a6b2309098cac4f946c4971c34158d13d563f1de28a3acdd195", + "python/sglang/kernels/ops/attention/flash_attn/cute/sm100_hd256_2cta_fmha_forward.py": "6d315ad3f40404b0da688f57bb481bbe0766a92ff6b4ffdcb5b35686b7c0072d", + "python/sglang/kernels/ops/attention/flash_attn/cute/softmax.py": "b9bd63eb9f27be36e60e7c3040eefe9f6a5967051086b752e80a005513e4d268", + "python/sglang/kernels/ops/attention/flash_attn/cute/testing.py": "e83f8804a1198f967267cb3b081bc8cc3bd1b4e7d50a7bf04b6e2bf020956cc7", + "python/sglang/kernels/ops/attention/flash_attn/cute/tile_scheduler.py": "e6d1b4ebd9708f01cfb5e12f4aa54dc9f7d9b15d7a92c93a28faaf9407a7102d", + "python/sglang/kernels/ops/attention/flash_attn/cute/topk_gather_kv.py": "f1e226cb2552c6cc1ceacf706a5c5ac40b39ad7ddd2350136e2579491199dbe5", + "python/sglang/kernels/ops/attention/flash_attn/cute/utils.py": "9ca44a24082e440b13afa5c6f18fb00cfeddbf6f79d1e5cc5274eb9dc2543a78", + "python/sglang/kernels/ops/attention/flash_mla_sm120.py": "f80df68c252a8c8960f96e97d1ae9d89825358ad286f716f7d8eb66300c29495", + "python/sglang/kernels/ops/attention/flash_mla_sm120_triton.py": "37e6dd6dcab87a812b20a2ea2d35ae01a32cdb2e8dd67fa0ebbf799873c1e4a7", + "python/sglang/kernels/ops/attention/fused_metadata_copy.py": "34a84755371995870a179ce60a20a216a6f5aaced4640e9348df424203f83054", + "python/sglang/kernels/ops/attention/fused_qk_norm_rope_store.py": "0803a0e0a4b462b4211abe8b6cc51684a47cdcce8d8027b3a6aa13eeb7cc7241", + "python/sglang/kernels/ops/attention/fused_qk_rmsnorm_rope_gate.py": "d1972dffb4da33fab4410567f32359527bc5c32794c8d8015ffc39b9b9d80cc1", + "python/sglang/kernels/ops/attention/fused_qknorm_rope.py": "fc0131556a5b80bc6585caba6e6cccab3f4a44079e72bc7f93cb1381ebd64d90", + "python/sglang/kernels/ops/attention/fused_store_index_cache.py": "e5cb4a31c5a51fc0b413fa729f9712270f86c815853baa6183efe6861075fcf4", + "python/sglang/kernels/ops/attention/helion/__init__.py": "307fa361ccc4a4eb6347d5d3ca1199a17be821efa55511946609af5e763e8953", + "python/sglang/kernels/ops/attention/helion/kda_decode.py": "25803b176e1830355afc854fb1117bbd96637e7b67a6778aa627d90567260a7d", + "python/sglang/kernels/ops/attention/helion/kda_prefill.py": "200e95d07f68b1dd11c4d6b76f962dc98e383ed2af19ebb05740dc37b0ece58c", + "python/sglang/kernels/ops/attention/helion/kda_replayssm.py": "327b25962159b19f310330a2882be9517979997b7b0f1e869d04d4644b5a2137", + "python/sglang/kernels/ops/attention/inkling_attn_prologue.py": "463474b4a7617981611db3ff36790e95d2d98488defac193c6f70a1de8e5fb1d", + "python/sglang/kernels/ops/attention/inkling_rel_proj.py": "5deee148391d06dcb2e78b3f08cb6ece6d563c7c5b361f488f3ed90aacad472b", + "python/sglang/kernels/ops/attention/inkling_row_scale.py": "8abdff86ace18bfa9d90953d054dcde3cc28c306c6235d108e3bc29bff830924", + "python/sglang/kernels/ops/attention/kda_fused_decode.py": "0038e4b82f74ff2569a29e09b1b9f4a8d5b0008b2b6784a67152b190f36fe7f3", + "python/sglang/kernels/ops/attention/kda_packed_decode.py": "518855d312f44ae0ca1bc5f730fd5f26c98e731f9298ddb1e493a3d46edebef2", + "python/sglang/kernels/ops/attention/linear/__init__.py": "121dd755ac7b2e17c9ca8bfa0892813d98ac8af6a96b865c37be5b7966713d00", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/__init__.py": "773bcce973a6496403b6e07413928903931da727520e680b7d1f51b2d97c36d4", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/kernel_h.py": "e751896358a46abb7e338847962b1fa1a12f5c99979092a54bb719c61dbcb126", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/kernel_kkt_inv_uw.py": "f5743c4a14bdab8baf6aa79ed7846931b2afc883b9f58dacf7339e971116bf71", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/kernel_o.py": "c06b292daa82e720c4c6ca0ee03cb1d84c851e05e95f795adea4ffffb4df4333", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/__init__.py": "da6231a532f3bca80336e020e10ee5e099ed9ff39e27548fc9aaabe51631e6b7", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/kernel_h.py": "c7f6ae3771d09223c61689649cba1e9d87656b3c75115effdb67ce1e62fd7842", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/kernel_kkt_inv_uw.py": "115feffa986944f3e538cd47403f738e6060c8c9ab3930b673c79f1b7ed16a98", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/kernel_o.py": "4d9cc537c45dafffc2654a9851bc6213bec267ba7dd0895ae9377b102b896f5e", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/prologue.py": "72c1b42d256bc797d291bbaae80493206813beccf098b99cccd4e145b4807785", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/Akk_inverse_lower_triangle_bf16.py": "418208ba8acd2644750413ac223b18423a45f8fdc3aea2714f6987ada8e991b2", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/__init__.py": "04282eb62222296bf6778f01eae374aac1d0fa185da63498898dfc55fe504a3a", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/chunk_fwd.py": "e70269de406548d9ab0e4180a293746e9c7d3fdb687fc9ad45cda5c3c414e88a", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/fuse_k4_only_persistent.py": "79398ed857a586dad6e71fde4cf64b22006941e48d929b503e1b43fd875c279e", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/fuse_kernel123_persistent.py": "d9c79963c50a01704c306965585bfe2f41b89f2e77c746144fa87967fd58c4f6", + "python/sglang/kernels/ops/attention/linear/kda_ptx_prefill/__init__.py": "5967689a59d9eec6a188fea05331a3c554ee38e9b4de590310f090231eb777a1", + "python/sglang/kernels/ops/attention/linear/lightning_attn.py": "e7c81f873addd1e66f1b6ca829f13ddea1cbe97b54702f42c10971c8738f7ad2", + "python/sglang/kernels/ops/attention/linear/seg_la.py": "a5a52db38a754a2358984022bc0c81a027376cc6b8c14c5f719799526f4e7e6e", + "python/sglang/kernels/ops/attention/log_scaling_tau.py": "a879bd967980d4c7a9cfdb084c23aebf117d6324827fe5b526b5736339a04302", + "python/sglang/kernels/ops/attention/merge_state.py": "bfd9c3d356b97939e4c19c4cc0446daeb45f0b9aece86c6460ea44ae400f7182", + "python/sglang/kernels/ops/attention/metadata.py": "8301be5035f976e02e91323fb469f0e925193ca4a25a39cf25640d50c66f0d29", + "python/sglang/kernels/ops/attention/minimax_decode_topk.py": "3e773a7cc4d20a05585993242d10d5fa0e59a16cf06b4c31596ebc97308eb090", + "python/sglang/kernels/ops/attention/minimax_m3_qk_norm_rope.py": "e782750231f136aa4d606c1b06fbaa1f9c66d2ac9a0a97900b75ab2268ef63f0", + "python/sglang/kernels/ops/attention/minimax_qknorm_rope.py": "b97f5a99b370e6b7e561f68b29e3d56755cfdb4f62dc46d3272adaac52637a23", + "python/sglang/kernels/ops/attention/minimax_sparse/__init__.py": "891d49998a7c1bf8dcc77139b4bd6e1702fe40c17efcc315895af5e307ed3c63", + "python/sglang/kernels/ops/attention/minimax_sparse/common/index.py": "f7141f5d82e92f88533ac3a4ee7001cb1c2181f1f0a8b487c41da28646f9484a", + "python/sglang/kernels/ops/attention/minimax_sparse/common/utils.py": "7dd6ffa28fcc14374cc2d7006c884217300b344fe544e56d8bbc662c1a9af3bc", + "python/sglang/kernels/ops/attention/minimax_sparse/decode/flash_with_topk_idx.py": "84a9816213d65af954a712faacd0e44045aeb60376ccf2bc735f6e1f143be6f4", + "python/sglang/kernels/ops/attention/minimax_sparse/decode/topk_sparse.py": "a7ba7bf7919a7faa02bdd2888f939e7648c6b84bdd6b6616c28b2aa8fc28cbc4", + "python/sglang/kernels/ops/attention/minimax_sparse/prefill/flash_with_topk_idx.py": "e9ea1ab4e617d261752c49ce40650ff561dd05068d410f99c82270d3daebf87f", + "python/sglang/kernels/ops/attention/minimax_sparse/prefill/topk_sparse.py": "1bc59d10771c5f4ecf98b0addd50e7de88cc7aeeddb9121532ccd259458c3688", + "python/sglang/kernels/ops/attention/mla_kv_pack_quantize_fp8.py": "dfab3349c84cc1ed458ff18253952a0dd88ad67798e0f90b1d37d84952cccba7", + "python/sglang/kernels/ops/attention/mrope.py": "5d42bb01f7ceee189879678054e3023c0c34130d75543ce242da7cd14ebb7cb7", + "python/sglang/kernels/ops/attention/nsa_triton_decode/__init__.py": "7b1934f54d88e22c722df8986d7ae30c4609d19e3b257af13985c14aafbb07cd", + "python/sglang/kernels/ops/attention/nsa_triton_decode/triton_mla_kernels_decode_fused.py": "9664d16537fee95b0e50fd24d14b8f12b8aac495691aef2e9895654952f707f5", + "python/sglang/kernels/ops/attention/nsa_triton_decode/triton_mla_kernels_decode_optimized.py": "7eba46e5715be8584edd1403cf8d9088277bd4d8679737e31221d1966c437234", + "python/sglang/kernels/ops/attention/pa_page_table.py": "f21bf6bbf7ceb104bfcf3f0b9a4e4308a8526dd3f08fc1d98310b99518ad3daf", + "python/sglang/kernels/ops/attention/pad.py": "805e534b8533092ae375f7186d5bc35051abbfd9bff38e4238df41d9ab2d5ea4", + "python/sglang/kernels/ops/attention/position.py": "5b0c61b2bd74d4eeb1d3fa21dfb37c52838ce3533701c4f9f66f6031fdabfb17", + "python/sglang/kernels/ops/attention/prefill_attention.py": "eb158c4c03e69091eb95a1bce093c9b054ac1ca5aab12769063d2e84630ca7f3", + "python/sglang/kernels/ops/attention/qprep_bf16_fp8_sm90.py": "6b76a8f3c6fe6a2588f78cf2f3af0b23529bd9d2dd36e305a2dd2c99d25ed628", + "python/sglang/kernels/ops/attention/qsa_indexer.py": "2e413f99a9c5e475f98529691f1dddf7b59061ff234e107b1894e96e956a54cc", + "python/sglang/kernels/ops/attention/rocm_mla_decode_rope.py": "43e72631dde538f70478b8f31ec9298561109f772538826c6ed558b3a41473df", + "python/sglang/kernels/ops/attention/rope.py": "079a4d99dadbad673159bdb7ec9231467a4ff6c4aa63a40850022e61995a70f9", + "python/sglang/kernels/ops/attention/rotary_triton.py": "49b3a2ca2784b4ffb0773947d2e26055f55a520c9cd847b86bcc3f6c2bf94d05", + "python/sglang/kernels/ops/attention/score_mod.py": "01f6e619d93d1f025940ffda81f39d36ce31cc8608bc7d21c923979d41ee924a", + "python/sglang/kernels/ops/attention/set_mla_kv_concat_q.py": "0b56dd69bc4d5975f7b20fad798508eba5d5230ee04bf8623f3a9f5795578a85", + "python/sglang/kernels/ops/attention/sparse_mla_q8kv8_prefill_sm90.py": "0ff15d46709c97554652c6052d67832fc234376752bbdd4ef918773b7e033131", + "python/sglang/kernels/ops/attention/triton_gdn_fused_proj.py": "c3a7595605ff253d9ad46018bd123d7d1fb10002a3d556fb6bc5d0b323e04bc2", + "python/sglang/kernels/ops/attention/utils.py": "649ba76f5997dbb95abacf9b32626e3349b1156402f5acd30a15d741888fefa7", + "python/sglang/kernels/ops/attention/verify_mla.py": "40b1dbee180ffc289977953a448979088b4a99f7eed8b2cc0b04a41dbd84aa59", + "python/sglang/kernels/ops/attention/verify_splitkv.py": "0c2c4009b3553e13bcc4ae1e0e375aa5c96c48e6c96ab9a475a3e2d874c3c6c6", + "python/sglang/kernels/ops/attention/vision_rope.py": "d0e27aca64cf83cb90548d9e931835d44046da8178f216c8fde81befdd732194", + "python/sglang/kernels/ops/communication/__init__.py": "f9a34481689fa042fc994899cc4110f44f41c8f9c51211e86af7bdf5f64b4b02", + "python/sglang/kernels/ops/communication/all_reduce.py": "a10b7bc586399ae06acd2766b74c27ae309ce28b64ae982755bab1c26ea8a1d2", + "python/sglang/kernels/ops/communication/inkling_all_reduce.py": "b323b96e8cae729484d70d418326affaae2c78f4e71582c98421e78ab9e17184", + "python/sglang/kernels/ops/communication/inkling_ar_fused.py": "30cfef8bf611749121715f8c5bb5c1b9d22517ae6884faf00798628571d36057", + "python/sglang/kernels/ops/communication/inkling_ar_scattered_sconv.py": "ccc90e7dbb8a2b9dae4d61fc30b259c9651116ed4178051b9b40a74031af7b06", + "python/sglang/kernels/ops/communication/mp.py": "8e229fe09ad4e938c946bfafc0bce6e75457f39931ad264b0332de76863e91ef", + "python/sglang/kernels/ops/diffusion/__init__.py": "48a131d5c1ab2526dde5c0bddd9c563735521d745d47ecf0fa86f53d83110f33", + "python/sglang/kernels/ops/diffusion/bitexact_gate.py": "a9a5bd028d32117f426fa4bca29222f999354d1e1c426510597243a84dbcc840", + "python/sglang/kernels/ops/diffusion/causal_conv3d_cat_pad.py": "16df0e84da819237ee0b689a18fd3769bb30b9fe3b399820f48c83883e332508", + "python/sglang/kernels/ops/diffusion/cutedsl/common/norm_fusion.py": "8e4feea1ef0a026fef873136c2cde82ce5cf823357ebc60267e770d89c71bfcb", + "python/sglang/kernels/ops/diffusion/cutedsl/common/reduce.py": "90b8a0ea9a857849799ae8c17e3306271b68156082fcc4c257b28a1d051e7e2e", + "python/sglang/kernels/ops/diffusion/cutedsl/scale_residual_norm_scale_shift.py": "db66599cb0d4cd16aa62b8c775218de5da95b00a46ff448b78ead3e230e98bee", + "python/sglang/kernels/ops/diffusion/cutedsl/utils.py": "5bd351c9360fef8596b5cd3cca269d2dd60ca3d1f3218f1149948c6549d92bb8", + "python/sglang/kernels/ops/diffusion/flydsl/fused_residual_norm.py": "f1317cd8ee0ec111739d51931444d0fa06b1cfffdce18a098e44f485bb820ced", + "python/sglang/kernels/ops/diffusion/fused_gate_rmsnorm.py": "8a6333c6f65e8cc54d3dd7c581cff06fe65b9642a37aa5075c5664ef6472043c", + "python/sglang/kernels/ops/diffusion/fused_linear_gelu.py": "f76926ea975e5cc91977f4dfb2651f7b09bab6d9b681b7584ececb641a8d2d14", + "python/sglang/kernels/ops/diffusion/fused_ln_modulate.py": "10de436aac55149942babcf0b59ebe53180c59ac0137abd6be6faa587c75dd1d", + "python/sglang/kernels/ops/diffusion/group_norm_silu.py": "1f5d6318c41d3821f915fe4790c0f7935977636b5d32d6a96d2d55afa4836498", + "python/sglang/kernels/ops/diffusion/hunyuan_qknorm.py": "d6023352ebd69bceb57330e2406c72d0a2329b7c57788473c7145eb98604851b", + "python/sglang/kernels/ops/diffusion/ltx2_qknorm_split_rope.py": "d4f8fd1d3f8d810525268ec0a678619ae7d8b13498a3838e7541b82f574cf6d3", + "python/sglang/kernels/ops/diffusion/ltx2_rmsnorm_modulate.py": "98e170af81879494ae17ccc4f356be5d04d9f0adace0715c597e0a651478f41e", + "python/sglang/kernels/ops/diffusion/modulate_scale_shift.py": "59a5b7512980429ea2b08d8479ea4cfd94f81709bade49e3d83cef319846e8b5", + "python/sglang/kernels/ops/diffusion/norm_scale_shift_native.py": "fe63af2ceece6a0960c21536b964e5cb0d8fc497e3c171f130235e278356fb40", + "python/sglang/kernels/ops/diffusion/qknorm_rope.py": "53700c9b76253b84e043ef52c35c1b65ba05b68dce3f84740c6e4bcd3f2591e5", + "python/sglang/kernels/ops/diffusion/quality_gate.py": "b83cda11bd2083dd5bea7cb09c79dfee11697832f23125faf243d0438482b975", + "python/sglang/kernels/ops/diffusion/render/__init__.py": "c7c1501d0385ccb9e500061b6e087ac3965367ce82751d9f6c5d94026135f54c", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/__init__.py": "f24c32c50fbcc6e324689f74d629929d95b76ce64b5901be23bcf7bf8d7fec26", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/rasterizer.cpp": "618007e9eabca702f43ff0f7499dfec9fe8d93129f6d90deb2a20299e51e07da", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/rasterizer.h": "0129c0d8d7d5f35ccc4f6e5c3a1a6e68878725ddba380085cb0610969b446e94", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/rasterizer_gpu.cu": "23139f3ce94197170e068f696de9dc50ad1a64b5cfd87c066f3d208ad191a4c0", + "python/sglang/kernels/ops/diffusion/render/mesh_processor/__init__.py": "3af13541c7aeef8f92bba2e7276bdaf5824308008c0f22232389cc5a438e4141", + "python/sglang/kernels/ops/diffusion/render/mesh_processor/mesh_processor.cpp": "5a222e19c4707394cfb868f5722f7b806e5100b0e5c9d364ff7397bada00e610", + "python/sglang/kernels/ops/diffusion/residual_gate_add.py": "7a461f604c9939204fe825936017a71faa10395edd150890920f234b7158d230", + "python/sglang/kernels/ops/diffusion/sparse_linear_attn_kernels.py": "c92e69aabe9cf122f25213951768d2bb67199e5d401a787271840ec7ba6166d7", + "python/sglang/kernels/ops/diffusion/timestep_embedding.py": "f4d1128cb425bf1de9327309e121bfe0605afc9f4d869ed2345f802450df1dec", + "python/sglang/kernels/ops/diffusion/triton/causal_conv3d_pad.py": "f2f0bdd7571ab72a0891d596f09b3d2eae211e4bb83654deeb8db5e7be004d50", + "python/sglang/kernels/ops/diffusion/triton/group_norm_silu.py": "03a0e073cdf7a8ea5111393f952af511dc98849c2545d40da829d11e928fbc1b", + "python/sglang/kernels/ops/diffusion/triton/group_norm_silu_twopass.py": "edfafcb3c51bc47606ef41f8c2eb247f29d52986b421847785a12055da742d13", + "python/sglang/kernels/ops/diffusion/triton/hunyuan_qkv_pack.py": "d12d307ed3c0365f1e36e3e1ce8b59a0618522a834e576dbcc618e19105e4408", + "python/sglang/kernels/ops/diffusion/triton/indexed_modulation.py": "a9771bb71b6a34ac9f28f55b616684d209e68c0165d70cb50f788b470dbebef4", + "python/sglang/kernels/ops/diffusion/triton/layernorm_modulate.py": "d82e26b94ee83bdbe76ce50dffed8e7ff33361891002f97588c8aea91bdc44a8", + "python/sglang/kernels/ops/diffusion/triton/ltx2_ada_values.py": "9817d7593a60e9eb959f8b80673dbf00260250a3bfc53131e00f8b11290b6bf9", + "python/sglang/kernels/ops/diffusion/triton/ltx2_rotary.py": "16feb7045fa6a5be7ae42191da396d97d075b1ccff7692049f4dfe205bc8efb1", + "python/sglang/kernels/ops/diffusion/triton/mps_fallback.py": "1a24599b415bbb1b8cc0c4be7e650741a0f9b0a34e83b26b8c632463cd429c46", + "python/sglang/kernels/ops/diffusion/triton/native_bf16_rmsnorm.py": "e5f32428b41f771f63e81c1bd0118520d8102069a0564be99937aaa92a75c802", + "python/sglang/kernels/ops/diffusion/triton/norm.py": "aae6388237a26b33f5ab63dc9795a654edabd984f3814a00b2fe695ea3e0741e", + "python/sglang/kernels/ops/diffusion/triton/npu_fallback.py": "daa3d71a16a20024d88b2ddc509e0dcd305e8acef994e251b0c446bd0c7ee478", + "python/sglang/kernels/ops/diffusion/triton/numerics.py": "bb2a5e18c36f92107382a3e8fd23d345bd4b6df879a34721ba79b2c0fc47b6e7", + "python/sglang/kernels/ops/diffusion/triton/rmsnorm_onepass.py": "e1f80c95a8e707135e58e1f8f8ed95006b49e25630b80bec7804e35abde0af34", + "python/sglang/kernels/ops/diffusion/triton/rmsnorm_scale_shift_bitexact.py": "4cbecffe13479ed25803e95ac390a7c2b0263753cbb53d8886647793eb0542bb", + "python/sglang/kernels/ops/diffusion/triton/rope_rotate_half_bitexact.py": "ab4924019695c20bab2b2808370a83e0c3ed7934fda92b2cfdd11095661e9598", + "python/sglang/kernels/ops/diffusion/triton/rotary.py": "b1d04f149681103315e79c5447fdad36f49b9989cd603015fdd6d8e7b4972587", + "python/sglang/kernels/ops/diffusion/triton/sana_conv_post.py": "df2a5d8a8e6b0efa5aae8f58c6fab1ce7983be12cacd6cec1307b5bfc29195e5", + "python/sglang/kernels/ops/diffusion/triton/sana_wm_gdn.py": "614e1b1bc48600791883d3ed7b7e2db1044768d2495fd41079b7ddb11882c33a", + "python/sglang/kernels/ops/diffusion/triton/sana_wm_gdn_chunkwise.py": "6222295886ad7f4162e47e5b6940f3d2167b8be3e716b45fc7a85fc792680dea", + "python/sglang/kernels/ops/diffusion/triton/scale_shift.py": "21fd89999067c57b28c6f912cc2875e220572c850403a38f74ef6110e870059a", + "python/sglang/kernels/ops/diffusion/triton/silu_mul_bitexact.py": "a5da4c5e6e1c0b75f88047a2ea823c9ac1ad33659691994ac84e1bfd696e8e10", + "python/sglang/kernels/ops/diffusion/triton/torch_fallback.py": "6b2a61c91709aca46f0bb8e9634947c3c623ab9cfe53c609c4f0ad14c85b6101", + "python/sglang/kernels/ops/diffusion/triton/ulysses_qkv.py": "96e589548c530d2de091f07a4497f52efe09edb7029c5b0dc413e12da8ca8c4e", + "python/sglang/kernels/ops/diffusion/triton/varlen_pack_pad.py": "23077c268664919b1bb08b8c863e54a98e4d8ddaa9ec66cc936920942c35a62a", + "python/sglang/kernels/ops/diffusion/triton/wan_causal_cache.py": "0cf15e3897a74e9ce6351f469c2b39b4763c7e569731ab2b108dd3c03b5be959", + "python/sglang/kernels/ops/diffusion/triton/wan_rmsnorm_silu.py": "e16e33f202e7b88bdc0a2507c0b04b6d3095df46cd2c24b5a1816a66a1a11abf", + "python/sglang/kernels/ops/diffusion/triton/wan_temb_table_slices.py": "5c77ad9c0fa0b62589b2e49706d2c27d61df933d57e46d8e0de7b5cd019aceff", + "python/sglang/kernels/ops/diffusion/triton/zimage_native_norm.py": "957e568f47910de4efa9d9a848ad51ac4ea94e6203bfc347086f84a25d189caf", + "python/sglang/kernels/ops/diffusion/usp_relayout.py": "4cf547bbf6c3b08e2606f01add0af522f1b2c90ea40dc489617fb58f7c86a893", + "python/sglang/kernels/ops/elementwise/__init__.py": "c56d53ff6b763fb7f8eb9729b04ba8d4bd69fd62551d57c77af60a9f5b7d0db9", + "python/sglang/kernels/ops/elementwise/add3.py": "48f3d6656705e38ae685bba0b5a873db8357108e299a9f854289ff935456e587", + "python/sglang/kernels/ops/elementwise/add_constant.py": "9a6ead19ee80eee6d8323b8342737a160620c6a39164ddacee686d4c243e3d48", + "python/sglang/kernels/ops/elementwise/elementwise.py": "2592f87a688dc86f217e5e35bc88ba4c49639d5e3b52b3a4132126329f079ced", + "python/sglang/kernels/ops/elementwise/fast_topk.py": "77780478c7b48517fbe9240d62d8a71371203a1acea42d27d44022cc1e9863be", + "python/sglang/kernels/ops/elementwise/hc_combine.py": "13b7ac26cfd039495592199b2479669621503695d9f30232d1b9ec7f2f9772fc", + "python/sglang/kernels/ops/elementwise/hc_mix.py": "363c5371c5c940d802f09c8f72565174cf7cc979f638dc7657def71316d16e3a", + "python/sglang/kernels/ops/embeddings/__init__.py": "342660f1c240300f60785a0eba6927dc834c56c40e44ffa8b96103e76e5bfafb", + "python/sglang/kernels/ops/embeddings/vocab_parallel_embedding.py": "7766e50514e621317fec277fd5975adc469d70ab2951722a99d56afbb6dc16d4", + "python/sglang/kernels/ops/gemm/__init__.py": "4235aa78f78a59493159c0121f7609c91d8293b4729824a40a95c350223940bb", + "python/sglang/kernels/ops/gemm/chunked_embedding_lora_a.py": "1189c7f90730dbf62f0cbcbac07a4ff858a1871a2ab9181aa5d73ddf2da8403e", + "python/sglang/kernels/ops/gemm/chunked_sgmv_expand.py": "ec3927c0c0319fd030734b5cfc480ebfbded87e1508fcefc6fe1221a8988948c", + "python/sglang/kernels/ops/gemm/chunked_sgmv_shrink.py": "f078bcb16ad462933c6d4805f6f0656ec2ec3811198ab8ee5aa9bfe00c166595", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_expand,K=1024,R=64,S=1,device=NVIDIA_H200.json": "4dafa32ab78835e78d67e9a92f0fa788a32e28ea7c3d2bd4e70771d813bdf50c", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_expand,K=4096,R=64,S=3,device=NVIDIA_H200.json": "1656bcc75507725947af06940bd290b0fe5cee1dfee288ef4cf5a35202d85dd1", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_expand,K=6144,R=64,S=2,device=NVIDIA_H200.json": "b5dae0b58af37bec41a5d2a61ac9f0a7ad6f965b2096eefca9023c9b3e103627", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=1024,R=64,S=2,device=NVIDIA_H200.json": "637806800dbf01eba94f67067db60c9179b8016909a36d63bd4e43eb09ec356e", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=1024,R=64,S=3,device=NVIDIA_H200.json": "2d701fd6dd639b389826903177910ac727561da3e4e742d2c8eadabe6aad641c", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=2048,R=64,S=1,device=NVIDIA_H200.json": "c04d42f40c70acb8383f430226c88abb9af7d57ade0ab0304c313588a8e0b547", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=3072,R=64,S=1,device=NVIDIA_H200.json": "72fc03f2163375f242dfd5e6a8eb2f9c5630b8fd0b1ffa46ccfa16f98ef52e9e", + "python/sglang/kernels/ops/gemm/cutedsl_bf16_gemm.py": "6217583a506217f5d001f4aac125ba9253c1a65ebb6f378ce98442c0d70e55e8", + "python/sglang/kernels/ops/gemm/cutedsl_dsv3_fused_a_gemm.py": "20a48ac344d9c82198052cdaca386c504fee6bbfbe19260b42a6d3df1f14195f", + "python/sglang/kernels/ops/gemm/dsv3_fused_a_gemm.py": "7eebd0e7c5c2fc3ec5afc283012c94990f7d8995c923ff3037e3dc0c79047807", + "python/sglang/kernels/ops/gemm/dsv3_router_gemm.py": "70a421bfd27b85680373a742e49829d3dfb392f736f609ca42b9eca982082c40", + "python/sglang/kernels/ops/gemm/embedding_lora_a.py": "44a704ebb8e084326d634e1f5697bb49c6bbd3a825790849da7f4c6c28537557", + "python/sglang/kernels/ops/gemm/flashinfer_pr4266_dense_bf16_gemm_sm100_splitk.py": "ff7fc374b440218d3261c94c54be04efdd7fa549780746ac0954cb88986dbaf4", + "python/sglang/kernels/ops/gemm/fp8_blockwise_gemm.py": "86026c90a00063193fc848cff90067b3976c32255e023d6cb52ca3c3afc60b6f", + "python/sglang/kernels/ops/gemm/fused_a_gemm.py": "a7e41c536e4ad55ab04a4456a6a52bcf201707c77e51c320de245d28e361e55c", + "python/sglang/kernels/ops/gemm/gate_up_lora_b.py": "a1444cf7b161e5ce7801453ab719006e0f59d9876d293f8e97a3e8474586587e", + "python/sglang/kernels/ops/gemm/kernel_utils.py": "cdafe7d0763c7baeeabf141bbe9d38ee75ea3631dc157d9263097bf37c1db6f4", + "python/sglang/kernels/ops/gemm/kv_b_lora_absorbed.py": "59f8ea4af698f4ac2b47abb986f166f4d4930adf80cc72e630204d5b66c8543c", + "python/sglang/kernels/ops/gemm/lora_tuning_config.py": "aed0be9961f803cc6d4956e0e5abb0bdda960e859477e85007c925f24a1a7ddb", + "python/sglang/kernels/ops/gemm/qkv_lora_b.py": "57457ce0c29538c60e95f8c8a212e07726ade389460baafdcb1b6d230eb719aa", + "python/sglang/kernels/ops/gemm/sgemm_lora_a.py": "5d175ae4e9671085f24e298ed7ed3042e829bd2079eb8221fa3d3e2c0c04ecf0", + "python/sglang/kernels/ops/gemm/sgemm_lora_b.py": "266579cda8289e8c87c5411cf69a8fd7276e32b2b255328484a995e2d64b04fe", + "python/sglang/kernels/ops/gemm/sm120_online_fp8.py": "949793d24c9e166f46f173279e96541698153cb5d4765ed0e29d60d87e04df31", + "python/sglang/kernels/ops/gemm/tiny_gemm.py": "f975b4092e23ea26cdb62b07e3db41c68caeb293969ed90643a7b05da9ef65a6", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/__init__.py": "46a41f87b80b661d990f84ce9925f265ae3d833b378aa496822df31392bf5721", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/gate_up_lora_b.py": "a8d57f36f29d36284a2e0a9a045e36fb369e9a68681359254e6b58994c602c2f", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/kernel_utils.py": "14eab93e5bc85eeda76d679e422e95d48ad3fb3b7b86bdca728b83887e1aa829", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/kv_b_lora_absorbed.py": "d2e100d3af9711fe9fc9f8312e9990898397fcffcc55b8da8c4bbe2234d13b84", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/qkv_lora_b.py": "85a494048308de003890526ffcad00c4d6df6f3ce67a059147d7cca750a3a1f8", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/sgemm_lora_a.py": "db88315cd2db0b991273c00f9388953f0123df355faa7462f749bcd20fcadf03", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/sgemm_lora_b.py": "8a6453a9f32c23ba46b7800868b6b7392e23f50c5f367fc66f33963ba7624b5d", + "python/sglang/kernels/ops/grammar/__init__.py": "650612778d49fc2fc68e5641dab243c22ae5f73117f9d363e1477ed77847fc6d", + "python/sglang/kernels/ops/grammar/bitmask_ops.py": "5a34de9fd8aeb8558bce41359801d0641f7feda232e501fc5a37fe941f856a6b", + "python/sglang/kernels/ops/grammar/token_filter_ops.py": "7f78601f2f6143dfbc8e29c5aa4daf63e7d4002bef1c7e8b774cf7683d3f3fee", + "python/sglang/kernels/ops/kimi_k3/__init__.py": "d05bc02c371ab2ed217af119bc40cee853f7ef8cfa5204bd50d027f9dff86830", + "python/sglang/kernels/ops/kimi_k3/activation.py": "af6f58799eb172d39a350ad23440621915dd76dad5479339fbcfd550e3710cd6", + "python/sglang/kernels/ops/kimi_k3/all_reduce.py": "6e1d0eaeb4e8bf29f887c84140bde18691dd9cf38d89b1c4f409d18c757ca348", + "python/sglang/kernels/ops/kimi_k3/attn_res.py": "c851a9d2d3c3da409cc2ef535a9f94eb03bf8b4d4a47154c623b2444006354a4", + "python/sglang/kernels/ops/kimi_k3/attn_res_hip.py": "95ebe877ec7176f869e5d19997c92b0c57079b32430da8e264ea13809aacc51b", + "python/sglang/kernels/ops/kimi_k3/configs/sp_collective/world=4,H=7168,device_name=NVIDIA_GB300.json": "64fbfeb5b29e1eb1870692b6fbe7e74a1706c12742c4cfc69567a27607aab8f3", + "python/sglang/kernels/ops/kimi_k3/configs/sp_collective/world=8,H=7168,device_name=NVIDIA_GB300.json": "219b532137b089b3ec9693fb3c199034b7bc44d1a6a97a9b5c395bc5967a9b10", + "python/sglang/kernels/ops/kimi_k3/gemm_ag.py": "db348314282a1c38cf81149db702fd2e162bb2634c1cf2edf3159391b95b0a64", + "python/sglang/kernels/ops/kimi_k3/gemm_ar.py": "dbd6b822687a4dff30511202a3ad08853093cabbe4f1086b9340d9c5f9721ad9", + "python/sglang/kernels/ops/kimi_k3/kda_decode_mtp.py": "2a6c135ad98b823243d8492b81105df07f3c72db908c873fb0bbf25171664adb", + "python/sglang/kernels/ops/kimi_k3/mla_output_gate.py": "155c434b7b5001e9f4778b0d6bc2dc7ad2cb760b93e050ca2241a91ded5f78c5", + "python/sglang/kernels/ops/kimi_k3/moe.py": "ba62b68696260912ff1c7eceeb4f255f61411b72bc9071331934345b954164ef", + "python/sglang/kernels/ops/kimi_k3/sp_collective.py": "ef40307391fc97b15a39a93fa2ac15682b291e354c6fc5bc5a55efc193abd48c", + "python/sglang/kernels/ops/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/ops/kv_canary/consts.py": "6bbef700edfed32676d101c4e29f45ca6d7c9327019d8f3b0d01be4e83d3a83f", + "python/sglang/kernels/ops/kv_canary/plan/__init__.py": "f89a48c8cf947b6f98762eee9f338ee20cd8dfd1483c51e27f1c688d05eb5907", + "python/sglang/kernels/ops/kv_canary/plan/api.py": "8906795df412ba2b346593bc4825a40442bd3c1d8894a8c6f20a724af4cedb64", + "python/sglang/kernels/ops/kv_canary/plan/entries_kernel.py": "8971648dd987b7033e5fa111e9c6e3099afb2784a814fb0a675756c83b6ed222", + "python/sglang/kernels/ops/kv_canary/plan/offsets_kernel.py": "b2de9670740afb283edc8b6c33c8e77698a6d4f255fde30469b68d94dff7c800", + "python/sglang/kernels/ops/kv_canary/plan/utils.py": "d4f55a6637cf5d75ee6b32d0a26b7a60fff8d69d38b26f40653c45d7243fb11e", + "python/sglang/kernels/ops/kv_canary/plan_ref.py": "b2a3670f1f882a42f7459006b7309dc902e8ef5644c9edd372cecc73f02f26cf", + "python/sglang/kernels/ops/kv_canary/scatter_req_token_ids.py": "c14ef46d47a3b3039da885d349448c8091f8760b95a00a0fdca136a0573d1e0b", + "python/sglang/kernels/ops/kv_canary/verify.py": "ec4e777b3c6147b3e077fce68747161484662f570eeff0a531fa2d525f3e7147", + "python/sglang/kernels/ops/kv_canary/verify_ref.py": "03f41f0419bdda26c76b8a8db53ec67ae023fc76ef04b9a90fea0e48c19b9047", + "python/sglang/kernels/ops/kv_canary/write.py": "6e3c8ad4ab1dfae483070cf966a244bf3bf86382d346ef63d2da4cee6df2d4ce", + "python/sglang/kernels/ops/kv_canary/write_ref.py": "39c31b22ea0e908842f557770cc25f1f98ba42ac8ba1a8f79bf349dd18df6e8e", + "python/sglang/kernels/ops/kvcache/__init__.py": "ff8b033d0695a90a804b80116e08e93535013a2af6d4e4cadbfe6ed0ecfd921e", + "python/sglang/kernels/ops/kvcache/aiter_unified_attention.py": "4b295eeb1d77a7e40b3aae690ebdbfbe46258c90525317994a2b6f3164243a8b", + "python/sglang/kernels/ops/kvcache/cache_move.py": "eabca144a116c58141342d6dc6471e8244216776a3b1692aae6abc9e73d7b75a", + "python/sglang/kernels/ops/kvcache/cache_ops.py": "8965e5242a80e12cca326272a67ecb38eb36f2e6d3ad41dda22035861e59458a", + "python/sglang/kernels/ops/kvcache/fused_fp8_qkv_kv_cache.py": "88755d730cec527a7135aabff1c57779d11752ea7b286343c47c285a0be39fa3", + "python/sglang/kernels/ops/kvcache/hicache.py": "9b8e174c83d10743795f14ea5118abb4be86d895c8df238e7b163134883eee2f", + "python/sglang/kernels/ops/kvcache/hisparse.py": "f4b3958f0ed4c154fe39cc1fae217b2b80a7e1547c186d10105098af4ed5c566", + "python/sglang/kernels/ops/kvcache/kv_indices.py": "9d676688776c6c30883feba9f87a470ae364ff04e6cc1d51e5b2e7d2d45b6303", + "python/sglang/kernels/ops/kvcache/kvcache.py": "9a2101696be86275ea15725e11f8fe3ac55d560876ba66d81740236a916e47b6", + "python/sglang/kernels/ops/kvcache/minimax_store_kv_index.py": "dc8cf08f18f287f3a01c4071eed01d0186f38a4b7cd0657fb25c78922b20dbe5", + "python/sglang/kernels/ops/kvcache/mla_buffer.py": "3726d1c298e50cfcc3704573ffc001ac9343294480d331552e22f907bcf546de", + "python/sglang/kernels/ops/kvcache/rope_cache.py": "3aa237838d71d235a6df3ea41a91921d0450ef8fdf207cc340da03a8bd577f6d", + "python/sglang/kernels/ops/kvcache/set_mla_kv_buffer.py": "0cd007ea7fc26c2e3c84c0fdfe4caaf65b8b71d2b1b3d5775bc4d7d1b49bc2ce", + "python/sglang/kernels/ops/kvcache/triton_store_cache.py": "6c4b892865a0c198e9b980d03a8e7b75803cbc0b0a565ec0f1e3533bc8db6584", + "python/sglang/kernels/ops/kvcache/trtllm_mha_graph_metadata.py": "f58a0217a26dca700d1a91d73fdc069643b1870f6312c1a7745b0fb2dd81fecb", + "python/sglang/kernels/ops/kvcache/trtllm_mha_page_table.py": "1f47077656f99720d37aead72242ec7ac8dfcc1bd2c331c95118a3a9f6c7bd6a", + "python/sglang/kernels/ops/kvcache/zero_pages.py": "765e5ae8b8fae7ac7ea9c2c3a4e361cbd35e07d052adcc60f98da1e2a788a5fb", + "python/sglang/kernels/ops/layernorm/__init__.py": "50106dfbcc81884ec1ea9dc3b7522423d196d731fd051f7992347ed260889967", + "python/sglang/kernels/ops/layernorm/fused_eh_norm.py": "662a38cdbfde51eeed8ff07af486affa467b93a2f051eba1cb7f7b9f7b468281", + "python/sglang/kernels/ops/layernorm/gemma4_fused_ops.py": "f9d8c7c3ea71afc1341c2de02807b8fda94e418248bd9ee404b15b3337463ad3", + "python/sglang/kernels/ops/layernorm/grouped_gemma_rmsnorm.py": "ddda52c6d0bbceb817e83815a8e89c54b408a1b5bc238df7df81e2b974dfddc9", + "python/sglang/kernels/ops/layernorm/mhc.py": "d1bf39ee70af251ae539de44fd56671f95d76bcdbb02f816d5f3f25ec55634e3", + "python/sglang/kernels/ops/layernorm/mhc_head.py": "a82d40c36a0c9b40285116cf1701f5e449b895eb48f18b00ab6600ef53537826", + "python/sglang/kernels/ops/layernorm/minimax_m3_rmsnorm.py": "e7e81662d1989eacd46b757b0240111ef9caae31a77fb3035ca2b9196307198d", + "python/sglang/kernels/ops/layernorm/norm.py": "6105bf76253528190cae48c77f2d62315debf3c201950337ab7ae2273a3a7d17", + "python/sglang/kernels/ops/layernorm/rmsnorm_hf.py": "9933deb3f66af9e04c125727819d47b392cd804f509d04bd23484301efac6d87", + "python/sglang/kernels/ops/lplb/__init__.py": "cc59c1c96943b4860375c4d45b2bdfd668f653613cccc1dca62e4cf38766b1d7", + "python/sglang/kernels/ops/lplb/cublasdx_solver.py": "936110bc5799cc43ac1e50c65e03a8099bdf057a24b75c506b42e1aaaf79ad64", + "python/sglang/kernels/ops/lplb/cuda_solver.py": "cada08e6b9c6e421adbad7b37857d97dcc40d0fc96074d74c52bab2a889fac79", + "python/sglang/kernels/ops/lplb/shmem_budget.py": "360bd9171b75299b4f5563d6fd2d1ca2b5f7012df68add0a93a575432a95449d", + "python/sglang/kernels/ops/lplb/torch_solver.py": "f8c4501c5fc51795b9ccf374cc9c803f314d6b9092be8c4634bb45dde30558b5", + "python/sglang/kernels/ops/mamba/__init__.py": "97bc4578cddcf40ce2badad85079f2446b3240281195dd2a8960606ba3518bac", + "python/sglang/kernels/ops/mamba/causal_conv1d_triton.py": "5fb01e6aafe9b9ddf1fc3adac49c2a09c8aec310de234e2b0d8d4f75f587bfe2", + "python/sglang/kernels/ops/mamba/inkling_sconv.py": "fdf8b125ad55e8964ae7cef273880aa08953ff51f8aa146c243fb68285ba9517", + "python/sglang/kernels/ops/mamba/mamba_state_indices_triton.py": "75f8ced02daa10b77a284e5cf8cf176ea417259ea09ae4dad51dd4c0c0d6c6b3", + "python/sglang/kernels/ops/mamba/mamba_state_scatter_triton.py": "67681aefc281375e96ea48fd471b14a9b1594c6496d53c3bce3e5cc026537abc", + "python/sglang/kernels/ops/mamba/transfer_mamba.py": "07a7649666ea0651b549a071172dc324b8bf97d1ea6cad23ff2ccf621cc63757", + "python/sglang/kernels/ops/mamba/triton_ops/__init__.py": "01af68cc89077d4152b2684f4553f53e5ed3e5767841fcb5c13265e76a416b34", + "python/sglang/kernels/ops/mamba/triton_ops/mamba_ssm.py": "fe453aa738428802bc7ca4dbf5afa653787bfb646434b73ef91376c028adf7f3", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_bmm.py": "27afe193a8f5ea7f51258cabfbd67200929be9526da8cd73a189c1ceb3dea37d", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_chunk_scan.py": "9fbd0140cf03a60effb215fcedacb742f04450ee1f11c9a0d4ea2953cf0a3e21", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_chunk_state.py": "dc2fed284d4fba3328b45e531a21ce61e94bc5895470acaa9a5ceb1a0fed1d24", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_combined.py": "0f98cd2e9a9d6f743d7d334ccd89b18f2336dbbaa5665bdbe4cd4d08024d9648", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_state_passing.py": "cf0460418fabf6035e0af6f3ebffa63d25d0805e135151f5ac378a27f1bbb7d6", + "python/sglang/kernels/ops/mamba/triton_ops/ssu_dispatch.py": "a6125c8c4268d7aeafb67b983cae4f0d3cd0cfc3109613504cf4075b2e888e11", + "python/sglang/kernels/ops/memory/__init__.py": "eb0efdf461a1c718a18c3d85872f15402d6e8d4762fdb624d6d0c2a02e99afcc", + "python/sglang/kernels/ops/memory/allocator.py": "ea84e0af085cf6821e6c4568516764da706aa9efd997f8d7a8dbaba8d97461a3", + "python/sglang/kernels/ops/memory/common.py": "a2377e0d262b8a527475477a7e76a3dd137ff8cd589f9af0067f5c23378a6aa3", + "python/sglang/kernels/ops/memory/gpu_tensor_hash.py": "0401f647b849a0f763e55f9f917dec78678f5a735aabb401e64801e49123a38f", + "python/sglang/kernels/ops/memory/memcpy_triton.py": "a81f299bb4186f9cae247cb3f5c97c8554e9ec7f248aa34266156964ca8a939f", + "python/sglang/kernels/ops/memory/virtual_slot.py": "3e11bc67d4169134a9b8c3984749baf89b5971d827bcb0a87cbb3ccfb01fab48", + "python/sglang/kernels/ops/mm/__init__.py": "8b8c0d9e89ad6a28d359ef75769e6496ed7812b6aef71031dad6e4a53eacc829", + "python/sglang/kernels/ops/mm/process/__init__.py": "2cd3d5d1285cd203e6c10bdd5efd5d32c79d6f64d4c1627c65ff519df2fde96c", + "python/sglang/kernels/ops/mm/process/image.py": "79870c590b700056cafff51814d892bc090a0d3dc73fffaea5ecfae266a1ae33", + "python/sglang/kernels/ops/moe/__init__.py": "907720e21482bba929cad791045c785d9885e1db1acd5bea3dfd5c15c2a4ea0a", + "python/sglang/kernels/ops/moe/configs/moe_front/epilogue,E=896,topk=16,device_name=NVIDIA_GB300.json": "f6140a7d1cf3b8f75c53cc41e7d4aaf4c8fe10b34189119ed4293d9419a56966", + "python/sglang/kernels/ops/moe/configs/moe_front/strategy,E=896,topk=16,device_name=NVIDIA_GB300.json": "c333815256dbe18a9043b16c66704498b00d392e1e6bdbade3b647180cd20af0", + "python/sglang/kernels/ops/moe/deepep_waterfill_kernels.py": "ff5685f930c3a630e3f72551d3b810d773c2f35bca5482104d77622d9dea443d", + "python/sglang/kernels/ops/moe/ep_moe_kernels.py": "e685835c09cf82a5d15481345cc8163f083bdf391e94f58d8398b073b77f62c5", + "python/sglang/kernels/ops/moe/fill_padded_rows.py": "18439c7bf44073acc136ff644052e9b9a0d76a2312108ff3d0a2203a251bc022", + "python/sglang/kernels/ops/moe/fused_moe_lora_kernel.py": "0042c5aabfee2bed6985a9e3796dbabe2426a9ec50fe9c5f23c7b48754e123b4", + "python/sglang/kernels/ops/moe/fused_moe_triton_kernels.py": "9c3342d3147e7d60a78a2c934111f0fc1becbb8df1d2d32aafc82e6c8a0b2e70", + "python/sglang/kernels/ops/moe/gate_topk.py": "9bbbe6a89810f6ea68a90dfed2dbf48da02dd1872eb51e2c9e5a9b5b5ebbe6b9", + "python/sglang/kernels/ops/moe/inkling_gate_topk_renorm.py": "b2da874fb42e04e5525e218db074cbb28fe42efaedf0488d49aa87150ac55c9c", + "python/sglang/kernels/ops/moe/inkling_moe.py": "0727ceccba5c74700ba47230f84cfbd937bd251018c505cda338bedcd162ac2b", + "python/sglang/kernels/ops/moe/minimax_m3_swiglu.py": "4e2cd1f047ffc5b5dd5fd20359e51dc31816d078adff5a8045260800231261ed", + "python/sglang/kernels/ops/moe/moe_align.py": "86877951a95cb96a4f92586bd3fc649493454dddb7521297ddd1560ecece3b17", + "python/sglang/kernels/ops/moe/moe_align_single_token.py": "5815a12c30b00719496db29860353900d27225803eba16d91a3c09eaabb30498", + "python/sglang/kernels/ops/moe/moe_align_small_numel.py": "ddeb1b65e6b86338c51077029fbd1e1a9c61b6fd625ef6fb272435c0b8608008", + "python/sglang/kernels/ops/moe/moe_finalize_fuse_shared.py": "6702f87cbbf57e73707313590368de95af3c6c2dd571facdaa6dfc73be0993e2", + "python/sglang/kernels/ops/moe/moe_front.py": "951be9046a5785294866d747c130fa2fa25aab945304cb49b48fa0e4b7209849", + "python/sglang/kernels/ops/moe/moe_fused_gate.py": "945eae03580d034420a20f2c38adf8d9ae8fed4a13de364d8c235466ffc513b0", + "python/sglang/kernels/ops/moe/moe_fused_mul_sum.py": "937d437f85e600b4566f9c436437139d27f5e0e65b76c4d407023468338e58e4", + "python/sglang/kernels/ops/moe/moe_lora_align.py": "0a0e28a7c7ce9c41fb6ed434b316e998b08e2af37d808dc32d68c5b841d24288", + "python/sglang/kernels/ops/moe/moe_permute_prepare.py": "53df1bcd7c072f23e44ebfa4cecd1a51d464793ea2b5a33d7236c563ca6ed46c", + "python/sglang/kernels/ops/moe/moe_route_quant_fused.py": "0c5965c027558dd464d9af83f7bb11bb05785309fa53292ec0a6000f978d19e8", + "python/sglang/kernels/ops/moe/moe_route_radix.py": "84a7b2e8977dbcca38b92fd56ecf8c72f4d6cb8dac484fd137ea96bad64682ed", + "python/sglang/kernels/ops/moe/moe_topk_sigmoid.py": "d4351193f9cf41e51086f50432c88eb9ee1a3e3ddf06c50be05fa2050398c52f", + "python/sglang/kernels/ops/moe/moe_topk_softmax.py": "e5403377267035a6a9914e8e35b80a59158d2091f83d458bc4198c70c7ae28a0", + "python/sglang/kernels/ops/moe/moe_topk_sum.py": "1847f8d4eb524e3b2e11969496f6bac485c1e275a5da58d3737002048c5c8e37", + "python/sglang/kernels/ops/moe/moe_wna16_marlin.py": "0f99349d7b7efd56f3a6fce990c6792246e83b1696a409798514ad5e0c309e6a", + "python/sglang/kernels/ops/moe/mxfp8_moe_amd_gfx95.py": "28e68a6a9e6d5db18515a670a3fa622a9ba2bfc11b489e3e6fdc81b8f3debff3", + "python/sglang/kernels/ops/moe/pack_topk_ids.py": "01114f7c2d013b2629fde0cf50fc4cb7e2ebfd09951f90b0bb496c61d2a7d3ed", + "python/sglang/kernels/ops/moe/rocm_moe_utils.py": "2ff5f8ccbe7e1454f6c9ca61dc5521211c07b32a765dde9ebe6e99a504047b75", + "python/sglang/kernels/ops/moe/router.py": "787fcfe75984ec59f5154fcc7cd0dadc37cdd4548545971a8533d2a7c63d86ed", + "python/sglang/kernels/ops/moe/sigmoid_gate_topk_renorm.py": "308766f6b682bf7938da86ba85bfb731067d5ce6191c866828cdde119afa3366", + "python/sglang/kernels/ops/moe/triton_hash_topk.py": "ad764744fb1b569717dc6f6d2952326dc41a8fc05637c9d2232627e5907fb17d", + "python/sglang/kernels/ops/moe/triton_sigmoid_gate_mul.py": "7c357dfb96efb31a52e1895477a97f96d17c11e618d35cc0cb04ba4d051a6d89", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/SOURCE.md": "14ab603836404013486041129d3483d6da61e1d708ddd0ebdfb0676a51c3cd92", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/__init__.py": "d5a67ad8c9c69f9099eb9a27aa92b15a7f0fe590019eaf094f1b5f138c053774", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/core.py": "70aa97a50971d8731d1e756f095fcfea76d9394447730ae092e8d5ca77015762", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/fused_activation_quant.cuh": "9cc9f7dc1cedfa7c79cfd0e0c35023efe860de11c3d99fd5868ee731f5f4b822", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/fused_moe/trtllm_backend/trtllm_fused_moe_dev_kernel.cu": "d364842bbe3efc86f1653ab5e9e7c03c3debb6829da31cc60b212ce591680636", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/fused_permute_quant.cuh": "d3d48ef13dd4966f7130e98dc53d12dff1c4dbb067768661fb77f2cc1c9299ec", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/trtllm_fused_moe_kernel_launcher.cu": "94e7367cd8be10b4c800764bf20bd420816d038d64477a90e603355967905c16", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/trtllm_fused_moe_runner.cu": "404b03aaada56bde468bf43001bb0b62422f617131840c34d3fbea438dc887db", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/include/flashinfer/trtllm/fused_moe/DevKernel.h": "7e8e91cae9a0730654e4f096ee35c2d770f345cc5795eadea67ee42daaa4c917", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/include/flashinfer/trtllm/fused_moe/runner.h": "3fc2f48d1acd13ba71cd7747d9415936a7155b4f92c67b62d7ba83bb513ef9b3", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/jit.py": "4993f260c64aeba3c46874fbc43ed0d28edac29a8932ab4a667e45f9fad7ad3d", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/kimi_k2_moe_fused_gate.py": "3a06d43b3c1291646e7c9f20650b9f07f51f05f7cd1896114bf2ebb760ca8dcc", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/moe_lora_merged_align.py": "b623e7d7f0c0d2c5f60c1296113115abfe64ee395a7d8a7151f86f79b17170a8", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/topk_pack.py": "9dc26c3134be47ea6af4078ca4e0e28d71056d7cc68704f960bb1733061669a3", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/topk_softmax_pack.py": "9960dbb95c50bb403180b4204b08fb82a0f21ffa6ef8051193ad7d18545d8d7f", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/virtual_experts.py": "911f7e344ec3b19e198ceabc2d8eb3b7e4e7a22f3f6405bd05f5544ff9ec0b19", + "python/sglang/kernels/ops/moe/virtual_experts.py": "43ce29967827ab2b3603e6ec06651edc984cbd5f915ba3d83496855ded8a7fc9", + "python/sglang/kernels/ops/quantization/__init__.py": "26d3f9c70f1b68dc2b2820530a85412dccfd27a12d82c725094ea230f8b12e12", + "python/sglang/kernels/ops/quantization/awq_dequantize.py": "82c4c1396bcfb05b6d6f0f8de2ba6060c6b0dccf8aef8d5bb2a841365ae504e6", + "python/sglang/kernels/ops/quantization/awq_marlin_repack.py": "4d10f132f5ee312ce6d48926811851ea0630d3182a58c89e95e8da0dcf1e2ba1", + "python/sglang/kernels/ops/quantization/awq_triton.py": "d50c29c4fa2a71f7b7b0353cb91b372d705170366fabe33dc50ecd13d455d0c7", + "python/sglang/kernels/ops/quantization/configs/N=1280,K=5120,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "7e0ad2a82391ae0500492bed02e65a51d4c36e9dbb159cc17f265c7621528c95", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "45d1d0c565f05eabe2a37d75f76bec2da2a312be1ffc38e930f2a56ab6352009", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "d2f2da260a3907db62f97305289baf4a83068ec650f918474b1e1c0bc5e38be5", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "b642e3c0b0bf6955e1ceebe8fb64079288d765ab8f26c7f78cd1c59f54bbb910", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "08fa355911741e0b1030f064be9a0898495032b7f0a492e112f2fce9ee9f90f5", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "f6a77287a922f4b032abb5433bd58c46604e3d6292ad9854f88ef3d44f5b4ca0", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6a24dca01603c27b88c3a647d5396097a6e34c5239acb1d0fca06869da25eff", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6a24dca01603c27b88c3a647d5396097a6e34c5239acb1d0fca06869da25eff", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "f726bd7f536dd20d110feeac45105939a20f2d2a521590b3ee336fa933eb8051", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "dc4f8b5da5b514fa138823c1bab9bb536495e0a9968b8c66ab07428c7bd99240", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "68ef3be22bd7a67afb5ab1540bb082378871c5cfc8cce4f0d9260dbfa2f4fb64", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "4288fdacb2d10db28ce08281097bcdf11731cd298d3ddd1341488cec25c3a872", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "5199639f1c424a3c276655f73a029664919709fe41585fda804a4d5fc2386717", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e03dcabb8cbb042544273b9e2af402fcabce474dbac3738d5acc5fb00fd8ac47", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "e8f397cd064774dc1c043bf5c3a04929b2cc443b748db154b8cb0c35ff93a04b", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=4096,device_name=NVIDIA_L40,dtype=fp8_w8a8,block_shape=[128, 128].json": "2f46d4a0a76cee0bd0ce11cd379b18ce4f1ea99fae6c696a19008ed5b288d21d", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "d46d91b8a352f3c9a30fbe9985717047e2c184a6aa96dba9195250761b0ac09a", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "d035cbe8396572f76c17bae82d8a44e7fec99811237135a2170da21e3114511b", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "eefe2da7445a4f8bf1178bab481ae42b9151ff98a478543586d1770f00e5d659", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "de66ada02cc47b869ec70a1eed84e6923c84e0d03c9215978cbe44c92b8dc330", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d09d8c16068b92ffa67d5139c77eb796054a614ea688b1bfc513b7b495206bf3", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "25e5cd2e46cc023743295f96a73432f3b497374eada30a37c54a1f2edbd80902", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "93cd6296dd75f799cfe2bd7ded6edc6689cf2797f667902d4b05198c6da730e1", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "fef928b83c0620fcb2762140d95c7c4bd30ae542c5506b374b0ac83da2e1c47f", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "e2e6db8704855ff5db79f44b1242e85b126471eb4558fcecb333eed17dff5abc", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "f5ff086f880b10549f74da4ef082fcba238d226bea9e53db26b6741ccdce07ea", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "161ca78864f1e50782b95ac14954d0caceaad393ebe653c470fca4a405fb232a", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "0686bcdd948f6742efceab5f2c6be88ace502b84e625fc230369fde9cf444f9f", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=1536,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=1536,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=1536,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=4096,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "3d7ac07c8cdea58f76746a72b01b4b82f869a449cb891c54d8d942e2d21a571e", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "7e66f3a427748b25408eb9d49002e6abf464c2ecd5fd59daa656d2d4c8ff72c9", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "c18f0fb7cff9ece2c8bf210b92da8d7b41b5a79184c1551a719df111e6c69cb3", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d2fd7bbfbf291135efe92d99a226de9313958624e60a6f34ec3606e0338d51c9", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "238e0fbc98fbe7cfacc3f7c239544e2d3a46d0d439ff93c263241ca590b56126", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "b46e7f8957910474e01d7fa588e7fbf675918e3fe5519f8d4164db06b0603914", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "0c10b1991dbd41ff5fefc0cf719378b7f61baf8dd300b3594fa179bc03fee7a2", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f82547a829513a58bd1567bf167967b801b62e2162bc314afe78211fab7e0567", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "f6d099c49d1e003ec060c1fb3aa4b7006a692549652a724b36f32aec531776c0", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b264f5620f1f54b03346a42e6c20b18ab589f4a2dbc04a82b7dbcffdda0fbffa", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "7537b53b75225d272c2d4499a381a28f843901eec894bdc34a730f8994d8d366", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "1ac2e8624699da9e10bb40a88fe5fdd2cec95b27d904e9682073e5c8d29221eb", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "0692b0798e077c1c79c6fa92bf035a872f71ed1e451fe60af23eab2c541d2b0a", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "40c55f3174b46238286fcffdc69b35c6e662e8a9d8e65d8c78ac572d18d37a0e", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "6d2c536a9b5d7208f6ee640699d52642d6139f857ff04726b5169536280a8cb0", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f33b8984575de9a5d11298aa3c58482841560399602d51ab1b4f9af545dc06a9", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "8a75d7abaf113f9e347e02c2e472378163397d166fb8243fd4cde759d559074e", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "667d53be10283cebf4cd00581ce661c1d0f0de8ab2c66d3321aec82644c21e9a", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "caa8ceef330bec4b1e049c3a067e4c4f21de022b643ec97576775778be919fa0", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "fa740884a00e54242bc4b57a1c395c0f457c1cc5afaabbfebf288e45553baa5b", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "261b38a1dc76e5f817c974a69ef6e63595b2a6ff7da2e85d04324a0f776b541a", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3379f0a59776fb4c36eb7cb066df606b0e77cfb30debbdd3e6d978b5ce3736d9", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "ecf69ac0312680218e2a77f997ca15a02116c7d97a00f9f6e67759f18aed6abe", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "ba92c3c86b2b89abed5be0b4b9367602172d5540f3c6fff95d5e2bc08c9cb5e7", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "bcba15dc932dbc738aa51e43d4178240f32e625594025ad7bb9e20072364c0a6", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "32dc3b6bd052b298f64f30be68fc44f36a352c4bf0ce06d4b88a1fc11c54340d", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "074968dd2ba8417841127a231f64f0a557aeaef94a0fcc88f2442b2793918565", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "e55f381bf372105778a3c70be32df830f598ed4ab12f9e1c43eefdadac9cebce", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "347771ded6677cb17b36996cc0ccdc4d16d011014bb42860e2b77b194f6531b3", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "658674df388f1b01b6b026ac1182e3ed920feef34ef14341479a8d4e62a044cb", + "python/sglang/kernels/ops/quantization/configs/N=36864,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "95a61e1f8c348993a3d98837bc382d2a8ae83509f00445f819418bacef74f792", + "python/sglang/kernels/ops/quantization/configs/N=36864,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4d670f0d9da6890303e8e5830b516d791b3cd0d0fd442fa824bdcf2d59896ed2", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=12288,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "452380d435c282ae8eef1269c65086c6d55b54aaa2ed41233daf541a575faa2a", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=4096,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "9bebe165ab5295f364809405b9501589d9d39e50bd12ab5ffd375a67300ff240", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "c7135f1ad1c09710d55fb3c19ea13124dd149d8940d146da6285d49ae5f426c2", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e99ee421ad7846356adde93f0b5e6ae6652ed48ad8dabd0e3fc4befe99be3185", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "afadd2664509255f3b074d21017d3be3fb9a0bbc3041776eae526c0758d40342", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "6d52657a30601e34563c36effb991b933d671e3a542fa54a72d8372c6d477152", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "c4187174215fdf069352c2f1271039e11f74cce0db0bf0ca2375d70552a3291c", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "5c635b518c9e4676f93727e94dcd65b9e1e35bf8b8f4ef63f4c03e328adab1d2", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "5c635b518c9e4676f93727e94dcd65b9e1e35bf8b8f4ef63f4c03e328adab1d2", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "d7a424e01adb55039d47d12dd93dd29cba6141dbc4c2eb86dd6dd70a60056b7b", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3bf495dafa3fa1a0017d3e8cc6a726a35da99e12ad7d7e139d77ded3639c1c99", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "835d9792eadab7ba144bb2dd4bda472ca165babe3f15a30688606f76afa2042b", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "25ca5511359c6d7e2e3e668ececc0b2e5696a90b4e7ce90c4319e202a3196461", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "b4576b6399c00e65d495285d37cc3c273931ba3fd13cb5c245c797f45850df91", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "600e0fde2590732bf1f70460bece733aa8f730a6f48b79434df5f7893cc98767", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "600e0fde2590732bf1f70460bece733aa8f730a6f48b79434df5f7893cc98767", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "9b413d4f07d98efb68a5816123dd9549aaa18946698c1bbaf64bf9eab28c12e4", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4cedaa4469a9dfbbf9dd9aaef09a1eabf0526edc0cfe6a55a28cc6ca8360d3ea", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "aee99424f346bad39bb2ee24ba71613daec1a207d18acb36a82ad07f5fe23a6e", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d31aae7f4d1f81fac3383a5ac72aded150dc8ea7f3a84c63f77f6bcde27ca4ca", + "python/sglang/kernels/ops/quantization/configs/N=5120,K=1024,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "5725fdd408d67cdd0ec970db897280e946e85d64bec8d045377b65f6ed470ec8", + "python/sglang/kernels/ops/quantization/configs/N=5120,K=2048,device_name=NVIDIA_L40,dtype=fp8_w8a8,block_shape=[128, 128].json": "7600f18a8ef9f95ec1806991d1646737e6ff43aeacefb62d9f648616b4c0456a", + "python/sglang/kernels/ops/quantization/configs/N=5120,K=3200,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "70fef34b838e2aa124a97bc30943d3fcd70649b2bf63d0861d99efc47fd83a6f", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6c14caeae1ac9b0a57c9ca19bbf1cd477f58dcc854869dfca0747629ece8524", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6c14caeae1ac9b0a57c9ca19bbf1cd477f58dcc854869dfca0747629ece8524", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "038bb35894cd87235587b9ed3af5294f44e179a115bbf8ecd0d08d75abfc993b", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "ba1d872d4351188a8dba555226b85a9af328fee1311c0f92da891077aac707c6", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "497093dbede595d24507348be2e93ad1484606bcd5db3337e00d919055e05c4b", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "a86eafde7dea17a2c4d837464fe98321779c6756bbbe0ee9dd0a97602317f399", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "1201531b25bf62e0f0c840d40a81a0972235113763f49ec047451f27cea33282", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "0692b0798e077c1c79c6fa92bf035a872f71ed1e451fe60af23eab2c541d2b0a", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "956f0260a2fc1561187e0a0008aeabc0b4cac40cad3bc7878103cd4476ec237c", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "362a2b2603a8b7191070fe3d203df3e5a975500e10403ad3f0cbdb0b00162f96", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "15cbb37262857f645b694a40680b2e39b51e7dc18c80d3cc0db55d1d7464a066", + "python/sglang/kernels/ops/quantization/configs/N=6144,K=4096,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "0303aa74a51f84f4322d9420573928d55b111eee725891949a9d249a3121277b", + "python/sglang/kernels/ops/quantization/configs/N=6400,K=5120,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "dc2594d10e4c2d7621d6aa529d3a7e6f6a61b3eac965977ce4a4a6bd3d55604c", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "60a3dbf72bee313072da69de971acdd1e61cb9f68c1f5660371effd2018444e2", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "6905658c4c740b3be0916433f2437cf6a9ba43e89024378aedd2ab728f68a052", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "6cf416b6f689af338e22023e47e308c6cfdfe320bf1686e40f276edce90e16d8", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "877da509316294b97229b31eb89bcd586d6fd32249ccd8fdde4c12be5ac77da6", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "651822b876764850babbe595e431b06aee24d5188f2c8ebb78434ed1efb96258", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "92343f92f177f1b64672669e246489b1247435c52350e8772d9dbee5ce243ef1", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "0ccf74f23ee224a2b478b0d1f11d9a066642ff398c8d67362d7c4b92d62da807", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b7e99ac5ab0afbc92fdf6fe025638af7b41f42bb24de25d6f3528609a2e6e473", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "fa13ff3fc34cd0ad38986cd39a91813626d0e71c61e603f3e56b68317868cf51", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "d235fecf6953815c3b0012e65ac22c41da96e048e66d72910c7c9efd73cb0801", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "141e4b7b8a1bbcfa028054a70bfdfe521e7d9fe32de11a25f2c69755c2b744fc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "999194dfdb286ed52a3582a3b722068e1399c82390149305dcc8a7035ce34c90", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "5245f3c461955eeab7ca6a9a5dbd5012a9ea5dc5c137e985bd90d9a0a1c7e641", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b54bdb6e0975f1c81b6e64107b64adf8e7f8c248720bd41039682355306efdd4", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "90bbe21af56782980eb9e95f2adbeff48b3b31643cf6b1b196898c44feadd087", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "fdec4cdf027714c9861f0781707fbc231c1907368e98f685dd270c33a283a626", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "b9eda85a6976a2e51365e958c7936de69802998fa26f798b575ade24bf59b9d1", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "dadd659a7878167ebb612ab89da3f683f46a602d15b6c5604f0e464b5e00fffc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b326f4b4fc2b7585023a807b7d3117112d06689ea3cbf22a2378b5dfacee75be", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "be5cacd198bf09a694e3538719b59206d6d5825162f7c6e0a84c9204c73d49d8", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "616c81c8e94a4aaa7995b7146bc7aee8dd9d1d1289a890db0834a37434099e08", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "10d45661d530234a281dbe88c1c1e58aea5158e3e7c3eefe5adc5907ea901892", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "ee14d6b044935498c2f317c6a0b179a19a2b1299dc7eb0c687a9579cb6611488", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "8f93d35b4202e19db2408ca071d20268eb2f6fadfdbba32ff99a49624ac14369", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "36ff4a3ff28b1ac44974917be7975906f6d3c2cdfbbb518cd948a0311940b65d", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "bf657018b62fad8cb735fafb0a23a4b23691f976f01eedb546c5d9dc9ebfc9f2", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "f6f4ed082b447fbca132c9e0f9910053f82f28c4ead38c1381eca45740609d3a", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "1a0cb885e8e47168e2c39062fb01b348fe492d5baf3a38a9feb6e35c504965bb", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "5f2e26819c798a212fbafdb274ee1d14d213f2cd2380184d1c4d6fbbdddf1893", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "4dd5ae136448b08cabe089b6e0cb962b75f288db5b84efe10220170f3e603549", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "9c3f8a8b75ae43e324b6f1476ac624f220b5b323d499f6e9b2871751e6bd05dc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "c78efa9c57a5b41ff688ef7feb2fb3d8ffee9c06e1ee084b3c58b9cf62ce4cea", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "64e584a3ffe8532f008498809510ae18d01935d370785756045a6d258930c6cf", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "b13bda27446209a41e9b8175cfba044ba455449da02a006e71c5f5dd2d52a867", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e2e5a240c87771963f12d2c0d1adcf53c675542ba71763e9a254cf61e3fd463a", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "0f49a888aa92ef7a2b8a5df688d8f98112545a94f6499e637fe65eb1466736fe", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "afece7766553144f9bd639ce37dcf0b8142f4c1a2856e8f5aa37fb86f8c512df", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "377edd50bfc9d8956980b1659e5cfffc293b6789e344e9cd00ef15da8883aabf", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "cee4983b40de8ee1c92b476a4accd3c92a195058b3823b4b2174a38ce0bf9697", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "cee4983b40de8ee1c92b476a4accd3c92a195058b3823b4b2174a38ce0bf9697", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "46af9e30c2b575e509ce61d0387d04fe9c103fb97e654f840933fb5f07a06afc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "2ddb4ec97b00f6bd7c1a21649833a48918a7b03499059f0d61aa4be7d119e223", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "d3b19aac11e68a2624caa9feab112dac07200844ee51baa6e87aa56c7f72262f", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "655166100eb58627b2a79c40c8b4e4cdf94099672e36d5d88808e57c0c0cc7b8", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "904baf0ac5b760d07217e0c02d8a8f6695b74cbf196ed43981436aefef18bd9e", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "6a8ab8efddb33e8f3b40eed5ac47fd7dbfef8f4ccf88722eec7a3d68c5f070bc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "6a8ab8efddb33e8f3b40eed5ac47fd7dbfef8f4ccf88722eec7a3d68c5f070bc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "fd11ef15c6eda6c6412b166d7b6f84dd2507b4bd69c11b6ac21495e0131cc8aa", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3c3e002580a41dfcb68afbfd6da328b855f3053cb478a32e99b01fc5f9bdd472", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "148980f9327fb500e3ab0a0d5b14befac443a0a0d77fd81a9a5304ded9311f9f", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "1450634969692973317c0514614a976ce2bf1ddeea05e06c7db71a6bdb81e2a6", + "python/sglang/kernels/ops/quantization/configs/README.md": "62717927306fbf720b6ad618eefa94a4657894711680f57d9ec82aeb3ced816d", + "python/sglang/kernels/ops/quantization/dsv32/__init__.py": "871331116c34886397cbea62e19403cbb8b428353f1efd93723773620bec1cb3", + "python/sglang/kernels/ops/quantization/dsv32/elementwise.py": "d421f877d20799ab5f00fadf550fa33a36fb02bfa62ebf8194700254222d6f8d", + "python/sglang/kernels/ops/quantization/fp8_kernel.py": "bf4d819c35f35e58be94085c081425284de4d1efd640ff4b000219e1bfef1169", + "python/sglang/kernels/ops/quantization/fp8_quantize.py": "7d47a3d63f815af25a31cac61da9e108d58933f7a07339695e8e6eee3bccd3ef", + "python/sglang/kernels/ops/quantization/fp8_utils.py": "98d78ce79860f027c0b5989de2aff153529e28258d53bb6f4f6e32f51b308549", + "python/sglang/kernels/ops/quantization/gptq_marlin.py": "e1be46383797db3fc4235bc18ac43d54e696ae1a6be2c6240921dbba6d2f9641", + "python/sglang/kernels/ops/quantization/gptq_marlin_repack.py": "c128316664f70a631d2a0a88a6d0ebc1e4ee435114425914bb69bb1c89f30ca7", + "python/sglang/kernels/ops/quantization/hadamard.py": "bf8a100d8e1d75b542aeb3ef74c109d3170b6a0ddfa4697976d05e7714460330", + "python/sglang/kernels/ops/quantization/int8_kernel.py": "601e0fd6668af8d12d6e192e653112fec890745cd5fd40521be6b38bf290d856", + "python/sglang/kernels/ops/quantization/minimax_quant_ue8m0.py": "2e21e5a4dedac4aac89813175d3b6ace8379c74d822603d4ad5bbe5b6ae52700", + "python/sglang/kernels/ops/quantization/mxfp8_amd_gfx95.py": "a80677e9863df4f7d9ad35dccdad414488d7eaa53e81c7b35fefc3f8cbd66baa", + "python/sglang/kernels/ops/quantization/mxfp8_interleave_sf.py": "69601b1e025f5b4efac2004ad73ea5a85ee424ad916d958553f0cf6cae116dbd", + "python/sglang/kernels/ops/quantization/mxfp8_quant.py": "9c6c81711dcb6833fd12f8f2e86ff4728b5b3e97ed2862273c5eb4833d775892", + "python/sglang/kernels/ops/quantization/nvfp4_gemm_swiglu_nvfp4_quant.py": "aa8129b1cf1489d988f45658a730e9f593d20eec6d7e8e2df936efcd28658fea", + "python/sglang/kernels/ops/quantization/per_tensor_quant_fp8.py": "7fc8f52c4802eb4d33840e14e4261bb7baf45bbda336bbd861726a7b62ac9f27", + "python/sglang/kernels/ops/quantization/per_token_group_quant.py": "e06b15269ef3d75f6a85ab7a3268ece5624572e4fc95cfb0ff2ba26442432f54", + "python/sglang/kernels/ops/quantization/per_token_group_quant_8bit_v2.py": "c93f3059787d5d39d70fbe6affd28b1fa8286e2a68ead5c8becfe0004b0d14bc", + "python/sglang/kernels/ops/quantization/per_token_quant_fp8.py": "8f9ba0c5036d805eacbbb16cd4840bae035137be0fdbbb032873f291d1b510cc", + "python/sglang/kernels/ops/qwen4_ple.py": "9aad781e87bdc3be74dfc29cf9d1f5286456c550846856f6d7d0ca689a78ea7f", + "python/sglang/kernels/ops/sampling/__init__.py": "1c7676b6b0247bdce410ef682e7efcaf3409558d53ddf5383b3bf11fed55ef75", + "python/sglang/kernels/ops/sampling/murmur_hash.py": "0f1907f9b4665641166d1cbe94d392f1145eb468493fe66b44d515c394858bd6", + "python/sglang/kernels/ops/sampling/renorm_triton.py": "4c1a02b67c4aa518de72c27c495678e83c32178ecc8cc877c72dbcb34ba2232e", + "python/sglang/kernels/ops/sampling/top_p_renorm_triton.py": "ca04085e3a572a3f7ed41dd566f8cb3d3fd5f0eac03ad31ad0f101539701126b", + "python/sglang/kernels/ops/speculative/__init__.py": "a383c49aba6a5345e3879aeae9b962c5e66a583d37b32fd8b9a19784d7e19d4b", + "python/sglang/kernels/ops/speculative/cache_locs.py": "d1ae7029c4591ba79f9cc62c42cb2aaea896ca32bd918ce046063515f3ee0e65", + "python/sglang/kernels/ops/speculative/dflash.py": "f4cc3f2539a9ae6b1db0c0704f88bff557afc88f6bf25269e33ed13d574373b5", + "python/sglang/kernels/ops/speculative/dspark/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/ops/speculative/dspark/dispatch.py": "8baa09b85ad97aae209b55f40271bdd4168a2b889247dd5aaa6a7dd1e0d1772d", + "python/sglang/kernels/ops/speculative/dspark/dspark_accept.py": "184dec7ed90d64840a4f9ff3ffd583ce9ea4c50ed1bb676d1e8b1157fd207381", + "python/sglang/kernels/ops/speculative/dspark/dspark_attn_metadata.py": "9718b4ebb5934bf3eefe57ea7ae6df888d39cd1d8894db11a2b46253513f7a22", + "python/sglang/kernels/ops/speculative/dspark/dspark_draft_model.py": "c917b63f5754569288002757f5d65980de3325460712112a4af1d10dedd260c0", + "python/sglang/kernels/ops/speculative/dspark/dspark_schedule.py": "420478eac029ecff9a8914b7df4d7db2fea4f61be9dbafa1cf34b1b890292c06", + "python/sglang/kernels/ops/speculative/dspark/dspark_verify_window.py": "10266a2d86af22a42e6020a0753efe40123789f26093661ac2bb3de92387ac20", + "python/sglang/kernels/ops/speculative/dspark/fused_kv_write.py": "f48e2481327f8e5355ad2dee4c9b6d40fb4802e9e05b13d21e722f072f6a5cc3", + "python/sglang/kernels/ops/speculative/eagle.py": "b96e3d0538f52d73b32a7f29f649cfb52a88c8a74110a55bd5128524374c404c", + "python/sglang/kernels/ops/speculative/fused_kv_materialize.py": "b8dd985b7764d3212e9e3045b2daa5be0c481215346ab28f2513f8201e9cbfeb", + "python/sglang/kernels/ops/speculative/gather_spec_extras.py": "5b4e41ce94ef81db8a6a80cdbfbbf379675288a9f922a74a2cb4ac2b9f8c35e9", + "python/sglang/kernels/ops/speculative/multi_layer_eagle.py": "f43949449eef3361780bdf3b0b8d258fb6cbfe384936871b442dc90868cb6544", + "python/sglang/kernels/ops/speculative/ngram_corpus.py": "61848bb43c31193f8911dcf9cfda9e8e4871c63283d1edd96cbd0a219fd4f112", + "python/sglang/kernels/ops/speculative/ngram_embedding.py": "1bb015b137476f5fb1707da971026a9a17634a0c4469d9257aaf5b4e9008dfa0", + "python/sglang/kernels/ops/speculative/ragged_verify_kernels.py": "9d004ba087b74550b471b2fb0946c3edea8cc94f692dd7b4be6db4ce06ea6c45", + "python/sglang/kernels/ops/speculative/reject_sampling.py": "c1e1b66aba3f0a0668fab32ae46152d5fd36a23defdfe5a6b27a6380e227e1a3", + "python/sglang/kernels/ops/speculative/spec_tree.py": "8b3dde69be73a7982cd8ea8bb8b39dc3b39b412bcb6fce6f5fa4ae8cc6418f52", + "python/sglang/kernels/ops/speculative/topk1.py": "2dc54fd39c34a6aaaf46fbbc5c3737c57bf70c42f036f33490460a03b6034533", + "python/sglang/kernels/registry.py": "9d9614b4a54647fa40c66d6baf962b4a105c653239075542ce2482fcded01cea", + "python/sglang/kernels/selector.py": "e13283e97d664d9ad70422c0b0b4c27c046dd934332d40bb5610887018741504", + "python/sglang/kernels/spec.py": "3ac2cbe41ad81f147d4be6b13555f50dabcbc394a56ac60bf5b2dff63a1f6d83", + "python/sglang/lang/api.py": "15edcee0a734716e4d8986ad3a33403aeb16c9f364ce4b93d2430e85a5db0af8", + "python/sglang/lang/backend/anthropic.py": "a975aaa85964d3e9c2eb64027182118cb4dce001eb7532a997b842783cd1394b", + "python/sglang/lang/backend/base_backend.py": "b44bad182539b678b5c4696b223015bc0f5a7e5241b7676e2ab203cea69b2567", + "python/sglang/lang/backend/crusoe.py": "c653bcc66d14be9c1d508a5d1aa16ac0c3693e984ddc007d8798607ba8351549", + "python/sglang/lang/backend/litellm.py": "ba098beec7d4c6450755b1edc0dcc781d40011de140a33506e816e13729385c6", + "python/sglang/lang/backend/openai.py": "605b3ba420caebf0e86268d36bebe00d575a784e0f62bec4fac202d6aeef027b", + "python/sglang/lang/backend/runtime_endpoint.py": "82d37c4e9a07cefc0d7afb2e7780ef5ad8973cebd8227da57e9b9ff3695516bc", + "python/sglang/lang/backend/vertexai.py": "833d2e358c816fcf236cf633e99209efbe1f79fadc6ee55da0adf76e98546692", + "python/sglang/lang/chat_template.py": "d91a4548101b581828c3e7b0517360a9a42e06d8295760972200147bb51c6a19", + "python/sglang/lang/choices.py": "f96d43570f4df59962569be65abcc85c6e1cb3001a87c78c42b1d6ce44b70fca", + "python/sglang/lang/interpreter.py": "043cb4a126eeb75cae6ae1801a2b9f0fe516d6488efff53f7ca3e4023f4da6f9", + "python/sglang/lang/ir.py": "2b153e4cc92d90e4f7a57a9fe49cd405c248e0f63738b9c47e0509634eb6dbb3", + "python/sglang/lang/tracer.py": "963068f55674cd5686c33364df6ab0db569cca8eb4374523223a816d3e5ad562", + "python/sglang/launch_server.py": "9a54ec8ad199766518c519b6b98ea6170ad8ec157029eed4bb3a49431b86a540", + "python/sglang/multimodal_gen/.claude/CLAUDE.md": "3da0db1401eef176fe5e50189b6af0f894be536d8caddc5e01a11591a12c320e", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-add-model/SKILL.md": "234fab7222e82bb86b0953f26122bd8c16b3a07c91000f7bf74b5c79b236f985", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-add-model/references/testing-and-accuracy.md": "33b247b92654aa65517116c6551ee78907dce01ce830aa8acb27b023ef0da80b", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/SKILL.md": "45f542a134262717bf5725bed165e207e16e3cbefbd0e61a1118422c5f847d97", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/benchmark-and-profile.md": "34653767d8097b2ce6cafc721c53b7b99a64cfa70ba6d89305e3e0922375689f", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/existing-fast-paths.md": "fccf0458844c5b763879d19e4ee14f89d0276abcf37ee9feccdf0d6617dfffa2", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/scripts/bench_diffusion_denoise.py": "a9599c3bede9ef00b6be0466cc1a05a1b2945b119db05276478bfbb7da97e1fd", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/scripts/diffusion_skill_env.py": "6e33eceb3f170aec98937c63a7815d8132c0fc3565b20f5a6dee4ed5a8e3f050", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-modelopt-quant/SKILL.md": "d69bf54195574ff5fa2ad5f2f8c3b16dc0c9f17ca0f43796877e484f5a7c8092", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-performance/SKILL.md": "856426d2ca69413f10d4b704aedb9e33d88450aa753b6882263d5cbcb30d3846", + "python/sglang/multimodal_gen/README.md": "0a3cbac65031be3e1a0faf19f4c55ea8365ba13d159efc3dad1578546bf990cf", + "python/sglang/multimodal_gen/__init__.py": "a97a11a1ed866e58e1f18be0e697e07b97baac4a02aae38cf855b9308708aa37", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/README.md": "ea28cf5d4e9ec20c3b00abf731d1564f762ea41c2938ba7fa52e766c1574c1f1", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/__init__.py": "d559ddb65041458385e826de59b213d6508d0129b2cb3ac7be8a8e571d18bb7a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/__init__.py": "8cfe466edc4c988edf29e63b24c9bd32b3a9eeae33a3c0b982448df1c718656a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/generator.py": "5d6332833095f5822238b9265df5f19dfd7a2b47643cfd08ffd0c42824b1a2fc", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/model_patcher.py": "8744ad46bf889f92398d872cee25a6600151f25c380c30c94d6b78d587a71b0e", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/server_api.py": "ce31460c870b5a10cf69510081e3c63dc16717219002b43a1dc3759107f49250", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/__init__.py": "d43d7b1097c2657e6f65d20d8e60deee98428aef48c34dae19feabf90e4c6457", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/base.py": "e1ebffa3b2584d3a9498491ade0cfbded3933832910ac22f6f1224c1f7d517c3", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/flux.py": "5dd565803807e4db602d03fd4171491e2a7d80a0b76d01a819c63e7ff1da2dae", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/qwen_image.py": "bb28bc708a7d7dfec124b4c3783d9f1beb268b531b9b26cbfe731a6c93f7807c", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/zimage.py": "670252d402274c0f90887ac97152ff4bea5d086069903d66d106dda3fee4792c", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/nodes.py": "f58804c6daafc726b97fadcfbe5a32fdd2063fc0ab67021fce1f7e9f51b2ad91", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/README.md": "579b98f08cc508a3b111027470b9e1698dae7e63cf316cb08c7ee96d50b9735b", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/__init__.py": "2b9cadc14fc06788a3c041eb674898f0329fa173ee242a7bac748504c9f7a513", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_flux_pipeline.py": "f9df682faab73350ca77e714cdc2504aabeb82ecc936ecd9d2fcfa87660667b9", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_edit_pipeline.py": "9843dd2905e60d4510d056caaebc3e95e99ca02f2b9a49d8ff4c67809f35275a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_pipeline.py": "7ba2f1139ad2a7391d60c4f73ce95c0ea3702dd355e525214df85f08e5aff139", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_zimage_pipeline.py": "5ddf814b78fe683dcbf77bd1f286c4ef29df974f59d496f2ddb63f81e1c6b1bb", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/utils.py": "18ccb69ba09c25f2f5d1704157b6a8023ab177fbdf5c746a198b59e2d7d185f2", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/flux_sgld_sp.json": "a32697dba5a49820bd4816174b25a3eee45a1acdc8d95db5f115513abc5c403a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/qwen_image_sgld.json": "bab2400001f92d01f4fcd331a491d0029e68023ef37bea118e84e410425ed77f", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/sgld_image2video.json": "e8d532a567959ec2f9310426a6a26f4dd71e3f6b569a63d5bbdb55062b91e842", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/sgld_text2img.json": "8dceff5513a380fb79586fb88c319b8c385f1f1ed5943e41097c57bea861fd4c", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/z-image_sgld.json": "67deca18066b0d71576a5865b340ff116201cb4eea67bb8b10bb67420983b927", + "python/sglang/multimodal_gen/apps/realtime_webui/README.md": "c2acc71067182e70792fc607d6d4c1a62b01de8fcf044b28a30c453c52270a5f", + "python/sglang/multimodal_gen/apps/realtime_webui/app.js": "6e654cd3620e2524af7c4275f1e653a19069d372ed210ac367101f0a11b6fb1b", + "python/sglang/multimodal_gen/apps/realtime_webui/decoder_worker.js": "7d2655224ee3e24fb2347ef27214bedc7cf16bba60e8621aff05549055a06cdf", + "python/sglang/multimodal_gen/apps/realtime_webui/index.html": "8161da333a0e0889db51e2c050a7bf9b3c9a7767c6ca2c153af73bcb18becdbc", + "python/sglang/multimodal_gen/apps/realtime_webui/playback_controller.js": "3e01586ef955fcd35fb10969ade00825ed5756d9b1f95a2b82b00aa32ac62e0e", + "python/sglang/multimodal_gen/apps/realtime_webui/playback_controller_test.js": "cc5b19e9aa5548afb9268e9d154f4fa44153531994aad02e8560065e8788a022", + "python/sglang/multimodal_gen/apps/realtime_webui/styles.css": "179ec7d17cd189119c2180b7e0c78e7dba2b8aad65632cc5b4765958d294b39f", + "python/sglang/multimodal_gen/apps/webui/README.md": "7cb942ce7ab99a4d4c8003229acea6b600ebc46060d7303e8dc249190dab3cc4", + "python/sglang/multimodal_gen/apps/webui/__init__.py": "1f081fe4d4446bea793d8df2b829704a545ec7ed315a6411b4190ff834bdac29", + "python/sglang/multimodal_gen/apps/webui/main.py": "c39733d00b9c2a648fe47bef15cf6d78aa196e9aaa2b8dce8329b7f639589568", + "python/sglang/multimodal_gen/benchmarks/bench_offline_throughput.py": "a4c3e077312ed5c0495e7b0f2753f68234efa365dfe8641c93674ea2146d93e9", + "python/sglang/multimodal_gen/benchmarks/bench_pi05_openpi.py": "b175c2d7465220c88ea51a96f00bc2ec2b62b5568d3149f6a20b0c8d7d284ba0", + "python/sglang/multimodal_gen/benchmarks/bench_serving.py": "e934cf27af6e551fefeadf51143d8eb79a6d7446aaeaa106017b9e0e043a40b7", + "python/sglang/multimodal_gen/benchmarks/compare_perf.py": "0bd7da189b5ba7dcb84f8d18fbfff7d3a47b3fee0ec022147d0542d39239a14a", + "python/sglang/multimodal_gen/benchmarks/datasets.py": "1897ad432e7a48172d2b1464c337acc7ea1812015c171527a271ca6cc3c2bbf7", + "python/sglang/multimodal_gen/benchmarks/request_manifest.py": "14d4bfe40e878787c52e70020320965f3176d74552eb0ed8ca71194d8a7d0b60", + "python/sglang/multimodal_gen/configs/__init__.py": "2826d8dd051f9024e382088f3d1508a841881e92f9979fcfc8176479610ec70e", + "python/sglang/multimodal_gen/configs/backend/vmoba/wan_1.3B_77_448_832.json": "5c9c6a807a0943e169ca1595b302c92fa17266f3ed07a71ca565b83701f3cdce", + "python/sglang/multimodal_gen/configs/backend/vmoba/wan_1.3B_77_480_832.json": "ccb9da0f5da26aedc6a0f77394b4d4d5e4e8575d214ab4d3a2b7b2c070d90b8c", + "python/sglang/multimodal_gen/configs/models/__init__.py": "cb5d104fbae96c0d9e62fd62e53938fb666c8d21eceb6dd56839c6ac8820bdda", + "python/sglang/multimodal_gen/configs/models/adapter/base.py": "fdc068bb5ce39c0ba4a265d4b565a38e2fb0fae53de4ff4493e113f4f61c5ca7", + "python/sglang/multimodal_gen/configs/models/adapter/ltx_2_connector.py": "7c824ee702a3f023da47e5be40c9063e05c9e0aa691f56bcd455b7b64ab3ab37", + "python/sglang/multimodal_gen/configs/models/adapter/ltx_2_duration_head.py": "29d115306458b08b4a8c30f3982fac43dd04f1f5a58798ac81203b0bab6f606e", + "python/sglang/multimodal_gen/configs/models/base.py": "78506d1723cf8b6fc5c34ab8b3df228ec7a9cf4f8f878520c0d6addab5fc859f", + "python/sglang/multimodal_gen/configs/models/bridges/__init__.py": "5f2daa21e492c411fc514553b5e2b7afe9bfa1b1f3748b72e083322308ee9455", + "python/sglang/multimodal_gen/configs/models/bridges/mova_dual_tower.py": "5952b3f122ce18aaa12ebb73a51e04697e1eb832e0db202a285eb14371763b33", + "python/sglang/multimodal_gen/configs/models/decoders/__init__.py": "e86ec17d67a947d20f77d9e24d3fdf15271d6231de81c60a6ac56939a467ea28", + "python/sglang/multimodal_gen/configs/models/decoders/ltx_2_5_diffusion_decoder.py": "16e1dc5b55c95c49e1c9001136c41b0719ad16721219c3d25865c42920797646", + "python/sglang/multimodal_gen/configs/models/dits/__init__.py": "f5dab49623982c6b0a1d089922ba23f2098df59cc97d88ae390b0ddcf5a2fbda", + "python/sglang/multimodal_gen/configs/models/dits/base.py": "94db17fce1f4801fbcdf6733ce49caec5db4d2133ad84b9ecdc92b0b7f1e934e", + "python/sglang/multimodal_gen/configs/models/dits/cosmos3video.py": "d32e65a40bccbe48add895843496d076c04cb3898225ae09f9059e80393892d8", + "python/sglang/multimodal_gen/configs/models/dits/ernie_image.py": "cc10dccfeffaa9a77200aeeeca15d1057e59e1cc2adc20ed047f5b7d0f391fbe", + "python/sglang/multimodal_gen/configs/models/dits/flux.py": "0a6de167dc42c36d8d48ff448407d8e9a8df6fb7578b743a8ec38e62f4bea0eb", + "python/sglang/multimodal_gen/configs/models/dits/glmimage.py": "3daa2ae842980b184c873882de3d2ae47ca6cb6ce63e57b2225a56b2aeb85a31", + "python/sglang/multimodal_gen/configs/models/dits/helios.py": "46642a6f6d63d2d7f574406ef2599825b2db39be4a0dc7dfcaf7652d33ecf51c", + "python/sglang/multimodal_gen/configs/models/dits/hunyuan3d.py": "b438cc0fdd229821f77d388fe5d11587e129bbe438a77b250801590c7e063ea2", + "python/sglang/multimodal_gen/configs/models/dits/hunyuanvideo.py": "e32ca1339b075d4df96d48be961817b35f613d106666b1087a3bceaa20a9339e", + "python/sglang/multimodal_gen/configs/models/dits/ideogram.py": "fca2a4b7ba50eeb11abb9b5db2d3f4415eac154ec837bf607915eea3d2a27735", + "python/sglang/multimodal_gen/configs/models/dits/joy_echo.py": "ad3243260a1df4dfcb63f9195133d6605b275f7894819cac5d08a0524de63ee4", + "python/sglang/multimodal_gen/configs/models/dits/joy_image.py": "3236d64d8bd1cee09068e7318ef41c4903fc8012d93a6387504d9eb335f45605", + "python/sglang/multimodal_gen/configs/models/dits/krea2.py": "4da56df4f83573b459ca1ae10892a1a105af4c0e64c912c5f0a40ca11a769150", + "python/sglang/multimodal_gen/configs/models/dits/lingbot_video_moe.py": "219a5a9db3ba7786c7a90fb83c0f37bfb8db167f5a76b56f2eda026511b6cf08", + "python/sglang/multimodal_gen/configs/models/dits/lingbot_world.py": "ffdc1d327df385b1daf8653c621b3e192de25bfa96c9356b124a43b218ae46b1", + "python/sglang/multimodal_gen/configs/models/dits/longcat_image.py": "a461a25403b46200127e620809f97450be5522b9cb50d16134635371db1731cd", + "python/sglang/multimodal_gen/configs/models/dits/longlive2.py": "6b0f2ece41cf7ef0c8ce92e7a3300fd89d881b06053bec5bfdee1c39dda250ef", + "python/sglang/multimodal_gen/configs/models/dits/ltx_2.py": "70c3319ad2e1ce026f3ff02e8e4b5cce58d96b1e2190e33a461d031517ebc333", + "python/sglang/multimodal_gen/configs/models/dits/ltx_2_5.py": "7008178dc37431d31f06eea942e196d5d0667b7783f448e75a849d8c814dce71", + "python/sglang/multimodal_gen/configs/models/dits/minimax_h3.py": "8a239ed923abf82d577c220896d28b42c01f6aa7514a8dc2dd4cd2db4afd0d48", + "python/sglang/multimodal_gen/configs/models/dits/mova_audio.py": "7ee8ba0eef9083fd49b21136c7cd378431549b4e43bdee034e271d0ddf9a0594", + "python/sglang/multimodal_gen/configs/models/dits/mova_video.py": "0a5a9809dbd9c6981c1b195cf62915ef43ce14450d6f5baa79856986c994d871", + "python/sglang/multimodal_gen/configs/models/dits/qwenimage.py": "14da21d839495ceb9ec028386a2573d48995331f6289cf2ec3950183ada3cb32", + "python/sglang/multimodal_gen/configs/models/dits/sana.py": "d4d67b037d1ad81856143d2f641c3e47bef55d7c06de183d8ea014f198f72310", + "python/sglang/multimodal_gen/configs/models/dits/sana_video.py": "f42763aa57df5eef983adb221259e773f9736d6ba2b266643bcc28f1f5f29280", + "python/sglang/multimodal_gen/configs/models/dits/sana_wm.py": "97f3e28b2659d5eaab3954dc7601d274eb01e88868d0722ccd7bcc16e48e156b", + "python/sglang/multimodal_gen/configs/models/dits/sana_wm_refiner.py": "301ada1b905f745c13fe0717c7855a7b5e1b428a791e6a7d817c77b34be7d51a", + "python/sglang/multimodal_gen/configs/models/dits/stablediffusion3.py": "3d290e5515cddf0d40824224bf624be446d81f02c76c4c78c631da8ea66b0904", + "python/sglang/multimodal_gen/configs/models/dits/wanvideo.py": "e2703b8edad216852365e7dab09fc65d099078182806a97cf66bb7ca7d7a6fd6", + "python/sglang/multimodal_gen/configs/models/dits/zimage.py": "1ce4ec3bcc47e4f78e8e50ff5b5ff079c0ba0d9214f2721ebd80e424f487f8fe", + "python/sglang/multimodal_gen/configs/models/encoders/__init__.py": "982dd2d1dbbea63217e4dab5d4d806a7d473e86ca2efdba27fa1783ea8249d28", + "python/sglang/multimodal_gen/configs/models/encoders/base.py": "0f5e4b4ad6406c4649fa02487cd639a8d18728dd01c8d21436432591d6f491df", + "python/sglang/multimodal_gen/configs/models/encoders/clip.py": "95dd43242f1bbd8a3d4eee62dde848ff2d923ce2296ced6415772e1bc5c68c7b", + "python/sglang/multimodal_gen/configs/models/encoders/flux_2.py": "4c1e39bfc899f56a5dbc0c8faef7249b6d5f7f209a3fb9298096dbf07a51aeec", + "python/sglang/multimodal_gen/configs/models/encoders/gemma2.py": "15334d16485d0d16ccd3ad5d9ac7a22da3603178f9f6883186770f8277145df7", + "python/sglang/multimodal_gen/configs/models/encoders/gemma_3.py": "5f99d876b7ec0709ac731985cd9108f53391a9fec6fba3be06e11194cd9b4fb9", + "python/sglang/multimodal_gen/configs/models/encoders/gemma_4_unified.py": "1a3285adc6feb47ee1ab62acce97391a3608bd58ff8645248965a61d68a59373", + "python/sglang/multimodal_gen/configs/models/encoders/ideogram.py": "f2fb04c48efb5e34172c3d00a173e54b692f1ec20e750d5ca0c7949be7b68701", + "python/sglang/multimodal_gen/configs/models/encoders/llama.py": "860ebb8c5760c40ca774272ce059a0a03dc8a5f56c9453c4220d9b38a72f9425", + "python/sglang/multimodal_gen/configs/models/encoders/minimax_h3_qwen3vl.py": "7ebef8db507047384fa1cc78056afe93f7c4b707ce10693bd435014c8187f1e1", + "python/sglang/multimodal_gen/configs/models/encoders/mistral3.py": "72e05222b7961fe0561853f48cdcacb7bb8235bd93b52e2350cc73ace6286f29", + "python/sglang/multimodal_gen/configs/models/encoders/qwen3.py": "10f848e8643309e3468a856e98ee46a4e79c6c1e465edc2e620e42b5220d6aca", + "python/sglang/multimodal_gen/configs/models/encoders/qwen3vl.py": "b7f74023e4318dfe5857239a18a6ae8e36b3b963433ca1ae54d98ae6c77478de", + "python/sglang/multimodal_gen/configs/models/encoders/qwen_image.py": "c2f8e9ae8ae4dc66fb41dfc386e8194f6337efe197a2e7875778cd65b6af9e8e", + "python/sglang/multimodal_gen/configs/models/encoders/t5.py": "f142658cb9187c9258c1cf725f5a973ae8d51a87aae3e1cb042556c9330f5d9b", + "python/sglang/multimodal_gen/configs/models/fsdp.py": "3ad41ffde2108072950e2f82876504a0255324119a0470f1ff4e525ee1ac2e19", + "python/sglang/multimodal_gen/configs/models/vaes/__init__.py": "e4d897af0fa4c3307b543991d62bb785c88f443e845b7461646d8d47eff4df11", + "python/sglang/multimodal_gen/configs/models/vaes/base.py": "d6c4696a6c18f41126741ecd7c14691d819253bbd74f8d70ac08ae6f5634b452", + "python/sglang/multimodal_gen/configs/models/vaes/dac.py": "fe3b6b8a42cd23362479af6fd36c773ad8fe35e50ebc857b74a85984fb6b4330", + "python/sglang/multimodal_gen/configs/models/vaes/ernie_image.py": "bd8cf7d4b64815b7f963413473b5a1af322d21b5bf9396ad299af0c6eb24bff6", + "python/sglang/multimodal_gen/configs/models/vaes/flux.py": "1c47aaca7238d01792e3b0f3630270e06f2667f0363317159364074ec7a9a65b", + "python/sglang/multimodal_gen/configs/models/vaes/glmimage.py": "a9684072f50457c607ae4a785658ce7a7ed727998c72b2cc237888cd40941310", + "python/sglang/multimodal_gen/configs/models/vaes/hunyuan3d.py": "7381f9e37b1549be676099f850b61ef161f44dbbe6f64478f515879dd611aba4", + "python/sglang/multimodal_gen/configs/models/vaes/hunyuanvae.py": "7c3dde2a48e25664d619e1296af9c2b57f9ad9b6322f7077210bfe92b8efaa3d", + "python/sglang/multimodal_gen/configs/models/vaes/longcat_image.py": "9763882931ad55a71bc37730daab6cf72bcea4bda44289ec3b90663777b93059", + "python/sglang/multimodal_gen/configs/models/vaes/ltx_2_5_video.py": "c549785982f1fe27864c1f835064fea74ec1b6412e14467ca0352de0178667aa", + "python/sglang/multimodal_gen/configs/models/vaes/ltx_audio.py": "480423289d72034b97aa5971ad15639b6da0a595d8a10900da43a8b5cab65bff", + "python/sglang/multimodal_gen/configs/models/vaes/ltx_video.py": "00b942b8d00f2d053335fd90d169402d46d96ec7d7a1464b9c0f81a41542efeb", + "python/sglang/multimodal_gen/configs/models/vaes/minimax_h3_audio.py": "3737e8659a94aafe662c12c937b18e84551f518e2802e13a7914433ef1159c59", + "python/sglang/multimodal_gen/configs/models/vaes/minimax_h3_contract.py": "d0934b2d2acdf692983dd6ca3483ddb17f91c601c3ae07c8442cf7c6b5acc258", + "python/sglang/multimodal_gen/configs/models/vaes/minimax_h3_video.py": "cd28c09c06c77b0d398c3a7f670b306792e68c1b2f785d3177de6a374f33e161", + "python/sglang/multimodal_gen/configs/models/vaes/qwenimage.py": "17c44d212e94d29c94e9460b8918f7cd3d441f2e9a3c8dc147f8c7d77b30262a", + "python/sglang/multimodal_gen/configs/models/vaes/sana.py": "88a2c5396c5fc65b92fa5e024f8991c194b2f26aec9d126bd21417a6f589d7a0", + "python/sglang/multimodal_gen/configs/models/vaes/stable_diffusion.py": "ccda6acb4bea0a6fa821c25875c47787795102fff9a0bf5ab18eb640550b730b", + "python/sglang/multimodal_gen/configs/models/vaes/stablediffusion3.py": "08c64fc004f286459c0809200d2cdcf3c4e14406906fa0f270db134ea462a416", + "python/sglang/multimodal_gen/configs/models/vaes/wanvae.py": "1d1428ec59abfecf598cc54705bc7e338c2487aa485a4b4df1c58926e72837e2", + "python/sglang/multimodal_gen/configs/models/vocoder/__init__.py": "595e115ee5493cd740fc0cf2781ba9f5412733e630e21a3fa38ffdb90a2eba04", + "python/sglang/multimodal_gen/configs/models/vocoder/base.py": "5c017b6fae254c1da159d048b4f02c5b7eb36ca667e2ed446d3b96c892f29db8", + "python/sglang/multimodal_gen/configs/models/vocoder/ltx_vocoder.py": "ffc9f3d932daffe269bc95b0c90ad84bf13dfd1aa17a30b1f9abd28c6f6ca450", + "python/sglang/multimodal_gen/configs/pipeline_configs/__init__.py": "c1b294c5a3c418d8f1b44ecd95c02d975b87608086b3a876786829bdfe6e2591", + "python/sglang/multimodal_gen/configs/pipeline_configs/base.py": "066a8bb949d100f4a6b88e71fcb4892273f253820aa7b974019b60213e6a7bf7", + "python/sglang/multimodal_gen/configs/pipeline_configs/cosmos3.py": "bd7eac43e24677d7963f3e2537c04f8e8af5908336cda8cbe0ba56c935a8e610", + "python/sglang/multimodal_gen/configs/pipeline_configs/diffusers_generic.py": "567c368b86cfc3443ffba89d7d1112f807f8ca69586ca495c1581099da1acf8d", + "python/sglang/multimodal_gen/configs/pipeline_configs/ernie_image.py": "f859f7cc9993d95b269bb11ce1e4beb1c3f642ba27aa2d223273442b97bad247", + "python/sglang/multimodal_gen/configs/pipeline_configs/flux.py": "39c60bef47f5cb69bdfaeb9bc3dd115f7b26f6ee03181980534eb2c8e6f88ab1", + "python/sglang/multimodal_gen/configs/pipeline_configs/flux_finetuned.py": "ddb3dd4822d318c93b22ab6df895aebc34cf12d82168561be28eb87d0d39f9c0", + "python/sglang/multimodal_gen/configs/pipeline_configs/glm_image.py": "d0ad46bfad24b2f784babdf8ee788cea6323ae13a7fa641e36f79c4086ea56c4", + "python/sglang/multimodal_gen/configs/pipeline_configs/helios.py": "094a4544fb2251016ce4b62f68737327a722cf97d7506cf6ba47bd4d64de7f9f", + "python/sglang/multimodal_gen/configs/pipeline_configs/hunyuan.py": "6115724e8e69d65c7b407d3ac6166878eaa38a5e7e97aab9b2f338a8649e053f", + "python/sglang/multimodal_gen/configs/pipeline_configs/hunyuan3d.py": "570408aeca5fe43122cbdb4b1c7feb1dffa6fa1202a6619f564fb863e8eb5a4a", + "python/sglang/multimodal_gen/configs/pipeline_configs/ideogram.py": "0767e6b4ef030413a6adc279b2f6e00d74aba7baf4c86057671e8758d1377454", + "python/sglang/multimodal_gen/configs/pipeline_configs/joy_echo.py": "69b6caf69142b33c8cbe02ca93c456b6308c5bc25218abc785efb8ebf6b7ea4e", + "python/sglang/multimodal_gen/configs/pipeline_configs/joy_image.py": "6d162651eddbb853b5729e8ddf49c24986d995ef127d51ac2ae370a03008e39b", + "python/sglang/multimodal_gen/configs/pipeline_configs/krea2.py": "5da1560111d0e48ce7e0bfeb369f3ba646e3f1be0e5c896d05b0965efcde5b09", + "python/sglang/multimodal_gen/configs/pipeline_configs/lingbot_video_moe.py": "994bb9b7a0ad07b36b595abcbae968ab73b635711ce98a18263ad5ea2627ab49", + "python/sglang/multimodal_gen/configs/pipeline_configs/lingbot_world.py": "5c5a1c79887ca31ccd085379dbb23af1b1710c7fd1017129ce46a84af0000e0b", + "python/sglang/multimodal_gen/configs/pipeline_configs/longcat_image.py": "e3b8ec918b9f2b4a34420f65bc3bc14e0e0cbb2182cd267b074f4fdfa0f766fc", + "python/sglang/multimodal_gen/configs/pipeline_configs/longlive2.py": "ca4a7e2a6ad9866f59ebb8cd4dfc0bfb6e108542154ecd9db1985d9075ca04e4", + "python/sglang/multimodal_gen/configs/pipeline_configs/ltx_2.py": "76b57a82baeb51409f140cb7627e3fb2a9461abe80305dc363662fc0180028b3", + "python/sglang/multimodal_gen/configs/pipeline_configs/ltx_2_5.py": "4fe8f9ba981a668b6809520852f8053ba9412c63ca2b805c861d1817dd99f4ef", + "python/sglang/multimodal_gen/configs/pipeline_configs/minimax_h3.py": "02cd79f1b40abfb21b62bf0f6803ff925d0538671cfc91c3a8b051df329e0791", + "python/sglang/multimodal_gen/configs/pipeline_configs/model_deployment_config.py": "e6abd027ad8e0cdfca40c6d900fddb0dc07a6ca5e0031a7689c7ee5a54528ada", + "python/sglang/multimodal_gen/configs/pipeline_configs/mova.py": "e5b7e3cbd4cb343c2cccc04cb8ed890091aa4861b9183c9426efe0a8ef2197a5", + "python/sglang/multimodal_gen/configs/pipeline_configs/pi05.py": "3a96e0e67fa08540dead457c345abfd4c1c71e06ab27d6ec4a7340bfc3e08e4e", + "python/sglang/multimodal_gen/configs/pipeline_configs/qwen_image.py": "160daa9faf33cd38f17ce596a4e364c470af24b2915a0c16ebb4e83edb898c1e", + "python/sglang/multimodal_gen/configs/pipeline_configs/sana.py": "1b8eae33471d32576570b4fcc131391622aa5cda2742b3533110269fdd08a9ca", + "python/sglang/multimodal_gen/configs/pipeline_configs/sana_video.py": "58206af7c464be639e8c15f39261f465148a05856f69b238cab1c4eac202a5b1", + "python/sglang/multimodal_gen/configs/pipeline_configs/sana_wm.py": "440b9eec0707d38812506e669e79e972269ec4876987b1977cfdb47cabb281a7", + "python/sglang/multimodal_gen/configs/pipeline_configs/stablediffusion3.py": "4bb8f9d781bc7fbbbafee672cfa108b1533e5e451abef5627b7c31d11bf97f31", + "python/sglang/multimodal_gen/configs/pipeline_configs/wan.py": "7b98d3af2d1e5ae0d55763b217792c9a7c439cb06567e7c47f7dc4efd8f0341b", + "python/sglang/multimodal_gen/configs/pipeline_configs/zimage.py": "00c3b09219e95dba90806c918275041ff0a05f50dc7745358fbf946e72f29d20", + "python/sglang/multimodal_gen/configs/post_training/__init__.py": "9af6eaef9cd2746bbc48411f2f1851a8a5c754a54a1a3997d70b21acb65ca66b", + "python/sglang/multimodal_gen/configs/post_training/pipeline_configs/__init__.py": "384b0bb57d8d6e35f2d2cf5c9c91e648525d129c2cad5a3853af3587b5d22569", + "python/sglang/multimodal_gen/configs/post_training/pipeline_configs/qwen_image_rollout_pipeline_mixin.py": "46f0cd5d327e7bfaa4bd45c37e4ce5be9dbbde9e3bfe82ef6e82c00b472164a5", + "python/sglang/multimodal_gen/configs/post_training/pipeline_configs/zimage_rollout_pipeline_mixin.py": "7ce0975d78cb71ee7dcc40078cfe535ee76749375961f4bd7fde50d70e52b13b", + "python/sglang/multimodal_gen/configs/post_training/rl_rollout.py": "549259dd777cac147012d00cb3742553cf0b1e526bc2e45b6ae65b8400c8bd32", + "python/sglang/multimodal_gen/configs/quantization/nunchaku.py": "46d75c6bce484ea14f96aedea78e372c7ac49a21c07f8f6bcb5da606dabe7f2a", + "python/sglang/multimodal_gen/configs/quantization/qvg_kv.py": "dff09aa18af398bc7c820b90fac1409f3792bbe7ad6be76415ba424d469f2291", + "python/sglang/multimodal_gen/configs/sample/__init__.py": "b778b25f520563ab805431511e1843e2565058268811952e1e21dd689eaf5f89", + "python/sglang/multimodal_gen/configs/sample/action.py": "312e619c42f4a7827b1976c790945ecb1b64e032dec7697916f1984ba72d6d5d", + "python/sglang/multimodal_gen/configs/sample/cosmos3.py": "e336b83f7c92738b520e97ea05870701075e5e92248deec5b00a90904aa2ddf3", + "python/sglang/multimodal_gen/configs/sample/diffusers_generic.py": "7c739ba3f8885dd79142937df6023f4210eed2cf6a60ade68062eb517b3ff129", + "python/sglang/multimodal_gen/configs/sample/ernie_image.py": "0024b04ba1443b06d10376f794af681c880bf035cf6ae4d341f2904fe3a1dd0e", + "python/sglang/multimodal_gen/configs/sample/flux.py": "442dc7509cf5bc555873f5b31a8396bbc3cc44ab889fd498332224d8fa28113c", + "python/sglang/multimodal_gen/configs/sample/glmimage.py": "877bd695ee7245b829b540fa2c3fa326de7e891bc14cf022b7e2d47b638f20fd", + "python/sglang/multimodal_gen/configs/sample/helios.py": "8833aeb5318dbc983ec8860138b39d9c438a96f8bbaefb2402c306b97cf721b1", + "python/sglang/multimodal_gen/configs/sample/hunyuan.py": "1cbfff666fd539a55c3d21a2f91c7f81a688b34d03ecf698a080ec11d304f3bb", + "python/sglang/multimodal_gen/configs/sample/hunyuan3d.py": "a0e25f004514dae1a3ed0088c2c223a2ee893f2968c3757cbbb2f7b9f5c47920", + "python/sglang/multimodal_gen/configs/sample/ideogram.py": "6dd82d4d64a1de984bc3c10e2fed512f0490bb045f860c54e44795f94527ae2e", + "python/sglang/multimodal_gen/configs/sample/joy_echo.py": "57162970cc3cbe6c3c763cc20087eeb3c06038a4ea7652d16d15a3f97681c466", + "python/sglang/multimodal_gen/configs/sample/joy_image.py": "b61ace5aa2d288ef0b640ae2ec2acddbb497695ab13f86375542d41ee498e11f", + "python/sglang/multimodal_gen/configs/sample/krea2.py": "be892859626e7fa990fb00b94322add56e1eead791e8f4bfb8b266765f20d148", + "python/sglang/multimodal_gen/configs/sample/lingbot_video_moe.py": "70a071406105599dcb355ec82bc3bfe6c71edf2687bb91ac760877682716e276", + "python/sglang/multimodal_gen/configs/sample/lingbot_world.py": "5179822eac4a52098c168fe09a83afce311d506b9b78a45dc071b082ab7b978c", + "python/sglang/multimodal_gen/configs/sample/longcat_image.py": "3dcd05441fb21ce755081b79c190c750078ab194b1cf1779e57d7d42e72ffd24", + "python/sglang/multimodal_gen/configs/sample/longlive2.py": "c506485d0f0cb8f15e63a20d4896f6bc6f45e031b3922cc7d0c4a91d23e401eb", + "python/sglang/multimodal_gen/configs/sample/ltx_2.py": "99c5a0f17b090d77b2c6ba384c132bdd2a8a845c370c48b4a6b2a7fa72ac359d", + "python/sglang/multimodal_gen/configs/sample/ltx_2_5.py": "fcc768ce71f87c55e8a62ccd229863faa16122053a46dabf0e56e1b5f63af64c", + "python/sglang/multimodal_gen/configs/sample/minimax_h3.py": "18af182ad5f8afa61f179d17df9f9b5114a8fce54a4f2f9ea30cc388924312ae", + "python/sglang/multimodal_gen/configs/sample/mova.py": "1c3feae81b4b4e00a94844657967222b95c7d01819520b912e1afb712d4f0014", + "python/sglang/multimodal_gen/configs/sample/pi05.py": "5d43e92d41f54254482506620822d19950e8645f5f503f31a2c725184bb6d543", + "python/sglang/multimodal_gen/configs/sample/qwenimage.py": "ea8444691bde59d12f1a6d43997e9951618c56521741144b92d32cdc01474d96", + "python/sglang/multimodal_gen/configs/sample/sampling_params.py": "6884e0e62f02f66936a8ffa2937be94af2b97b32943f56b8ed1219a634da1d6d", + "python/sglang/multimodal_gen/configs/sample/sana.py": "f85ffe657605d8bebf9598b33cb05589b7304923db0a37fda65462006baf4ebd", + "python/sglang/multimodal_gen/configs/sample/sana_video.py": "2ddb49fccd4ff4e1dceb15f0a2d70d25e7d26d17598db480c901bc80024eac4e", + "python/sglang/multimodal_gen/configs/sample/sana_wm.py": "8181be4bcf14e4f7b1423ae681678409d066356d7deaa3c2ea08127cb53c579a", + "python/sglang/multimodal_gen/configs/sample/spectrum.py": "18cd0b88b5b5a7fe1f068973ba22a530c7810e4e8d1f79ea36dac3443ada0139", + "python/sglang/multimodal_gen/configs/sample/stablediffusion3.py": "a414cde6f8779e90d1828b3a75446550f9ef604f78d64d8721fdfbb1b085fbe5", + "python/sglang/multimodal_gen/configs/sample/teacache.py": "f0a19433a5f11c7d999651a1d09663d6bbbe840e7a654aeeca87fd12b262794e", + "python/sglang/multimodal_gen/configs/sample/wan.py": "85302beb7475c408238792ff52fdfc672121e63d7e17765f12d0063a82b82e27", + "python/sglang/multimodal_gen/configs/sample/zimage.py": "d6ed0e9dbd2c69e3397fd19968b5c974deb2132c6418fb6d443c91c1de21a772", + "python/sglang/multimodal_gen/configs/utils.py": "7600c200fd9da5f922009f9f1b7787f9d3bc47857ce2a1a96445e2f872d6b27d", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/README.md": "8c55e15fcec89519413672672d58175a172ca8e94786926b0ca433671a09ef8b", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/setup.py": "7cb78abf9ca9acf25098d7a460b3367e6886fec303fbd9dd950e5f0c5b7a6f83", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/tests/test_vmoba_attn.py": "7a52823f5176a6f0961b40e0cc8fc226adc8098d7706a64bea938efcb9733e50", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/vmoba/__init__.py": "30371a641040376a6189b06621a789767c059ec9df7ec1f2d4dfb12a6dc9c1b3", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/vmoba/vmoba.py": "cd227e62840beb31d4d1ebf507c81b8c33a54e20c1a1699b7fa8e5dcf8000a71", + "python/sglang/multimodal_gen/envs.py": "f71bbe54d90f8d07e8d4131f01a05b91a8a6d2cb9224373bf1d937184b10708c", + "python/sglang/multimodal_gen/registry.py": "a771a635ad06ad8a11824bc225bdd160ca3b9cba88f69a41e1398eb992d6ce1a", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/__init__.py": "ed9938cb6b128de384c2b176d2fa033e0273bc3eecd6d0d2f1a6a82721b2d99e", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/__init__.py": "e691594a5ce99c7f54e73d0f971623d7f1d2ce3aba2a05da9aa8917833264a9d", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/ideogram.py": "636fa822c85d14bcb59787a0f534ea369915bc68db897dbc9515ca208e32ff4a", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/minimax_h3.py": "ba1e588c1a880f91faae63568bcca3aace973beac3d53d0d9e5abe96ac74ca7e", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/qwen_image.py": "ec4b97f00fc9abf51f0b3dd5b0b66620c2d19672818390ff1e0787e8e54f1084", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/zimage.py": "3a4bda19ac8238b3ffba87b0cde6331d6212d6458e995cd0bb0fc4a46122c130", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/prompt_padding.py": "a25dc551ecb6a063acfe78c5407c5aacd8675eea4bbadd38020162748243120c", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/replay_token.py": "a369b0fd300c533037ea85471488ae86d6ab6933204e62b6e62f060e046a025e", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/runner.py": "1a02770b3a0e98c8b3b61d56e2fc616e985f7669bf1d9861cf317a92dbccba6e", + "python/sglang/multimodal_gen/runtime/cache/__init__.py": "0593d7834935ab33a73567fdb33dd0d39d4eb1b2f34ad9dad698c08a6890f252", + "python/sglang/multimodal_gen/runtime/cache/cache_dit_integration.py": "42a68d1cbcd78069590734f895df0c4ddabb805c929c34d3215d91c6bffc5a4a", + "python/sglang/multimodal_gen/runtime/cache/spectrum.py": "913cdbb160a29ed347d926dd134bc578486f5b621c5fb91436cffad4d6d97bdc", + "python/sglang/multimodal_gen/runtime/cache/teacache.py": "786188df7fc2012b074d560fe5cb4c7c3ae4d6edc0ae856e072ba794f0d9e41d", + "python/sglang/multimodal_gen/runtime/disaggregation/__init__.py": "637371500f02c55002eff448b2f32dadc9e0d01e613b6bd2bcd13551611abeba", + "python/sglang/multimodal_gen/runtime/disaggregation/disagg_args.py": "3ff0019ac448754180d7d566549d77427b551177ca753a8c0d491c29438d27d8", + "python/sglang/multimodal_gen/runtime/disaggregation/dispatch_policy.py": "957c7b881f80fe26a8594f97582ea0f97fafc69d8b8406689dda44c2f148ccd2", + "python/sglang/multimodal_gen/runtime/disaggregation/metrics.py": "0d1df4dae44b1815ba2a002a58693fb09f5aba042045cb41652c5aa8ce30aa27", + "python/sglang/multimodal_gen/runtime/disaggregation/orchestrator.py": "95fe507d88b67addf3c9c050fa715cdc5dde8f8a5f38b53d058569a30b76df3f", + "python/sglang/multimodal_gen/runtime/disaggregation/request_state.py": "86dd2c18a08633d96adbaeb24214d5726fd86db3f5f7d0c35966bef062e7188f", + "python/sglang/multimodal_gen/runtime/disaggregation/roles.py": "7c21ef11bb940c6e91d67fcd43ea20837be91130bb4a877f73609f70bb6831c7", + "python/sglang/multimodal_gen/runtime/disaggregation/scheduler_mixin.py": "fe6399204805e6cfc2820cf58d935ae0e9a066ad5157cca4bebe81bfe18b8f29", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/__init__.py": "6deb74a4679590b2b641b8a2b62a6a6fc390af3b608bf0319bba2f0a8aead715", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/allocator.py": "35f6f2c20ab6b83bd5f30f5b9803ae5618a1fcb044352077aab933eefac12093", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/buffer.py": "20ab807cc1fc4f82758370289a7da6e3ea2cef74a6a795799c668519f626d38c", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/codec.py": "fd4df92e4c5dbbb601eefaf25977c274ccd498a85fd28c0538e17effd58a04f7", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/engine.py": "ab6005a8a3242764d01cb17f238982e5c70e78b76f1f6ba28ae67e68590c2f90", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/manager.py": "97c74bdfd98ee84dd1bcb7ac9b505b3a137d87838529c9a0dab81c925f998372", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/protocol.py": "ea19ef2ea91b7e411ddde6d46edc0ad2d9e7d1836033ef5b244e794b790d8e4f", + "python/sglang/multimodal_gen/runtime/distributed/__init__.py": "5ef3261028b21da8e68affed24d0c66af68d68b4d65ba66f6a55f995167d0c00", + "python/sglang/multimodal_gen/runtime/distributed/cfg_parallel_utils.py": "722358a14230412a93135f00dc013c0560d93afadb03c732a9541feb60ed9499", + "python/sglang/multimodal_gen/runtime/distributed/cfg_policy.py": "a0cf5b16d0dbcc534f5b6487c7a2cfcc17fd1280e37c20e9b50cddad27f36e8c", + "python/sglang/multimodal_gen/runtime/distributed/communication_op.py": "a1d2aad120fb6bcd062f157b53165dd2d363b6318da4efec58fa2ddccab69568", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/base_device_communicator.py": "f3fdc26e0f9722a2662dd43e7f11180ffefd634d90e12b1740b2a9a0d2303f69", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/cpu_communicator.py": "7d1a179969c451e8adb9b2907780f4c2b4fdd18ace8f10d7cdcb129eeba1f66d", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/cuda_communicator.py": "24c6930bc8d15f50354209c71f7dfd4365c89d3d806c138aa49d7a90d220c79e", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/ipc_a2a.py": "cd01f9b81c72ccbbed1c942a4cfc4906f8be1a3dd74e1d52baff5bf0c48fed15", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/pynccl.py": "8cb46b8eee1063af1a0f8eca6d0912e64fcb86583131856863c4b6df96482ad4", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/pynccl_wrapper.py": "0eb4f8a9d5cf935f8126b8edc9ef80069d406ac17f8df491cff1c29a68939bd0", + "python/sglang/multimodal_gen/runtime/distributed/group_coordinator.py": "068cf27a3cb33da6d76b5076e46d3686f63b63453877a8a37d5012f29cd73631", + "python/sglang/multimodal_gen/runtime/distributed/parallel_groups.py": "b33f9e8238660a595e80c5073abcf424b7af2081a1ac9cd694778f23f994cdf7", + "python/sglang/multimodal_gen/runtime/distributed/parallel_state.py": "97692d77e1cb060ea7643eb9ad5342ae3db360010a20d781fcb6b642b3a6d3f5", + "python/sglang/multimodal_gen/runtime/distributed/sp_shard_utils.py": "40cb3fe9936966d020003d316a01bcfdea5f091637d05d2a5bd2af5260234f2b", + "python/sglang/multimodal_gen/runtime/distributed/utils.py": "d38d571a05dc1c83532b2f7942ab07807b3d0f0b7a2839d24ddfed86fe01ec40", + "python/sglang/multimodal_gen/runtime/entrypoints/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/entrypoints/action/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/entrypoints/action/api.py": "d8c16daf739fd895a65086aafba13273424b3e4cd4f5fbdaa83d7c14aa4fa94f", + "python/sglang/multimodal_gen/runtime/entrypoints/action/openpi.py": "bf41537b451d25887007df345a27a2d099be539fdbad302c5d4f89c8d156c994", + "python/sglang/multimodal_gen/runtime/entrypoints/action/protocol.py": "46188a7fdac7ffbf24ae3da4be46faac448f290f7ae2fa90a6389195f695a070", + "python/sglang/multimodal_gen/runtime/entrypoints/action/ws_utils.py": "ce4f1a12e9f5640cf0480d985a8b87b5701cae1c064b32e25b298f2f473b6e70", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/cli_types.py": "ad856b9c58ac35d9b1a6fc3fcd7767618faaff98c310ac8cccba80008b41be49", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/generate.py": "9ab20ab25260882b3128573e14b12f54c0bf53560f08040ed90fad6cf0d573c8", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/main.py": "290966752105570d8b96f3c95245e84510c4ac4ba72443c4e6724f7689eb0456", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/serve.py": "23db35d4bfbf3ad55aed39c4597aa61be1667b16a5b3d73377c86167ce663e9e", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/utils.py": "f1e98ed568eb39aa8d41e077b5092ccc95f49520fc664037ee909bab13ca70a0", + "python/sglang/multimodal_gen/runtime/entrypoints/diffusion_generator.py": "8b4b23bd0420f0f88e7b354daa3a5e20f8d1d5569aacbb97c084645c296e996b", + "python/sglang/multimodal_gen/runtime/entrypoints/http_server.py": "09278b36165f2c7d81b7409b04cc1f1fd13a575af49007206271158a0eb946b2", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/common_api.py": "ff05244c75a516c93b6009ccc06698836d10501e812813177bce3c5eb1ea0eb2", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py": "24dbba5240324a27bf72f3a8e41f980b70b704c7b14da8d9691f886371c15184", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/mesh_api.py": "94a9c8469bc9644835df54a62a47ebb63473ee3880f1719eb5c2427738f686ac", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/protocol.py": "b8ba2aefe78ac6a948cd3a557b771e06cd57fbb35884d476abdbb62492218db5", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/adapters/lingbot_world_realtime_adapter.py": "85124e3287205c3eafb506b096b535360f7afb235c30c96b1a2967126cd106f1", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/adapters/sana_wm_realtime_adapter.py": "be6916085f7b325979e0746c3d23f689f625697dde361bb6218e96e25347fd01", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/generate_session.py": "11346d37d5022742798f4ebdff58a7656765a10dbf2b2f41e3a213c54183e189", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_adapter.py": "55f1ab90571bc336d6a7d3fab679b051a863b0870bf43c0a7961256b1dbf2470", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_output_adapter.py": "9f344bb1e243c41c726a4f4608a06108bf5456d9bcb92a32e84ac6c38226ae98", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_video_api.py": "331d27962a902a72f68ee6b19986b602806c5efc4cdc856b4ebac72891917ffe", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/registry.py": "181c5594ed95f042cd6493810880f39804ff5383c1d673e5f48a382f25468f08", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/timer.py": "5cedf5f6e7f97b0e54baa7122eba13a31ff0bd357046a88c235eb512a7181c08", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/storage.py": "2fd45ef1c008baa9ae0185c65e077525df78e1c5fb155401cefc8022c5b9d471", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/stores.py": "8e290bd34d3e50ad173133926a9007b5930f440faff7eac00573fc88b39f51bc", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py": "78c1f60d5c4a6fb73acf24308586b1e1f95be25c373f6dd00cb4a04509604b46", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py": "446b3616c29a1b155619ff94d8460fedeeeb490a877abd0a0488b13f378d2247", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/io_struct.py": "d62d372fec05931b0c584e51ce2a874413799e53ea4d63d61cca69b6b19e77e3", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/rollout_api.py": "f61f6a43234e29fa985aed7adbb3f6bd81c03b7a6b9367461a9cc707afacf762", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/utils.py": "361613b9ee8ad2bfd25e19ae09f6ded30952d16b5bcd5f87bf2f424eae9210bf", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/weights_api.py": "be183aa4332472ca3a0d128e0b0a31f56b107bc44012ff351962f1462fc35dda", + "python/sglang/multimodal_gen/runtime/entrypoints/utils.py": "04afb89171c1807c301aeba6767efc4a6ec468437d16b8bc2c9337d8f5e3fd41", + "python/sglang/multimodal_gen/runtime/ipc_array.py": "a2c78346bd200520a3d29638a08edf0c6a4338a8b9f396d8c2357ce0004fb5c7", + "python/sglang/multimodal_gen/runtime/launch_server.py": "6c6c7c56a49299d8c6b0e5ce0e9aca59b5aca654d165b9526274dc0c1a1d46bf", + "python/sglang/multimodal_gen/runtime/layers/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/layers/activation.py": "9dc28da8e1c91e5489f4d9b02733e24807b150df1d9002990db9fabedbc0ee69", + "python/sglang/multimodal_gen/runtime/layers/attention/STA_configuration.py": "fded1886b3a0fd838f5bafe9a10aa0e351ec9f7aeaee50894af3c5a017f89a4b", + "python/sglang/multimodal_gen/runtime/layers/attention/__init__.py": "46c51ac1389ad58b4f46217454123de8d3f7ddf43e31c938acdf7a2f657c8833", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/aiter.py": "928da73506dfe0e3c1fa2b8c809206b6b489318e70a9c7fe35ea9365d95f5687", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/aiter_sage.py": "c022df1d60224c845a7c257e913d2e54769022b76f0327b95192285ab5c8fe73", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/ascend_fa.py": "5a61939216e8ad7d52fb0822bd114b224dae5e677acd7327734905916fb418e4", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/attention_backend.py": "12393e6ddc45229d38ceab55ce9a0a17ddfb1e8ca713de14cddf0dc48d6b6f47", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/block_sparse_attn.py": "93ffcbcac2fde37b53e7527cb8debc587e28038869e90045dfbfbf3c662f1dba", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/flash_attn.py": "eaf432dcd08afd649c62976b81802fb3c70fd338a434851a65db13b793b825b3", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/flash_attn_2.py": "38140528f6f6669844a2b746cb007c721f60c0b52df0801e9fe73bf0ade543d8", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/laser_attn.py": "8a13f75f0c27b4e686fba586b49f313da404789ef133b443778928ad53124f4f", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/rain_fusion_attn.py": "8c29c01bb8384ab729070f448b8f4444401aa1bd77b2a6484cbc87cbc7257887", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sage_attn.py": "fb8b9ac4f1b5d0c9f866cbed8f4b5405588899b6bc5a2a707be74215d0bd7bdd", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sage_attn3.py": "ce91c06a4eb6abb7fa027666274b23855c412f8e82721ca4ef4e89aa5c02d294", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sdpa.py": "49afb36bf827dfaf534e3e3b9cbece6e71a1db8b695829ba06bdb619826c35fd", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sliding_tile_attn.py": "e7c5dd336059ada2b7526463593d8989751cc822c600054c98e5136f6abe1ec2", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sol_attn.py": "996102079ecae4df164701a8d08deeaa66452006fb810daa35c8ae2fdda5e517", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sparse_linear_attn.py": "37e757c73e82e3826c919091f51dc7e2021312927c3ce4abcfc77626574cbcaf", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sparse_video_gen_2_attn.py": "4669d65f68ae16436c8969ab5c98ef5374f5d144aae30579c3864f8171690bb4", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/README.md": "6d68705da25541ee699796eff43b4ada400362c98818e4c4c01155014bd8b677", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/__init__.py": "39d2a968dde6bc116d17168f190f11f5666fed502611d099014778742339124b", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/kernels.py": "7b8b2943ed05f13a380aa1c1843973cf3b7c3c7af6d34d6fce74cb7958bf663f", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/router.py": "03330e28e03b059ce08a9d095f0212c1cc04ce11ab52feb220a3b6739add2407", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse_attn.py": "54c2946bbb4ffb37cd2d707b45ba015bbe294f8d675ac45bb792ac286f72c055", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/video_sparse_attn.py": "a6c80e39f2622b2f1f6d01b9267ff14a36c10bf05a8d8f1f0681a6a8ba33c68e", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/vmoba.py": "f3f1037eec6ecdd186df6226fa7e6161b8e6fae3bc3032307da2a70e9d759f6f", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/xpu_backend.py": "d867b65b5c5fc3e63c34cc77a09afe7ae6830f12730cd31021c1566241cfe6d3", + "python/sglang/multimodal_gen/runtime/layers/attention/layer.py": "879b43077a22be735c53ebadd4e9be4e33219f8139d7380c8c50e788ede1d661", + "python/sglang/multimodal_gen/runtime/layers/attention/selector.py": "68f9b6763b8b65c1362cbd2ee7df5f72135050109b31c3dd165a2243d2c98e8a", + "python/sglang/multimodal_gen/runtime/layers/attention/turbo_layer.py": "a603a836ecdb581a83059803f270bfd22ed01829732ff4bc602b1c40b6b6d48e", + "python/sglang/multimodal_gen/runtime/layers/custom_op.py": "9388052a00baf625ffa358c489ce643d9fb49759ba04bcd46845f0cb55580ba0", + "python/sglang/multimodal_gen/runtime/layers/elementwise.py": "c76dc89bcecc70752756ee4d79f6aa64b28b8746098b65e2ec80113f0b583a8d", + "python/sglang/multimodal_gen/runtime/layers/fused_scale_shift_gate.py": "aae43a406f2c2a4488567a94ce6537258541aa96a8d91d6ddf4268f4b39b3f85", + "python/sglang/multimodal_gen/runtime/layers/kvcache/__init__.py": "33d037000a3b740f0573069e6fae5b713b2334185604f5a3ce430c1946c5a8d7", + "python/sglang/multimodal_gen/runtime/layers/kvcache/causal_attention_cache.py": "628728f98c5ad29f85d5ad29af706d092d21930aafc026599124c33efe9452f5", + "python/sglang/multimodal_gen/runtime/layers/kvcache/qvg_packed_cache.py": "cc41601d83644893f0413156d6f7478ab664283ad4fa5cb09945664e22e313e2", + "python/sglang/multimodal_gen/runtime/layers/layernorm.py": "42a000bb3a098d32b106d04977c5fc513d0a1f52d5f131fcc793774280ed7362", + "python/sglang/multimodal_gen/runtime/layers/linear.py": "a93ff5a04c74ffe1acacbd3438273044764f81ff53e41081cf5134c50b8fc0dc", + "python/sglang/multimodal_gen/runtime/layers/lora/linear.py": "4864a0a17d3f3c1d2cfe68531867d07ce78dad05faec87a39226583c3e43899b", + "python/sglang/multimodal_gen/runtime/layers/mlp.py": "7592e9c7449b607040ff5c17aa78463d158f138944835f8ce26d94307cddee6c", + "python/sglang/multimodal_gen/runtime/layers/moe.py": "a12ec5824b9d17862fd4808f6c19ca6340c1bd7d4c61f61ed919ed82fccda1c1", + "python/sglang/multimodal_gen/runtime/layers/parallel_conv.py": "f9a95097322e80990009252953337d5dbe6a8ae5ff33eeb768e38bcb13b7b527", + "python/sglang/multimodal_gen/runtime/layers/quantization/__init__.py": "ef37cd8cd28bd5554e58f918f13883cf59b5408e110a6d798145432d5632a292", + "python/sglang/multimodal_gen/runtime/layers/quantization/bitsandbytes.py": "00c19985ebc02708d4f9354cd0754ccac13e09af4bbca86b90f47d0bd635ab48", + "python/sglang/multimodal_gen/runtime/layers/quantization/configs/base_config.py": "56c3943c380fbe0584c4f8bd75f51ad2e87605697200fceae944117cd34db9a5", + "python/sglang/multimodal_gen/runtime/layers/quantization/configs/nunchaku_config.py": "637d795cf3b26829373caeed22a7074fad44e331c952873676562e3905db83c2", + "python/sglang/multimodal_gen/runtime/layers/quantization/fp8.py": "a9f129870a6ba8a3ee1f86d53775f04a2fa27d736b713cc51bf42122e4928449", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelopt_fp8.py": "0779107406b1508912e6f3b854a81a4157fb85dde0a6f91f5ebcf1ed100949df", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelopt_quant.py": "1a76af8fce37bdd2521d24e82c54c695c064074efcc83c3e6cd03c90fc939cef", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelslim.py": "6c3aa92b21ffd8a734869ec87d2e5809f9e85d9b00942ae3a1e13b6d7bcb0d67", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelslim_mxfp4_scheme.py": "19c68dd5db6908eca3a733c73d1767707b132f8cfbc5b6a13e87caffd1c7c1f8", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelslim_mxfp8_scheme.py": "0d6fc7dc42e3765f07acddbb9444306dfd7fb64b4f859056a0e5d2f52e828a94", + "python/sglang/multimodal_gen/runtime/layers/quantization/mxfp4.py": "a59f4917982c88acae54f2e91b49ac9def4d0966bb0dc905f78b4ffe595fdffc", + "python/sglang/multimodal_gen/runtime/layers/quantization/mxfp4_npu.py": "5f2368d00347d7af10608b41c3ca737f8410dc7b1f53b19f993779a8bb9ec5a2", + "python/sglang/multimodal_gen/runtime/layers/quantization/mxfp8_npu.py": "1ab8788677b8e3bf5a39f5ea4234280f4df7d38558656980cf55874ba2bdae06", + "python/sglang/multimodal_gen/runtime/layers/quantization/nunchaku_linear.py": "d252165ceccc0d8fe728df9eb5fb8e02091878ef5df53dccf0bb160af10eecfb", + "python/sglang/multimodal_gen/runtime/layers/quantization/weight_only_fp8.py": "b92ea052c6fe113857f36f50541b40d6430cddee997f1189df05857b230016e8", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/__init__.py": "9af17cee919e0f0afb621e8e880df502cb7160590fabffcca5b64ff7cbef7c7a", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/base.py": "b590ca6cd7dc2cfb54357a19d49910ec0d5d975ec49d0874d992829ffd3d477c", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/factory.py": "1101cdfff76713a140c9b106e18705b56b5058535ca767082890a946a1e6de38", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/mrope.py": "2ac0f8d13ea663303095f8ecdb3d7a1520ab851a3534d29cdd9370f5184bbc74", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/utils.py": "7d05ab83063740a79559b411c07cd4f2191ee7a8952b5c8d6a73a5709b44a51b", + "python/sglang/multimodal_gen/runtime/layers/usp.py": "0ace6e1c70d7d5fe925ec44d903aafeefe96535ed8bb0e38b69da95ca116be82", + "python/sglang/multimodal_gen/runtime/layers/utils.py": "a2dbc990916cdaef054dd201c61301edaa738ba1d330ecc7caf2b42fb639ef5b", + "python/sglang/multimodal_gen/runtime/layers/visual_embedding.py": "d9da8fd38234c5f5deeca7d210d06aad7dc686c5e506212a60d65d0882dc88f1", + "python/sglang/multimodal_gen/runtime/layers/vocab_parallel_embedding.py": "9314f9ba2c7ef50bbc1a9e61037af62cf459a3963a7fd81db3de072b3e13e74d", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/adapter_loader.py": "a9dec97c947d5a7bce46526edd05863c32d5a5ce0dd44ac0cb955b9c8b94453a", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/bridge_loader.py": "6691b945a9d7f5f1dd5c8b391ccc63e5cb4507d923461bfa54530f1afa09d6c1", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/component_loader.py": "e0786c2eba8b48a1a6389bd4a246695b827ec9b1115579be9cc378135f2f367a", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/diffusion_decoder_loader.py": "3957341edec37d5787c3dd3b11d11a9927d449a7428e1c17193926c1a9be02df", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/image_encoder_loader.py": "1cd07a83cc47eec407a9d9210f0ec7dec50a2432710f62040a82f9a91b00c0b7", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/pe_loader.py": "a20bba36f057558380c1a1631391292959559558289f469e002cfe60d685e9c4", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/scheduler_loader.py": "aba7c83504f654bc3498e5820a5bda855d9aacfd3a83b667fe1c8bf29603497e", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/sound_tokenizer_loader.py": "b1937d0e7fc4f5ac68c6c7c3ef7acdb3b46fc980a4b714a4cb18f02f5b9ea533", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/text_encoder_loader.py": "4528730cb89f0a6ece895926e989274d8f82051f0dbf5bd64448446d344f42a2", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/transformer_loader.py": "ee3e50d928fa91be176223bb6fcc0e9c3a32b6a6e9414957086b718b88e6980a", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/upsampler_loader.py": "8535017e1755420fd95b0ce35af63514120fdf3259824063f5992b8e123cad27", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/vae_loader.py": "6df64e4d08020c4ff97880b18ab4183cc172e3a92638984b95d7cc746591ab78", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/vl_encoder_loader.py": "8c5d44a51e09e42047bf98eb09291136feaf912aadd96ee4d71dea1d590108d0", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/vocoder_loader.py": "999209b8c2987270ec45fe0a601d96da6d476f6c6d834f328a763f132b22c6e0", + "python/sglang/multimodal_gen/runtime/loader/fsdp_load.py": "5f08113b54f234f30ab1db404b730b97b58fd7ffde0792ee718eb99edb995b0f", + "python/sglang/multimodal_gen/runtime/loader/rank_local_checkpoint.py": "69988377a57733cecfb8b5b96f7e6ab9d208797edd9d61d2040cad25abafbff6", + "python/sglang/multimodal_gen/runtime/loader/transformer_load_utils.py": "d33c27f94139267ab733d9de0a6565faa0c6fd4dd34c6ece02dcb470b4a816dc", + "python/sglang/multimodal_gen/runtime/loader/utils.py": "dc426ac72030a31df4be048a762220ff909f43ee59a8c4d94bbfb25faeac65b2", + "python/sglang/multimodal_gen/runtime/loader/weight_load_plan.py": "c0fdc358f9c86507c613a11afc8af2725a2964c0799d5de640c87979dde146e3", + "python/sglang/multimodal_gen/runtime/loader/weight_utils.py": "9ed60494b361302297ad3b5c316a99a16cd0a6e30ac5a5b2c99cc554caa442fd", + "python/sglang/multimodal_gen/runtime/managers/cpu_worker.py": "9129530d59c1e112c93984a80f74a2d241434e4e93ee88edb7812ff5768ef18a", + "python/sglang/multimodal_gen/runtime/managers/dynamic_batch_admission.py": "a67970658b01e97a07208ca732f57923a51a170322cc20c56d05c09b6f136bff", + "python/sglang/multimodal_gen/runtime/managers/forward_context.py": "ec1d8deb655cbfd5d35a0cb5512728cab8a3290c92e81cb914453f855b7f53d0", + "python/sglang/multimodal_gen/runtime/managers/gpu_worker.py": "9360c8683df090e312e73b9fba6daf7fbceac0e64038f23ddb9050496b4e073e", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_loading_order.py": "b9475e14187a68a31d2788a4dbe9a169ae50dc0456191a3606fa066c6aa497c8", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_manager.py": "723abea1ae61d23b5e6af1819e7b582482a24f9900f83166a5b99c97331057dd", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_residency.py": "cd2cb0842d59f1e8b49325affca4e5d01551358d93c2afe6e19677b35ae1fc52", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_residency_strategies.py": "a541de018df77e94511bab2b758b657c47de114dcddb28a106726bf449ef25ad", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/layerwise_offload.py": "ddbea630f8eb6762a5107c2858003a1070f78f5d5618383bc2a87a8ca2070c47", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/layerwise_offload_components.py": "41ffa59ce3b01c95257dc6755a0dc0ec1a52c12378b349cff6ebe64b3dd68db9", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/memory_occupation_controller.py": "a21bb65a9167df86b02a4513c9ecf6cae1bd0b2d74941585961d2c7d833e642a", + "python/sglang/multimodal_gen/runtime/managers/scheduler.py": "5941b8bf6b8bccdc90bb7b53ad506215a8eb8eafe4bb4fd96b1e835191616424", + "python/sglang/multimodal_gen/runtime/models/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/models/adapter/ltx_2_connector.py": "710f57417f28eb4a343b598436de4916206ea5f5ee923a103cca4553edc06452", + "python/sglang/multimodal_gen/runtime/models/adapter/ltx_2_duration_head.py": "b6410dbee092def590e27c24148d165dc37af5b7160f139b275ed1d38346e5f5", + "python/sglang/multimodal_gen/runtime/models/bridges/__init__.py": "a4752c5a87fe7199c2f200a41bf6beaed51103fb0c8bb220587945f8332b82e1", + "python/sglang/multimodal_gen/runtime/models/bridges/mova_dual_tower.py": "2d863267a53296ccab8b70639e38743d6825a929cdbb3eb9a3f8ec4b8127f49a", + "python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py": "09bfa5b29d65481cab0f73148a0b93e150d44915d6bb78a67127ee476e6a553c", + "python/sglang/multimodal_gen/runtime/models/dits/base.py": "a2b301251870b280b084e397c971cc943c366fa419d058ede417468a8ef0a22a", + "python/sglang/multimodal_gen/runtime/models/dits/causal_wanvideo.py": "3689266cadd01628396e31113158061fd44679415812c60e52b006ec574adf4c", + "python/sglang/multimodal_gen/runtime/models/dits/common.py": "ff49004f0cd0e2554a0d3cd20eef5fe781e12cea9bca1e6fb560bc07aaedb6aa", + "python/sglang/multimodal_gen/runtime/models/dits/cosmos3video.py": "4080aa3de0d00bdc084336cad6d2cef6cd729d537559ffe596f40aa8c6418e56", + "python/sglang/multimodal_gen/runtime/models/dits/ernie_image.py": "dce5f7a888245a70d1a2d7e95e2cdc094e7558f05aa26effd9b1063ba3e5ec8e", + "python/sglang/multimodal_gen/runtime/models/dits/flux.py": "bd54b552882016cd03762d5616f1b69b69c103b9c6259c397bd652dad04fe572", + "python/sglang/multimodal_gen/runtime/models/dits/flux_2.py": "a47e92a208084baf1884f87447361b3992cd3f7f01559482a68d70f64db44c80", + "python/sglang/multimodal_gen/runtime/models/dits/glm_image.py": "2cb1e8b15a8c2b8d127cab6d697aebc7e3fc3899944daa2cd7b5b87e3d30950c", + "python/sglang/multimodal_gen/runtime/models/dits/helios.py": "88b1db03ec90430f6f95c8ddd1bb5985fe6e0c5166f111cc7d8d2c24446a770c", + "python/sglang/multimodal_gen/runtime/models/dits/hunyuan3d.py": "2b6b93a40f98e6451ffcc91d15526a4c52eb98e57df8e203783c778a158d755a", + "python/sglang/multimodal_gen/runtime/models/dits/hunyuan3d_paint.py": "6459c735a0b1f8d857a9b92aa76c33bc6c6fb391b5a5efd07453b5263ecff8a8", + "python/sglang/multimodal_gen/runtime/models/dits/hunyuanvideo.py": "1a688c928e44e335ca7979e41d96fa41dd84fd44a378b24a4c9c1513ee024186", + "python/sglang/multimodal_gen/runtime/models/dits/ideogram.py": "fb4c039364b191663b4f71ffb11682b044ac67b04f8a2e184f59f70b5222f345", + "python/sglang/multimodal_gen/runtime/models/dits/joy_image.py": "abb18fdc282f7d671784c47275fae907a6a5bc3f3e6a74348bc131609d4001ac", + "python/sglang/multimodal_gen/runtime/models/dits/krea2.py": "b94f77b11e881bd4b9e910f7cf58f42d0c2e310e3e8493f2b320a5b1691ac6e5", + "python/sglang/multimodal_gen/runtime/models/dits/lingbot_video_moe.py": "20cf369807ed2c7c3815ad9160d601dc598ade9f6ddf2fd8fb875d21c89f706e", + "python/sglang/multimodal_gen/runtime/models/dits/lingbot_world.py": "c5d9d06cef80d52fe7e0439a9dcb018e30ed39d08d08b5e903b215c1810aa919", + "python/sglang/multimodal_gen/runtime/models/dits/longcat_image.py": "a4ebf8515b0a339ba7b8dc62ff4f2943819d623d0cd761e3280889c562dc29f3", + "python/sglang/multimodal_gen/runtime/models/dits/longlive2.py": "5c1e10078bee0e9653e954e918c28ed94e1060e322b4d5ae8a657f95e93b1727", + "python/sglang/multimodal_gen/runtime/models/dits/ltx_2.py": "0c70037aa7038466fd8d2917868378c44c0cc0a907ab6a054bf558a0c58f4ea6", + "python/sglang/multimodal_gen/runtime/models/dits/minimax_h3.py": "51ed02981c04e53ff72302a9d1dca03f9957e28032c96fca7bd92987abe1ac64", + "python/sglang/multimodal_gen/runtime/models/dits/mova_audio_dit.py": "777055d2c2f37b247a30c086db7e6baab066f106b38c2cc7ab4c431835048197", + "python/sglang/multimodal_gen/runtime/models/dits/mova_video_dit.py": "c579c625265bf38cecba49f2aea2a11a924bce2d741a4059cf96a48ae2206632", + "python/sglang/multimodal_gen/runtime/models/dits/qwen_image.py": "917b33ca0b65a60eb1d0e6a7fd25fdba9b37363b648ea1afe6987f922f7b2f6d", + "python/sglang/multimodal_gen/runtime/models/dits/sana.py": "65d8daddf53d76ae011070d3c03e52c934baa99ae89d7522e40be9ab29aac290", + "python/sglang/multimodal_gen/runtime/models/dits/sana_video.py": "53c0da351d964acb5cd9db5e9dc8318929c1ed0e05c49c565113b2c0694b1e0b", + "python/sglang/multimodal_gen/runtime/models/dits/sana_wm.py": "0fe643a28ea0c79a4b3304f6a8a5db9a6a61ee82b56a6897196f64b0d6dbc33d", + "python/sglang/multimodal_gen/runtime/models/dits/sana_wm_components.py": "ae1a2a84d01f9faa9fcb05a617fda7da096b441617906c3575f4fbcf42c15830", + "python/sglang/multimodal_gen/runtime/models/dits/sana_wm_refiner_transformer.py": "5e196be390a04c772dbed3b87a18dbc3064a5a5f4aa5ab6607a00463b859ac82", + "python/sglang/multimodal_gen/runtime/models/dits/stable_diffusion.py": "cb909dc609c8702988e3a15819df0ad2d442ca710d9db239c15bf87ec730fd68", + "python/sglang/multimodal_gen/runtime/models/dits/stablediffusion3.py": "5a4f9fdfddc5f2ba63459ac24208b5749e766220d9aefc2ba4ccbe7f2c2796e2", + "python/sglang/multimodal_gen/runtime/models/dits/wanvideo.py": "aefcde8becfd2d74903677bfbed25584b56ecf5de5e2a076134f38dcb6a667ef", + "python/sglang/multimodal_gen/runtime/models/dits/zimage.py": "d9edb95f3aa774f2c6a366e4748d0381a9df86d1dd7d462e865d073155feb519", + "python/sglang/multimodal_gen/runtime/models/encoders/base.py": "f51334e5f2bb3b7656895698681d6bb98afedbcdeb97e4ad1a9e0558a26408ab", + "python/sglang/multimodal_gen/runtime/models/encoders/clip.py": "1458c21535566211fafeaba75349cd79a50998935b63daf878c1867bd09d6e1f", + "python/sglang/multimodal_gen/runtime/models/encoders/gemma2.py": "dc1f2c13ef034da1548cdc388aabb1237bb5a4b7828457f8a5bf3a413fe4e4bc", + "python/sglang/multimodal_gen/runtime/models/encoders/gemma_3.py": "aa056089c52ce99ce8f295fe32075cbaa35ddc33809ffdedac30ca0041404ac0", + "python/sglang/multimodal_gen/runtime/models/encoders/hunyuan3d.py": "89a92d6a3069869bcd5b359250dd766e3a9604e6722c917d90d7652b2dfc47f4", + "python/sglang/multimodal_gen/runtime/models/encoders/ideogram.py": "c1cd89f67bcafed9e2ab898d23dced908d0ed29b9c10107d0a1468eb421caed3", + "python/sglang/multimodal_gen/runtime/models/encoders/llama.py": "8a7cc03778cdf5a2fd55a0be58dda4e25ddfd28aba07f4224ed0368a8d6cec85", + "python/sglang/multimodal_gen/runtime/models/encoders/minimax_h3_qwen3vl.py": "bfa90ff49574e0274603d8a4e276b8c1095914234faf212469702ae0d5485982", + "python/sglang/multimodal_gen/runtime/models/encoders/mistral_3.py": "1896da5c12f01c97debe8939eaf5bffc25a091203211969c5f3f20c350f76897", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen2_5vl.py": "7aed7402b44d4f9b966b39329a4bffd838bb3a6bebf876b51eb9e3101db50cb6", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen2_5vl_vision.py": "d6fbc38058dbebaf73023f38978dd94176ef800923b30af6b93140b912ed674f", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen3.py": "54e36f7b16ca68cfeeb93623501e2ded8126e429448698b8868b5b1b6c9ca55c", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen3vl.py": "6c2945e4afe9f44ebb054e99f66ac624610ce9d5e1d92f5f8a02abb4309408dd", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen3vl_vision.py": "98aa9d4663426875b03127b9356e80b75d3c4eb1ff30fbfd52cdb07a4ab4a320", + "python/sglang/multimodal_gen/runtime/models/encoders/t5.py": "c40c16f5a23af923ba4f2aeb64fb7ec5db22cf537045fb323598846ac1ed0663", + "python/sglang/multimodal_gen/runtime/models/encoders/vision.py": "6a7d468c627b9723bf96345ee0cbb71089bf1114125aabcfcee785394fc8e2f6", + "python/sglang/multimodal_gen/runtime/models/parameter.py": "f0b76b8dd38967cac143f09fceb77759c13327c554ecc3721b71b1f7daf8dbc9", + "python/sglang/multimodal_gen/runtime/models/registry.py": "1db4e7402886571d1d2af74c47ca5f1f5eeafd33959e1faf6915536c5e877a97", + "python/sglang/multimodal_gen/runtime/models/schedulers/base.py": "91d08fbcf1717486863cc97c41aa3fe5a97f6254d0802cf8830b54c1ed530f60", + "python/sglang/multimodal_gen/runtime/models/schedulers/flow_match_pair.py": "0521c03ccd1c3b7b8c5d8d48365dfbcff6a6e6f465bc362fd9d6eb904759529c", + "python/sglang/multimodal_gen/runtime/models/schedulers/hunyuan3d_scheduler.py": "d8324bc70fef5d52f98604bbedabb492169daf4c41af1f085e46edb4cb76e8fe", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_comfyui_passthrough.py": "77401a8fff0a32cd1d8381c5219b194bf2d759c07881260fc70af4e6395b77ba", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_dpm_solver_multistep.py": "b51713e95535d2742bcd0248ea6880ca754d37ebbea37214136e7d91ec3c7755", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_flow_match_euler_discrete.py": "21d11e8b896f3f49973abc58e0dcab0bb342e9704282efa14c7b296fc0cf414b", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_flow_unipc_multistep.py": "c5993235bfebe894389d4b266a7f1b76b67c2506f34c05ed86c39c9087104d00", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_helios.py": "01b67c8ccc4ef199bb719e03c2e061e7c9e8a7e296270486eb027ade3ebd1a79", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_minimax_h3_euler_ancestral.py": "fbdb7faf8c3b29d5768562d523ad8a87ed4644ea7f322824dae7f9e246a661f4", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_self_forcing_flow_match.py": "872b8b9aa374f21841494ceba95add3637269821a0918bb8a4a57eddb954a4a5", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_unipc_multistep.py": "0239fa71456f0c80de99c83e6647e636a87287f1a68ef5185b47f1abbcb34e21", + "python/sglang/multimodal_gen/runtime/models/upsampler/__init__.py": "0cc18dc2663e115ac8b0934233260bd590df8d891bd48678188ebf7bdc1ef0fc", + "python/sglang/multimodal_gen/runtime/models/upsampler/latent_upsampler.py": "8a5007c84f245bb1a0080c565ff2c63404265432538a9ef10bb8115f4820ea9d", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder.py": "68bcdac692075fe5ce2303589fedb01d11cbb5ec47951e182af3944a0055d676", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder_dc.py": "297f9a3feb07ba887c111c56a3d1898d987fcb3066fd98efdeac6df1ff7a1aaa", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder_kl_flux2.py": "de46376e143caf2e00558c9743d5210e6be134a984c93a6f033caa926df9b896", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder_kl_qwenimage.py": "1c61768b7218898b82a3a1921edbe82afe9455398bf8fad2ade196a57edffef4", + "python/sglang/multimodal_gen/runtime/models/vaes/common.py": "3226ddddbd99df8753739eea8d5f60a555a9c000c8108244f042f56a39b6f386", + "python/sglang/multimodal_gen/runtime/models/vaes/cosmos3_avae.py": "070f26818115908d537c16a02c069fced80168214ee74e7b5c71c3b879a23bc0", + "python/sglang/multimodal_gen/runtime/models/vaes/dac.py": "df0998731a1d40093a8e61d294ddcf45db21e5ca41310d9f09ef6ee955180827", + "python/sglang/multimodal_gen/runtime/models/vaes/fast_path_gate.py": "e6ab5ac51af6ed16a22cb6c8e700c56175fc628abf6b966ea5d6f1a29cf974a6", + "python/sglang/multimodal_gen/runtime/models/vaes/flux2_vae_cuda_opt.py": "0bcf90fa9b7eed89ebd546b2e000d720d7b7347e3f83e6c9ae52b5c2479c6823", + "python/sglang/multimodal_gen/runtime/models/vaes/hunyuan3d_vae.py": "9d9df7a0ade8810005380cf80c568f1de22de6ff934e955b2e9119b3c13e94cb", + "python/sglang/multimodal_gen/runtime/models/vaes/hunyuanvae.py": "4f0622e3eb8704cad079e840581eec94a3ca185b08a4cab021adc896994de69e", + "python/sglang/multimodal_gen/runtime/models/vaes/ltx_2_3_condition_encoder.py": "a14a1bc3a6a2e5ddb6daf9404f4927aa4c18555eff688a84407bd8c0b63a550b", + "python/sglang/multimodal_gen/runtime/models/vaes/ltx_2_audio.py": "b9df1d6f0500d35c726229694bef284518140b9fe87f4d9a83fdfdb97107ebb3", + "python/sglang/multimodal_gen/runtime/models/vaes/ltx_2_vae.py": "2b9919336dd8930bf827b3c2903a28ce2e5c8ae456a2c2f0493f1ec49c98012f", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3.py": "72b08543587f41a359242ff49b2b34bba6f69dc5595524bd7b823c1b3eaabc09", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/__init__.py": "89480a39dda098dc895d950f6b1c0607cc61b2ebdf42f6f7329e44aa587a751f", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/alias_free.py": "40d8899a8e345fac07b970b1d26844f9a94f59bf474931a3f5446e3f4a1f6a2a", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/audio_vae.py": "8bbac65410bea451e76c98705f565d884e8fe5008b5b4873a31fc466930d5969", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/bigvgan.py": "08be3944c69d68917f700e24425c59aa776dc14f422e69f0be58f7026cbd4af1", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/__init__.py": "e6796d027b97366ff48eeff25bfd04e31c4fd4a4f4b5f4ee4b740b9166a8068b", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/attention.py": "4a5fc609c226c50be275cde8d8301d3973a67e94f71896e43411c2d7f8780999", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/base_module.py": "50a9a75b936b40308189515076b1208fc1fc2c6b342082fb71ad0eb40a98fb0b", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/conv.py": "587259d276178f64b2f9002a6cd82e19f547e20deb54bc8e3fd7e2a4c5f030e4", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/klvae.py": "4e855a369668e951751484d63801f4ce74e35b664a63d5e6270261e4c2073e8d", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/norm.py": "efd4e3f61c9381489e2926947981c24c471f6a16e7c08156f6d01c7dc4221698", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/processor.py": "d1fbb4f3125c79e1564b21392d67e7101762a53121268ccb82d8092a878488d1", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/vae_cnn.py": "792ee2176878d0f8b64b42d7ec63a927509dddf6ad864771d43a744981de13eb", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/vae_vit.py": "7eea59b9f87559e0309f4708d52398c987294cef757e729ff825fa0ebe904977", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/vit_utils.py": "1709aa4cd8a3ce911f317f58ea326de9aa63ef733b5387b1a77864b3e24f7a6c", + "python/sglang/multimodal_gen/runtime/models/vaes/parallel/diffusers_spatial.py": "ab25a8a2eddb90f7a3b9c341169f7ed3edd8eb26dc14ad95430fe6585a05aa7a", + "python/sglang/multimodal_gen/runtime/models/vaes/wan_vae_cuda_opt.py": "e866f38ea36176e1b7bf6cce547ca2076f69606742f5cfad3ff05661538564a6", + "python/sglang/multimodal_gen/runtime/models/vaes/wanvae.py": "e7ea14d19146d4455c4a2f30e512c8cb9d81523f7ee8eed80de5c6f45e41b48e", + "python/sglang/multimodal_gen/runtime/models/vlas/__init__.py": "94a562aee42ecb588af893eee9528bb565336d3b5049142403eeabf1d2a8f068", + "python/sglang/multimodal_gen/runtime/models/vlas/pi05_core.py": "09f4a75d1ae50f60f60025a48dcf89841cc7c69846380cc2f2f48aacc67fec08", + "python/sglang/multimodal_gen/runtime/models/vlas/pi05_policy.py": "3be6ce3afe0d372fe6a39a576aa6988832a8c34eb5e50c2a8f124a8ed9a8d1fb", + "python/sglang/multimodal_gen/runtime/models/vocoder/ltx_2_vocoder.py": "443feb40733b76ea7d3c14acc6cc08e60ee6c8feaa7e9190d930d6adcb12e239", + "python/sglang/multimodal_gen/runtime/pipelines/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/pipelines/comfyui_flux_pipeline.py": "9beeb875241f9bf039adff48a877094d4311ebd8d98902a6b59b7dd79470cb06", + "python/sglang/multimodal_gen/runtime/pipelines/comfyui_qwen_image_pipeline.py": "ef7e2eb33a6c4b226dc0ee7a79176ef809e617e6e5e90ca8f1e85e9e9df74984", + "python/sglang/multimodal_gen/runtime/pipelines/comfyui_zimage_pipeline.py": "1bc6d205ebda69464fd0548a7f9d30b22cf8115a857a9b39520f53cfc024fb81", + "python/sglang/multimodal_gen/runtime/pipelines/cosmos3_pipeline.py": "a51e9b1060fdbcc8aa8938ccdc184485070284434ba048d554e25ce5aaf294c1", + "python/sglang/multimodal_gen/runtime/pipelines/diffusers_pipeline.py": "d227b82d195936f9efb550683ab2af59e44e453b51716c847d1012f8aaadc187", + "python/sglang/multimodal_gen/runtime/pipelines/ernie_image.py": "e4463bee580d472ae31077d8ffe2be3363bae4e924000eebf08a393dd011902d", + "python/sglang/multimodal_gen/runtime/pipelines/flux.py": "a548029fb75faa7a638b9bac33f1c7153c19a5385525762ae10a0cc50f1f6977", + "python/sglang/multimodal_gen/runtime/pipelines/flux_2.py": "51af080813cc0f667d874d9b255cb519c5fc66bde06138131948bfbc7ac534b1", + "python/sglang/multimodal_gen/runtime/pipelines/flux_2_klein.py": "03bab0d7a6572b29fb203f2aa41140a54f77fb3e3ff90489401cd5a90933fd58", + "python/sglang/multimodal_gen/runtime/pipelines/flux_2_nvfp4.py": "dd93b28b5dde6f54ede886801f15a02366d0fe63a3a320298322c84ee8e9055d", + "python/sglang/multimodal_gen/runtime/pipelines/glm_image.py": "a217b6a4dac5f5fd019dc29e1868ddc7a305458aa3e664cc8002b4613630aa7b", + "python/sglang/multimodal_gen/runtime/pipelines/helios_pipeline.py": "877431bbc32af7f505e9a66f294527da9f0c68747ab7679d6a1ef832cfae01d5", + "python/sglang/multimodal_gen/runtime/pipelines/hunyuan3d_pipeline.py": "904af91f67269d4dc42cd288d017a1df50946cad50575aa09b7f1c5261a3329d", + "python/sglang/multimodal_gen/runtime/pipelines/hunyuan_pipeline.py": "4c158534ccbe998b01cd8677c2853b4273a7db4a900b288752d2f8e519922dbd", + "python/sglang/multimodal_gen/runtime/pipelines/ideogram.py": "632a931e1f13a3f1a33797bfd035b070c30e5550b567f63d0101d7e6511c4ef9", + "python/sglang/multimodal_gen/runtime/pipelines/joy_echo_pipeline.py": "97af44fc188a60095195ef2534f11c03815176351fbf9df75d8328ac4b4ef8dc", + "python/sglang/multimodal_gen/runtime/pipelines/joy_image.py": "48f87dd0b95933c15c411df6bfaf99ddfe489c8e7ebdf7754f47d91f9a1ef2ec", + "python/sglang/multimodal_gen/runtime/pipelines/krea2.py": "96cd5d14224a3f46169679ffbeb2c2ec366519d64df6f99c63f8178f579fff12", + "python/sglang/multimodal_gen/runtime/pipelines/lingbot_video_moe.py": "1315c3d65ad0c2f76931ffbbc35b3d4ea02fabdb45be5dd7df63dbfafdd0db7c", + "python/sglang/multimodal_gen/runtime/pipelines/lingbot_world_causal_dmd_pipeline.py": "ddd7b330f42392d0e66882f222d0fe8787aa978fcdcca48caa137099bce716b3", + "python/sglang/multimodal_gen/runtime/pipelines/longcat_image.py": "a21cad85cbc1a589d7a6a2626444e07febdbf50d7c2ee39a3352f88c02791d63", + "python/sglang/multimodal_gen/runtime/pipelines/longlive2_pipeline.py": "545338044488b1525f3b2f75ec7bdcca819541cd42ee84d4d1efe7aababa6141", + "python/sglang/multimodal_gen/runtime/pipelines/ltx_2_pipeline.py": "be45a325b798ab1283861da8529cfcc863cccb5e66475f8d0c76a3a9fe5c1648", + "python/sglang/multimodal_gen/runtime/pipelines/minimax_h3_pipeline.py": "df9e4a8821d494ceb2ab9bcc9961267a0d5e904785d04e7408e2e35e837d7d5a", + "python/sglang/multimodal_gen/runtime/pipelines/mova_pipeline.py": "6e830f3f3f7f33a01f964f486bc94682c3f1579700ab6186613deec7da98de85", + "python/sglang/multimodal_gen/runtime/pipelines/pi05.py": "c63ccc8decb441e1787fc303302399c7c659b760aacd1b86cc9c90805161d044", + "python/sglang/multimodal_gen/runtime/pipelines/qwen_image.py": "3dc4c341833d90bddf3632f3d7efacbbbc56f678bc5abe57b46387659398a727", + "python/sglang/multimodal_gen/runtime/pipelines/sana.py": "75c789f401fc04e031185cf267a95d212f7c8ef7fad1c9baf6aebd317a58359e", + "python/sglang/multimodal_gen/runtime/pipelines/sana_video.py": "33bc780a46275475cc9fa63769cdfb8bccfd43f62acad3d08ecb8fb15a392ca6", + "python/sglang/multimodal_gen/runtime/pipelines/sana_wm_pipeline.py": "efd5775c75494a02226fe0f2120c648a3c71b8db991fedeb146fcd1dd827ef15", + "python/sglang/multimodal_gen/runtime/pipelines/sana_wm_realtime_pipeline.py": "a70910d5e11b17b850d4b706cdfff5663052de6e934e1cc12e099bb96a6525fa", + "python/sglang/multimodal_gen/runtime/pipelines/stable_diffusion_3.py": "73ad4dfe624e7622bebdda2c7900c08140ae0ae7dd01f8139f32d5a418794242", + "python/sglang/multimodal_gen/runtime/pipelines/wan_causal_dmd_pipeline.py": "b6dddbb4274c0d03bf5a29f0b93c0d4a3709c11d798e5c01266d5d395e7b1401", + "python/sglang/multimodal_gen/runtime/pipelines/wan_dmd_pipeline.py": "bcd1e9bf7bbc44fefc8836f67c4074f4eaad1de9d51b75943a3620d76b74227d", + "python/sglang/multimodal_gen/runtime/pipelines/wan_i2v_dmd_pipeline.py": "eff86c1eb694e6c6df56d5bb7ed18214f26525d66363a2d3fd93f9f8eaa00e5f", + "python/sglang/multimodal_gen/runtime/pipelines/wan_i2v_pipeline.py": "33eb376b983824ff5ea9a7200d47b9d6414c9b030e0efa734de0096ca5e02b83", + "python/sglang/multimodal_gen/runtime/pipelines/wan_pipeline.py": "8deec56d8aff8307e51a601caf52fec92e888aff38e4203940a8f9afd09eaed3", + "python/sglang/multimodal_gen/runtime/pipelines/zimage_pipeline.py": "9a916192482a2ead84aec5e26074c119986c49b5cf5fc04556824f5f07558fa7", + "python/sglang/multimodal_gen/runtime/pipelines_core/__init__.py": "7a915dad966148fac6ba6ef0e8a2ea7b8ab24364ad798651fde34e36105bb686", + "python/sglang/multimodal_gen/runtime/pipelines_core/composed_pipeline_base.py": "adeed9abfedb8aa03eabb6e7c17e1be4677d8fa8c3c07c97da0041c50545b15b", + "python/sglang/multimodal_gen/runtime/pipelines_core/diffusion_scheduler_utils.py": "4441eb11d7d9bd216abf4f092ae50e7e88c571600cd3f261ae638198d9d723dd", + "python/sglang/multimodal_gen/runtime/pipelines_core/executors/parallel_executor.py": "4e2279809f573c2bc97a7282aa19aeaaa904907d87c40965c440e64ec4a20c1f", + "python/sglang/multimodal_gen/runtime/pipelines_core/executors/pipeline_executor.py": "a611faa15b912209cdc31bf6e53e2f25c8921e161767d2a60108825b4de5c38b", + "python/sglang/multimodal_gen/runtime/pipelines_core/executors/sync_executor.py": "7b56b40f7a16f7668a046b7bf7cb5fede338865e9fab9e93ed6505ce4f365df5", + "python/sglang/multimodal_gen/runtime/pipelines_core/lora_format_adapter.py": "bd9cbafe43b461ce72f8c23916af0c225d8b93b6e8ed971ba7b9050da91b8b76", + "python/sglang/multimodal_gen/runtime/pipelines_core/lora_pipeline.py": "795b5e5643c5f409ac4d3c5ca9ecb949e0306624c9530a1889075e19ede4d9b6", + "python/sglang/multimodal_gen/runtime/pipelines_core/schedule_batch.py": "1f0316c81a5e78bcf4e517b9ebdf112781a0457795edb624acebcebff8104a01", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/__init__.py": "c625f68f3e66d4fb3c67cb61938e249c78d91ce8d0a0511d48f72d9ca275da0b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/base.py": "f241b98bdc302cd5166c865aab43578ab7bdb0192fedec9e3d72fa927b159c90", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/causal_denoising.py": "a9288d122f3570db0c1830479a11dcab45b81c54a3eef3af3ccabdb787bed7e5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/comfyui_latent_preparation.py": "2dda6124c913c7c136795f00f87291dbd2d26b1ff9d0a5aade1595c5dc1c1bc4", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/condition_encoding.py": "4e4ec28b2f34dbeb1b55a33bb03b271426882e2f45956af85553e67ecc71ab13", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/decoding.py": "366f19a971272faecd7593959252738255be7cd511844589622ccab1d8d56b7d", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/dedup.py": "74e5599aafc01f380a362135518a0738a818bf36f743beecc660065a6d4261db", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/denoising.py": "eddf4b7c56f8327dd32b3bae96f4c4bfc00a2a2c3130d51f8493457ea89af886", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/denoising_dmd.py": "2cabac8977c3cd85cb01e8115a06e289cbcdc50710c4a1b65b30905723ffa910", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/encoding.py": "c5b05e6fb51f89b9acc9bb8c3550b7a74d7d99160ea8159c9c19ee8d008defff", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/image_encoding.py": "0399e820f586e01b02ce7691c0e35787b70d8d945cf6f87688ff60254369bf1b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/input_validation.py": "98fbfba3712ab1c02693f45a8deb9be6deff5ac7fc69a55613e53cd271cc6ba5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/latent_preparation.py": "4a3e4e5969e6d5a94b3a7ab31e9d3ad41c115baa8578130a3c67c8f9f1fa8064", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/__init__.py": "ebd231430fdad47b9245706acb16104c53254e70509649f253b659be62f413d7", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/cosmos3.py": "9ca060ddc6dcf5a1b0c03d78bbcd05ac143b6ecd628d110b945a82dbe0e5542a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/cosmos3_action.py": "4cc1f9f7782b1c7e067f16abd42f30678a10c9e50ef3c74844733aaca22291d2", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/cosmos3_guardrails.py": "7f7287f0bae16ea441ca55f14973cffeeac9766f9721485cda2e937e34f94af5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ernie_image_pe.py": "97104d1be95cdcdda1f474eb9a02888fbd08779edb62ca62efc0c7725495dfdf", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/glm_image.py": "b9e09a44cadf9a21eda5e620db33a73d40fa3adde7a93351802d95ada27ec600", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/helios_decoding.py": "858260a1493175f56808a1de788da255469a4bd5db49ddc9366b172c7da4e448", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/helios_denoising.py": "e07ba169836ed182d502cb011e56543beba751f5baf40155dfc1211ee78b2f8c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/hunyuan3d/__init__.py": "f40587c9be218a7ccde841bc977de8d85c5e5b55c949a0d5e81c659488e67e13", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/hunyuan3d/paint.py": "bd40ee8797df95d2a58bf1cbd0108e7ef8f13222a9142b20f9c828d691d3c58f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/hunyuan3d/shape.py": "6a2104cc36081c94280333ec46052e4d0dc3b1237c3031ad3d3b67ba01448656", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ideogram.py": "df557487a415bbe227954a178c395c26fb99e102d72862d9d7dfa397b914ba9a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/__init__.py": "de8741eeb8db145fc04d02006b4a1cb2832f36187f7efb0612bb0b879a010347", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/denoising.py": "c634d859385927f4a4d02aeb88c03f53172202a290a71c76aa10c13d9b24b0cf", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/memory.py": "0fa134d57ed89a80b2495c682fbebf1a8a67fa527df9830bca0026f1251c1f4a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/setup.py": "7439f7996d73d6fd0760b27193676ff202de33ed632e73278ccc788d63a8f306", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/krea2.py": "b95b1aafeca065e81d7815f8e6ff37ab492ab49ba063c942d24a0535d5cd5ccb", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_video_moe/__init__.py": "f2a03b7a4cc32cc59d40d805052c29d18d090ef9c7d8d6fc5f58d74f4734c5a8", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_video_moe/text_encoding.py": "8110862fd7037db5bb7606fd403d4b557bd7772d09481bdf916b716a230c3153", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_world/__init__.py": "ee72d57db58de7d21d89553c80e262f3a3fe18a0dfad92085891838e191bd5ea", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_world/constants.py": "295fbcdd46ec9bfe7b8a2994c67ddcc66ad42a1441e9c0cab4f13dfdb059f326", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_world/lingbot_world_causal_denoising.py": "d1dfc2f4901d31e6678152ba7f18105f15846b861a2068757372d73c45c5845f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/longcat_image.py": "f49d8ebea3a51c5970870c6bc093bf95586ddfb8338d96104ba58178f9eb6795", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/longlive2.py": "33512ab40646e6e517c82e99e8516d6608b26fd637539dc4e33e869d52e088b7", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/__init__.py": "4948a3b70126453c1dd13d3e2bfb29a31db3c84fb2bac601430363f2dfd7726a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/decoding_av.py": "0977369c7cd77b1e3c1c5251899d1f077153c7a91e46130a960aad76094acb6c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/denoising.py": "82ac9294fda80ceb56f7586e39b14cf92a04505911a5c70904fa7006c3ac0a16", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/denoising_av.py": "cf7db0a4378df0b3baa733924ff6b1af21688d65ceb3210295604b5a704b1c69", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/duration.py": "cb606e0b84ee08bd076de6c9786edf7098e7e45bd0449d5ea56e31f7026cf54a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/latent_preparation_av.py": "22f195152cb797198c270715ae168272d07d21fdf81b722cd44d493c2c365057", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/text_connector.py": "f45e4246aff0bebc5755940d00523538fdf94d32dcf8af9cf7bf2444accfd7fc", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/upsampling.py": "33284244363812abb74dafd626c27d8f2e4a5cda692190355a353551a6f77204", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/__init__.py": "763487795767fdf28fed18a6cd8f020fbf0647b6f8ecbde8dbf8c518cc19bafe", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/canvas.py": "e3b8513260bbe1d1d15cf8835f0146d9e958f4a6950826c30df23ded8d22d892", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/condition_noise.py": "4e2a4046ec6b3899e474a3352ef73c480d57e104f242c1e06c4819b2d1a221e6", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/constants.py": "583e94f14e3de084046af5218ed6456d1122d5e6051062d1372b35657235cabf", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/denoise_loop.py": "af19fcd37935da6193dc1329410edbdfaef25ca763db316f40bbc46fb6a48ba5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/keyframe_encoding.py": "c8aeeffcb0045402ce11dd3eed156df9188729e6bfee92f6a49ee95d27e93bec", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/material_io.py": "d75427ecbcf227a61f140ae45eccc73e30d001be0e70e90b6d2ca76bc8b4868e", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/packed_sequence.py": "8428954a3998429ff565b6a06e0c678ce0dd1b35ccf0492b26dbbee512f80a99", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/packed_tokens.py": "5441c9c3eb183a7694902f093c0ec5c9ffcf4351b4f8c64011cc75a85aff29da", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/prequeue.py": "91652d61cf0a7c552ccf166cbfcb9877f6f2ef2186ff078dd0b4b9fa105db4c1", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/presentation.py": "7c8e4d4a22c0933be79196b1c6b446191d020b55ba7de87be2781e81fd838f00", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/reference_encoding.py": "d0c8ae24984618c3f8b1f5a0eafdb077777784c1b94437c1f5e90b3e1e13a3e9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/release_metadata.py": "006910e9437a7250a7c72c7e7e1029e0b6a5e1a4be1a471fdf6c8fc199f2885f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/request_validation.py": "6fb8c16f336b24d9bd5abb52a7a1b822885b53fcb8a6d6398262718b62a99433", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/resolved_plan.py": "03d85dfb8819f6c52e6cc1a779adf9b515618f4dc6c97705b517d93ae972fad9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/__init__.py": "e0e3946d1e14a6190032baf047f920efc9cdd428efcd350bf9b58ba7ad7677aa", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/audio_encoding.py": "d50ee17293a1ac07e253ad259cc728f023c77ef56aac45289d4be057247f373f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/decoding.py": "a1ea299b0430c54ff0c7b26a338c168cc7ee9996fe748b08a2f73579728a7507", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/denoising.py": "c812008e49e42b762c1cea6f72e1df89574e905ee4de737f606afa205a0e8fec", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/latent_preparation.py": "8eef36d7a41665b80550c75a93566dddabf0ea3f15c6f66c3ed41262c135b368", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/replica_broadcast.py": "8c249dd8a295e1d3c989ddbc745258632a9017432230b362f85a215b13c24593", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/text_encoding.py": "f299b2f26598a04d5e70d8f5f659b9c45cc89abdb136cb466559c14a7ba17db5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/timestep_preparation.py": "efc5ce8ef4f05af58c4e5079b8ec1232f8847c5aaec7dbe5299312e3ebbac3d8", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/visual_encoding.py": "a52754f8c1ccb6370ac12c1fe8e98b2f28f76145540dce72c9a1d0e27d9946d9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/task_profiles.py": "0313922cc2d5e2b5af76583aaa96a114ccedf582de3eebfbc05abd79a84aec0d", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/time_request.py": "c63ae32bfc7e3fde5cdc7a791ceb5a62d9e72f30c9d08b6af773571c126bce90", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/video_adapter.py": "637bb5c97fb12b1b347845df366f8d0239735dc43b1dbd998e0ace1018d2baee", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/mova.py": "79b1beb782edcfd1d72565f6924def1e676001b35b7dae41bf833c53d3e943ea", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/pi05_preprocess.py": "907722ab1b870f37380bef6ca018c9fb364143d3e6db3c9afe07de8d6dad5a9b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/qwen_image_layered.py": "4b50c4fe30b5c187f7820f5a7e71e30fa79bc6e2215a49fdb8eb24b4a4879c33", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/__init__.py": "d07dc00c83ef44d83f9b649b7efb4c750e23601a435fe5c5fc6b4ec4f6250016", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/base.py": "13757608aea15e1d4183d2be4b6f2c3341c0d336e0282624c3e4c6d7f3fef21f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/parity_probe.py": "5017dde841c6b3073983cc7877f1b55663ef20a8acd8acc274f2640c86d9917f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/realtime_chain.py": "54ce38eee977a8fac6c12fcf89bb0d5b0b09c884a13c5511d07f1162078ac2e3", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/realtime_stage.py": "c4664d770fb65caedf02e1bc8d8458f3f67f711e347b240b2c94e3be789423d3", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/refiner.py": "41ec01eb88b0607164f953a53f5ad7fc9ace96e5d2ebead573d9684cbd80cb8b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/self_forcing.py": "52dbfb8187e6bdf72565a27f05c6724e360067f101b30458e03e6a92aefd377c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/streaming.py": "7556d57853d3a8880b3c7becd0f0342316e7a7c8a15c8c6347df60d8f451424e", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/streaming_refiner.py": "eee37cc2b25e637be9b1a5b41f021c21d53058d9123ca26e451bcb84dc63aa39", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/wan_ti2v.py": "1ef1e949e4281b4d66270ff1b46c0494e833b1e3057284a17e7fb079f483a42c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/denoising.py": "96a4afbe87e09b25b47936edf0d7a4a7f7595095103d35d57ee2bf7b1eb016c2", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/flux.py": "51445836cc46bdd17057fdc785a746a7ad1e6c20998c05d873b5d195358d7e82", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/flux_2.py": "90666826b8268bf1c220547e526b39ad916e091ef3c005e71a248fae283931a8", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/ideogram.py": "199950972f3d0320035a6448e435280f4afc9f2247af1be5bda38ff2a2183e72", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/qwen_image.py": "674b0f88531a624c24465a111b5da1bc2e088c17535d75dd54b230ba0250232b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/spectral_ops.py": "decd473c34592ad614f49eaaec1948860b89a30e188c60f63773de408e795f06", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/upsample.py": "67f79e1d35cf767c7d0893bba92554d10b46e74c35aa0b3601f1831673b55be9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/wan.py": "01e20f8f4ad778a1cd63ca358830ec03c49438ec68d19fca398925b5d817c2e3", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/zimage.py": "02d7b39de22f513243b2ea38e691b12fba01ebe376dd893047eedcda15af99cb", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/__init__.py": "4e797ef67941ae4007d47b16fb2ae8690ebfa20e73c21a94cbcc6ec82c629b70", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/base.py": "5709aae23ec0677bf87f79de569fcc4a82cabdada048389084dbdf373e10a01d", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/input_validation.py": "4960abc43e241570e3b8821e5f1e1e7d02f5371cc099292a8b52d1627aeed676", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/latent_preparation.py": "b2e9913b190da21732267e61c7c2270818634e3c8efef99a17c20fabb11c338b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/text_encoding.py": "c255839e213e174b3de65397f3e74decabdbaff33a9a77310496617b16bcaf97", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/vae.py": "c3d377fdd3ca540ba132a0b0f37d8379c7a87892ce68cd0e04801763729cc4fa", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/text_encoding.py": "db0622740e6d6ffdfad700cbe9ac5aebd79b9b7d4fca2585bc80670fe9c7567a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/timestep_preparation.py": "1967429c4319b340f37598ba34602025d11b3bc331f1177d2d93d9a1b582b445", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/validators.py": "2c9cd061911c1bd701a2c10294ad081168a12d895f19cd0349c30936348812e2", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/vla.py": "e31a04dd06e3f5d5ff1f76d4c3f7b22e231033f92a41cc403c38dd7800b47d18", + "python/sglang/multimodal_gen/runtime/platforms/__init__.py": "5bb4932af140e12b2c3bb25df663b648d7dd31ca9caf0bc11ca1550549c6b65b", + "python/sglang/multimodal_gen/runtime/platforms/aiter.py": "7a49bc177acf80e4555090af7590dbed1e07cc34616b746ce9f1a92ed48e9509", + "python/sglang/multimodal_gen/runtime/platforms/cpu.py": "d8309690b0430ad0b2c24090dd98e2c9f8fec4e8621e06ffe6f4f291a9d37f6b", + "python/sglang/multimodal_gen/runtime/platforms/cuda.py": "75e193d697ed7c92eb56b57d255270b0e66cae1d07ed1beaeb34c2275502e2f4", + "python/sglang/multimodal_gen/runtime/platforms/interface.py": "c930fa459065ba6e0376f40fa79e901cab6fd88b1a9c614ecdf211ddb46aeb0c", + "python/sglang/multimodal_gen/runtime/platforms/mps.py": "104fe9a5c7cc645a56b0752d06107ef96053d856f19165872ef2f8ddf986dfd9", + "python/sglang/multimodal_gen/runtime/platforms/musa.py": "311867736d12a2577c791281290444c9dcaf1e0047eae804794e5802b94477b4", + "python/sglang/multimodal_gen/runtime/platforms/npu.py": "fdbbfc977a3136add00574f1859d9f2c3a43cf1cd6439f700c1ca0dc891f0172", + "python/sglang/multimodal_gen/runtime/platforms/rocm.py": "fe9cef509a49647a9f3cb8b65fa1d5cb2b86d4d7a0d6327989209899c592c06c", + "python/sglang/multimodal_gen/runtime/platforms/xpu.py": "ddc912e9062e44a2fe550a2d5d37b22534eaf2fe5fdf125206fb30d13b1a1371", + "python/sglang/multimodal_gen/runtime/post_training/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/multimodal_gen/runtime/post_training/gpu_worker_post_training_mixin.py": "e1aebeb72bef4c1ea5ba989952aa05e8bde09a5af3e0d5e9012433f783077e99", + "python/sglang/multimodal_gen/runtime/post_training/rl_dataclasses.py": "c4cfb89c970281779e76bd8121fac8492fe013b97166f62d0b88f851b4d9a066", + "python/sglang/multimodal_gen/runtime/post_training/rollout_denoising_mixin.py": "10305a821b163434eff8416bdccce16bddc5983526d8d300ebec6e4988d8447c", + "python/sglang/multimodal_gen/runtime/post_training/rollout_scheduler.py": "aa8f161c0fe0609be9e3de959e40df57c53b276575689f782a113fb1f317a4a2", + "python/sglang/multimodal_gen/runtime/post_training/scheduler_post_training_mixin.py": "095f61d7300510896007c403a88a6421e9c82aa2b294e6d48efc951afd3f3f2a", + "python/sglang/multimodal_gen/runtime/post_training/scheduler_rl_debug_mixin.py": "ceb15bac24baea41a718a4c538ba1a98f2d07d32a579ce4f70407386121df58a", + "python/sglang/multimodal_gen/runtime/post_training/scheduler_rl_mixin.py": "9ffa667d04fb58ed1f92339f8af3d13858ac942b026362e8dd94dfe420d0a6e3", + "python/sglang/multimodal_gen/runtime/post_training/sp_utils.py": "c24b4c63676632001857b19ba96aca5ede62c7e3e0c058c627dd472c12c51464", + "python/sglang/multimodal_gen/runtime/post_training/tensor_update_checker.py": "d848b68cf1a0998cdef6d5122bd6ede88bb191dc9625fd2b1d7584e2289549d3", + "python/sglang/multimodal_gen/runtime/post_training/weights_updater.py": "e186916d3a674d5fe63a37843617de10adf77728103062cbdb87c1832cebadfe", + "python/sglang/multimodal_gen/runtime/postprocess/__init__.py": "20ee20c21e544591bb88333128438e87c26a9a9abaa78f9547e131b67ac9d920", + "python/sglang/multimodal_gen/runtime/postprocess/realesrgan_upscaler.py": "a7181cdf15394b92ca5cde3b638fdb9430b21ffaab302e7b255556135b44e749", + "python/sglang/multimodal_gen/runtime/postprocess/rife_interpolator.py": "cdd703be5e99188602b2d7c00ff65e65742987b10fe9a42a50989a3f96c75242", + "python/sglang/multimodal_gen/runtime/realtime/__init__.py": "bb74a0238ddd0e18db8a608b28b0a95773af8976fa7411ec4cafed7c56233ab9", + "python/sglang/multimodal_gen/runtime/realtime/control_signals.py": "62ffad1ea2a6fdb326cb938972af040a77820f1a06d7e7f1a673a9e54a47a048", + "python/sglang/multimodal_gen/runtime/realtime/session.py": "c88d017f2bfcbf643ee8d58eaefb7ddfbdebcb91321567ef9489dde79141755a", + "python/sglang/multimodal_gen/runtime/realtime/states/__init__.py": "55e92a843e0c48d0cd42cb2ec58b5a276421d22e78b0b3bcad320cd0f6a678bf", + "python/sglang/multimodal_gen/runtime/realtime/states/camera_control.py": "07f930c494a88b588be5d19eeaa995e1e135b8994f2aadedd31591ee4b01951b", + "python/sglang/multimodal_gen/runtime/realtime/states/causal.py": "4cae131ae8996d587653a3f133e9635ab091b929704f797fd5fd31f9a3b0950f", + "python/sglang/multimodal_gen/runtime/scheduler_client.py": "840763aba125ad921e8110d3080a1b423dcbe7f15adc875997986d12ac96d18e", + "python/sglang/multimodal_gen/runtime/server_args/__init__.py": "ebdbb25077de0323534a461552a1fd35cd0bf37883f3af853ab31c6774cdc210", + "python/sglang/multimodal_gen/runtime/server_args/auto_tune.py": "e81265cf01d8118292a177bf142be1ad3ec0e6b101ba01e37e03983371c9507b", + "python/sglang/multimodal_gen/runtime/server_args/disagg.py": "42cd66c907417cb2f2ea6175fd730ac78110468877b41c72d8f01373b248d5f1", + "python/sglang/multimodal_gen/runtime/server_args/server_args.py": "7a9fb391c014b1f08c0a495d6f689f26ea554c61ca1680ee57d6e5f7b672f3e6", + "python/sglang/multimodal_gen/runtime/server_warmup.py": "01636abcac02acec198bcd97daf1610c5e93c90cdc8affb8034d10c6ce5b5f03", + "python/sglang/multimodal_gen/runtime/utils/camera_geometry.py": "1f83ee08bf6f55f3f59e07a6a0c01c4eef23f5f4a29bb307101c5727a086cd1c", + "python/sglang/multimodal_gen/runtime/utils/common.py": "3337dfa95b8821723c1d642b3f5dc4f00e24c19b7e739665a71705b6423894ff", + "python/sglang/multimodal_gen/runtime/utils/component_load.py": "b99183a600bd3fa8e9b9ce2dd569b8cf4b3f0e4aeb4a594cd562e4001ccbac9a", + "python/sglang/multimodal_gen/runtime/utils/condition_expansion.py": "577778dcf46e171f944747e7e583b67b3f413a4a09a0cebd9adf9610873bd1ee", + "python/sglang/multimodal_gen/runtime/utils/distributed.py": "22de4ef9e9c8beb9f18f3e938956d67bbf98f0ea75682712388a59a270f4cb85", + "python/sglang/multimodal_gen/runtime/utils/hf_diffusers_utils.py": "827f328740f0f6ea0b0760412ee615cc8aa9a51a9eb2eda509fee859327a0a1c", + "python/sglang/multimodal_gen/runtime/utils/image_io.py": "fdf1f4c36faee71bdda18a90b9eb7877d321fd382c4034a1e4e048b6af5adeb0", + "python/sglang/multimodal_gen/runtime/utils/logging_utils.py": "9b10037166b203ecaa859710481a5e1d6c1993ecdd3001d6804df0ff69c62385", + "python/sglang/multimodal_gen/runtime/utils/mesh3d_utils.py": "dcb94dac457c7e58782915115e5eaf4a012370363e8566d89ad29eebdbe82ba7", + "python/sglang/multimodal_gen/runtime/utils/model_overlay.py": "dc80fe7529e39587e5b3cbb9d76d4c6f74d0d8dc6f1f72e0c3e69926115540d7", + "python/sglang/multimodal_gen/runtime/utils/nvtx_pytorch_hooks.py": "0fd3943870f48e1b342c74c43d54713b89d0bc51b1c19c1c2777dbf9929f9cea", + "python/sglang/multimodal_gen/runtime/utils/perf_logger.py": "d5de095f14cfec2258d3f72b18f5754a1d0ec567736a6407ee14f76ad2dbe522", + "python/sglang/multimodal_gen/runtime/utils/precision.py": "2941476e01609abb128c4cd0fa1a7c554f575ba69ad16b558903c5cc8a3edb53", + "python/sglang/multimodal_gen/runtime/utils/precision_types.py": "c6ebacdf38bc674a57a95b31f4fd0bf7ef1025a2432a83030573383c27f5e6de", + "python/sglang/multimodal_gen/runtime/utils/profiler.py": "fb9935d1d4e22f2b4329dd247909c3a46c1aefa35a88f5645bcdc2fd708ba6d9", + "python/sglang/multimodal_gen/runtime/utils/quantization_utils.py": "d12d7cda40415371c406516ef911ed5e670b993cab25fdad30ec4827f5dc6246", + "python/sglang/multimodal_gen/runtime/utils/realtime_video.py": "dd337946b5039d47b896b2d665e0137dc703d89db4d7abe9ab3e50d714f90acd", + "python/sglang/multimodal_gen/runtime/utils/request_logger.py": "ece900b3123e8e6340a62bc7d10afc0cd35b8a62cd3315b421cee8ad48aabfbf", + "python/sglang/multimodal_gen/runtime/utils/torch_compile.py": "67f01e9dfec936624df2fe77232ce9af57fec1618f7b02c835a244266aebdfad", + "python/sglang/multimodal_gen/runtime/utils/trace_wrapper.py": "7811b8bc666cce8f1847c2cc4a009a3d4671eb34642fb61ea2cbb210acd2406c", + "python/sglang/multimodal_gen/runtime/utils/vision.py": "c731c2f579c3be880c4810e60883c3a0048bae6583dc05bd8e3318baa9b67e47", + "python/sglang/multimodal_gen/runtime/utils/weight_attrs.py": "a803a937c1bb2dddcb675213b7a75baad0d988ad79c62d31b35db3430463fb47", + "python/sglang/multimodal_gen/runtime/vla/__init__.py": "72611bc6b62a2a01eb7f593b973d90affc93ffb78885d3a23b36a6b2563737fd", + "python/sglang/multimodal_gen/runtime/vla/cuda_graph.py": "c9b6d3d07727dc53914b80f7311bee449cde52ff2748280d420702f361c2ecc9", + "python/sglang/multimodal_gen/runtime/vla/observation.py": "f05173db6fa20ae11929b32fbd4f895a8f94b1173d412098381f0d75ed46ed92", + "python/sglang/multimodal_gen/runtime/vla/parallel.py": "1bc23d893e8c9cb9887a4d8822dc45add7589fbb80324cbf72d6be4166891221", + "python/sglang/multimodal_gen/runtime/vla/prefix_cache.py": "40ace0b366e9673b6414695765b3f2aded8f2944779275ed73d9439cc5a5ccb1", + "python/sglang/multimodal_gen/runtime/warmup_request_builder.py": "9f63342e9453603a56786a93dd6ea3ff5b2d06b9ecfe6a901c9c51f1dcf45491", + "python/sglang/multimodal_gen/test/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/test/partitioning.py": "127c20a8b3301d5825e29932c28eb74ef129ec20d9c16e77b3a13d574940fbdb", + "python/sglang/multimodal_gen/test/run_suite.py": "5785b26c1a621cb7a8ba7b506a98ff07a239293310bc4f45a531cbceb5f74fd2", + "python/sglang/multimodal_gen/test/runner/__init__.py": "17587a799b45c0a19d8a9d2c1bd563ab2a1ef0ff62b4a79cabfbc1c8c2f8545a", + "python/sglang/multimodal_gen/test/runner/pytest_runner.py": "522b5141b729b12260723da698dcf82b75a3bee88320e6e9edaa02002b173bad", + "python/sglang/multimodal_gen/test/scripts/gen_diffusion_ci_outputs.py": "3067dd3d119780a9d86ff6709459e4658ae0f3d53e0e7d5e6555e01d07db5783", + "python/sglang/multimodal_gen/test/scripts/gen_perf_baselines.py": "adef171719472280f161d53eb72a5d43277fd6128cec9346c9300a2900095099", + "python/sglang/multimodal_gen/test/server/ascend/perf_baselines_npu.json": "4437ceb952fe205a1da70bbe6ea309895e6b951b674bf89b1d78f961a6cab18e", + "python/sglang/multimodal_gen/test/server/ascend/test_server_1_npu.py": "adedacdaf2f2d26439a30b18165a5e84b6b273521384012a0a6524956be0356d", + "python/sglang/multimodal_gen/test/server/ascend/test_server_2_npu.py": "d17e7a94ac9b712cb330d6d70f76aec3d93c1eaee783e9f5fdd4c2fab1eceebd", + "python/sglang/multimodal_gen/test/server/ascend/testcase_configs_npu.py": "add9064c389abdb21b274932bc5aff35164d18f7be9518d6bd1f413549fad2dd", + "python/sglang/multimodal_gen/test/server/common/__init__.py": "a33a6e1266b4ec92e3a20d365cac1bd96612545a5f5aaa1cda1309b6f741fb53", + "python/sglang/multimodal_gen/test/server/common/case_fixtures.py": "16b5e8d20a1e74f6efc0513cd6347343baa59fd249a44ef29e4e09fbba68fda3", + "python/sglang/multimodal_gen/test/server/common/slack.py": "ec3beb52a4e8c51f221b471b0eccf9a21a3259ecb3b5b95768e152da6bedd473", + "python/sglang/multimodal_gen/test/server/configs/cache_dit_scm_config.yaml": "7be6aaa922d1256c7eec2ea866433fef59b83eab5cce616e392dff412b12fc5d", + "python/sglang/multimodal_gen/test/server/conftest.py": "c0e7af08db1f33060e06be7b1b83b2b5238c57805a54434d7907de4f238b7a5b", + "python/sglang/multimodal_gen/test/server/consistency_thresholds/5090.json": "2f8dbf71209a5697c55e3c43093652612d05c1d883dd2a6924bc1de029e07218", + "python/sglang/multimodal_gen/test/server/consistency_thresholds/b200.json": "c19f6c9403ce1b2e8ff22311d16aa1e50ae310cce3242ca80d66c22ee3b651c9", + "python/sglang/multimodal_gen/test/server/consistency_thresholds/h100.json": "b39b85a3987e8a611a9fff1d61ddd70ca8843bcc4a1c6fa9623c6ef2862163d5", + "python/sglang/multimodal_gen/test/server/gpu_cases.py": "e78fc306fad631050a8d1e5f6b311dab17e1ced9e53e52aa657a6ec19b28aa55", + "python/sglang/multimodal_gen/test/server/musa/perf_baselines_musa.json": "76bb570e6005c4c9602c1c9998ed405f10e97752ae73e803bc133a16dea14967", + "python/sglang/multimodal_gen/test/server/musa/run_suite.py": "17da70de107c4250d1a52294e9fb7599756a402f731e24cfa8e06b8f2d360792", + "python/sglang/multimodal_gen/test/server/musa/test_server_1_gpu_musa.py": "77a53681073e5807c153b8c8d743cfb7fdaa2075a6c34e5a122c5a77594ecc4d", + "python/sglang/multimodal_gen/test/server/musa/test_server_1_gpu_musa_nightly.py": "5ef291bfc18c02f1ad701a8b1265a1c4f75440eeaa95d2c19619fe4306ec5225", + "python/sglang/multimodal_gen/test/server/musa/test_server_2_gpu_musa.py": "ce2456d248bdcfe601529bf320965120721cfbaa15cfcee3d202c46565b4d3a3", + "python/sglang/multimodal_gen/test/server/musa/testcase_configs_musa.py": "b8a993d183b288d23f45dc30e084b31d20be88004bf4cec8ee712962cdc23f0d", + "python/sglang/multimodal_gen/test/server/perf_baselines/5090.json": "9260040f51700f6e43e6ec6ce39b366b3090427516a54db4b625a9d1cc393ba2", + "python/sglang/multimodal_gen/test/server/perf_baselines/b200.json": "89f04a7307863fd2aedbb4070b1d70fcb436af644347ed57180922c25ac20f29", + "python/sglang/multimodal_gen/test/server/perf_baselines/h100.json": "a41e2d3ae76e4188f62a5043bc6e8f27dad53fa5950f388a0d2f84398673e997", + "python/sglang/multimodal_gen/test/server/realtime_consistency.py": "248069269b7a98d4a1581afff21c2637ee5fac06666243746041beec8977ebf3", + "python/sglang/multimodal_gen/test/server/test_request_logger.py": "806c3ecaf732740503bccbbfecc21e17eb6e93400cc0010bafb1c3ba729eb5e8", + "python/sglang/multimodal_gen/test/server/test_server_1_gpu.py": "8ece23a8aa163fa347966610f694950f69cac3b82f90adff377aa09a7b13a836", + "python/sglang/multimodal_gen/test/server/test_server_1_gpu_5090.py": "880a6e5b8857285f28917a3e737f77e049df5720d94ab2f6c00051cbfcc61db1", + "python/sglang/multimodal_gen/test/server/test_server_2_gpu.py": "3c3c48d0a91b4a8f6f7ad0bfa694ce2c025386d46a71c3c3156d648cb8cfdd9b", + "python/sglang/multimodal_gen/test/server/test_server_4_gpu_h100.py": "677aef54687fd5c5f498f562784e362763d5d885c1ab2309959ef4fbca418e94", + "python/sglang/multimodal_gen/test/server/test_server_b200.py": "a2fc33120d704e64e89d5c5713704ca52dc9106e5f89e563b19d454119a46e64", + "python/sglang/multimodal_gen/test/server/test_server_common.py": "c3d4e392b135f9dfa290a20fd42fd955739246ad433516875f45d38436a85785", + "python/sglang/multimodal_gen/test/server/test_server_utils.py": "cdfcac431a5e37553332f55a8649b023e8824e827a037cbbb59a231edf0368a9", + "python/sglang/multimodal_gen/test/server/testcase_configs.py": "02629a142a0ba96de2b628121e0bdabb3120f03e475f37284452eb832f8733a4", + "python/sglang/multimodal_gen/test/single_test_file/__init__.py": "24a42a7936cb2adb6b925e7751516cdc351ee72b4b7b9cb009da2018f5f587a8", + "python/sglang/multimodal_gen/test/single_test_file/cli_generate_common.py": "3f55cc9522e6612b2928a8ad1d73c067ec6a91c895d2b58dde54d2ecf6977eb8", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/__init__.py": "1c95aa916035e3af308a2fabd8fc9227325f85cef2560279e48db633f3702f70", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/config.py": "068e239a444766c3a8fdf561d92c203796629d2087b23a3ee6f228cdfa2086ee", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/engine.py": "f1fc4fb903fd56b4e33465b6faa61380925e3a0260e4a6b709270efe8893c155", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/hooks.py": "b66b3c788f840ecdd70ace046b282bf5bd51d15f8840b1539d0cecc6300f473e", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/test_component_accuracy_1_gpu.py": "1649af1159df0f358137e4a6101867154076d8120a2ba4d1ce6158901bd0f97b", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/test_component_accuracy_2_gpu.py": "97c9f6209dd47bc547f9678ce0101794160f9392dbc97c2d7a05902d7faa41fa", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/testcase_configs.py": "db538500a798acfeecd27c3151a918dce33c8552cae17684a21d5217e65c3dfc", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/utils.py": "5c642f9dc49caa230728745a269a090241191bfc1c043dae54c3ad8fe0189926", + "python/sglang/multimodal_gen/test/single_test_file/test_ar_models.py": "a23638ce14d90e6986928cfcfc968af6eb2788dcb9b3195a995c01b1dc5e602b", + "python/sglang/multimodal_gen/test/single_test_file/test_diffusion_bcg_tp2_zimage_turbo.py": "a824db2c8d1c46e91f7109a7476424919ca09057fef12944ec0ac1cb08826e01", + "python/sglang/multimodal_gen/test/single_test_file/test_diffusion_bcg_zimage_turbo.py": "5b56b8c2e1a751c8405c267c4a40b3bbf39a84125e6b70f3527a0b91a800f899", + "python/sglang/multimodal_gen/test/single_test_file/test_disagg_server.py": "bfc41aef3576630bc0dc4d8cbc614b8dab337adc698d79ba0a060828c98ef694", + "python/sglang/multimodal_gen/test/single_test_file/test_dp_serving_2_gpu.py": "0485ac2be9f9b9538af9b4217b061e4dfd24d7fd87b28ab879ce20cf981e9018", + "python/sglang/multimodal_gen/test/single_test_file/test_generate_i2i.py": "ef65c19885923d141a3e62cef060ae2e5ea63ef31ec28db8d53f84535a3b4d34", + "python/sglang/multimodal_gen/test/single_test_file/test_generate_zimage_turbo_cli.py": "f0a66ddc1cae8b5451d6d4cc64afeeebe2ad745e0924c331d1f20cce4f4107af", + "python/sglang/multimodal_gen/test/single_test_file/test_ipc_a2a_2_gpu.py": "5676488aa36a01cb4465a94db240ea536439f484af282e26e9f2a0166c952f12", + "python/sglang/multimodal_gen/test/single_test_file/test_pi05_e2e.py": "6aee29b2a863dc63eb5e21b3a3050d3b36915b2f3106bb6557537a1046a40e1a", + "python/sglang/multimodal_gen/test/single_test_file/test_pynccl_a2a_capture_2_gpu.py": "00763779cdd7af3a94629b1da95a23a05371321cb88105d125ae40a00841f4ba", + "python/sglang/multimodal_gen/test/single_test_file/test_update_weights_from_disk.py": "b0e1468d6deb8a501f8fdce1ba625690eb1b2a0c476f157f015a2c12bebcff29", + "python/sglang/multimodal_gen/test/single_test_file/test_usp_replicated_parity_2_gpu.py": "7e0129fe1c081c55a471c4bebe17a737ba53362a2cbf90e2557fe2704fef43c2", + "python/sglang/multimodal_gen/test/test_utils.py": "17c3be6aaf3e392f6b6171cc976d06631b142a7483c588b840e2411c04c22b42", + "python/sglang/multimodal_gen/test/unit/conftest.py": "2ac87ea8d2fa630edbc3672ceda2e3837badb31dbe97e3d12d2ec8004a96fd8d", + "python/sglang/multimodal_gen/test/unit/manual/bench_patch_embed.py": "4525980fe6eeb24c3120724758bfb0f47020a56d92d4f7163095fd6f7c394596", + "python/sglang/multimodal_gen/test/unit/musa/layers/test_musa_rmsnorm.py": "79f8bc273acecea5107f4ae5bed7a949b6afcb3574c54356e25b780b75cc0044", + "python/sglang/multimodal_gen/test/unit/musa/layers/test_musa_silu_and_mul.py": "bd9dfab06e2d7279be68f4bab2722fc517e683f9c56c6fcd550b289a06e4ad45", + "python/sglang/multimodal_gen/test/unit/progressive_resolution/test_progressive.py": "a3501a5a78df433f78ce3e40e8c2885cc4ef16f85b64088ccf5abe55d003ca55", + "python/sglang/multimodal_gen/test/unit/realtime/test_causal_denoising.py": "1163d8ee78e4d6918aaf22f4b7d12132509073864d633c2152b1c336a499a5c5", + "python/sglang/multimodal_gen/test/unit/realtime/test_lingbot_causal_denoising.py": "a1e26a1d832b073f81c94b5fdb155997dfe3702bbc55461217559ecb8874b902", + "python/sglang/multimodal_gen/test/unit/realtime/test_output_materialization.py": "f31a490b9ae2fc0d908267455e1a889ac5de28f1c29b7ed94286ccf36ff67fb4", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_consistency_harness.py": "5dd4268658b93df53c0ff6f950da100ef6513b69abe15ede8b7740b5058373f6", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_control_signals.py": "ccd8038b430fe8f2773e9ed88d4dad3e1d309cf0c1da19faf8445be3c32245fd", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_output_transport.py": "72829e0c0d6931a520f5e7b0ab13740f9a2c058b26a2ca6d5add756cd8d993be", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_runtime.py": "5cb2f47955643016c3a046cf5afa64004a472ca57dfa9909b34c1e09a84fcc74", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_vae.py": "cc58da5a5bbbfbe9490a271d96a67be8a8200e28d888e396c569a3d78a69db12", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_webui.py": "fa8e336bf234a0da55a939b8aed22368efc3348b8fef0d664c17e389779cfa04", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_pipeline_config.py": "6f6c7f7d054872b91ff6343d0f6adf23998c97bf42dda8c33258fd6565d0b2d5", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_realtime_chain.py": "1d6de8f81a1b7a5116daa5fab95d32aade85fdc403ec7f72cfc2954e79d8835e", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_cached.py": "a98e85518d66ada93f21e09e957f7cceaf38629c08b52657733a58ddb44e7327", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_forward_long.py": "6f6fe0a962a18dbe1421a71f677bd5053c2e6a09e49211dc4deefae7bb16b421", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_realtime_path.py": "8d2df2a9789005b200ff9c447028867d81cb639ce0547b1bdf4034bd4a001c9c", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_stage.py": "90a1af040050667c96c5a6617a2f2223a7d390cd08946263795bc69bbbfcf1cf", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_vae.py": "5cf1d8883ebf87e1cbbcc2c2ff701676743eb51aef90e0ad05f1f54beff6e95c", + "python/sglang/multimodal_gen/test/unit/test_adapter_loader_offload_target.py": "578ebe6a29f8b283677e08ba928d52959a17e992e7402866d1b1ea1c5ce94a3c", + "python/sglang/multimodal_gen/test/unit/test_attention_backend_selector.py": "2513e4878d6db0ac403802fd5da6f2baa9e99a1d3293761e0c1212b09eb84c3f", + "python/sglang/multimodal_gen/test/unit/test_cache_dit_integration.py": "9fc9d62e39d14ec41463c90f475b3a718157f73f53f0aae6836c36bea1b8035c", + "python/sglang/multimodal_gen/test/unit/test_cfg_gating.py": "1e20054ec9ee3ec24cbe0a78c9c1932efb035659720a7a2e02a40c9a90e2b371", + "python/sglang/multimodal_gen/test/unit/test_cfg_parallel_warmup.py": "bb20413567e84e8a7a6154ff68d8987c2bab64f1043927e7ec34d79499c01cae", + "python/sglang/multimodal_gen/test/unit/test_cfg_policy.py": "7d24b78ba63d88bcd7bc36b3970f83aae0e8af83ec20c15176272cedbedf1437", + "python/sglang/multimodal_gen/test/unit/test_cli_generate_common.py": "1347c119117717ec3d49edd4f601ca2391b4f68544c0175648d8af68e3dd2bcc", + "python/sglang/multimodal_gen/test/unit/test_component_accuracy_inputs.py": "1acc11ecf4b244dde2577d3ac712af182849af7b7a131aef99139b7a6faae550", + "python/sglang/multimodal_gen/test/unit/test_component_accuracy_parallel_runtime.py": "3014e8a0499abc002aaa636a33893484aab81662ba7020fe53cec9ce9ab9182c", + "python/sglang/multimodal_gen/test/unit/test_component_loading_order.py": "8a7c6b214e32d4382e43cd8948ab97b21f3cd2d83741bed1f2e970afc9ff6202", + "python/sglang/multimodal_gen/test/unit/test_component_residency.py": "67fcb9b7640bc5ea5bf5c4ba08e0afefc296154a0fa2bf34d8a43776f570fe90", + "python/sglang/multimodal_gen/test/unit/test_consistency_metrics.py": "0be386f51a19b61c27e452fac37c60b25b4331f1bc451e52b490e52f09d0cd45", + "python/sglang/multimodal_gen/test/unit/test_cosmos3.py": "42e0b5a3799d999faf68e1c706ec79c854eddad99c85103d8c6129f44c141d91", + "python/sglang/multimodal_gen/test/unit/test_cuda_attention_backend.py": "f3f0ae523a8b4370330da57362e085f74174b8698925ecea52df02749ad96bd5", + "python/sglang/multimodal_gen/test/unit/test_decoding_stage_parallelism.py": "4fbdfbd05f5b3b7c6347b23881b72460c64567a2cb86f641077abf8225e38c7a", + "python/sglang/multimodal_gen/test/unit/test_diffusion_bcg_padding.py": "dd78c121383dcae2c165d3836322e83c4c6df763ce502767917a5d550424c0c9", + "python/sglang/multimodal_gen/test/unit/test_diffusion_bcg_tp_graph_capture.py": "19a636b99eb07712d9f97a59cd9a038837f8f5b2bf9556b50c6838bebcbf0691", + "python/sglang/multimodal_gen/test/unit/test_diffusion_generator_shutdown.py": "28cd08a46b5595daa5f1bdb39ad3317983d4896921c87ba906460614617d9810", + "python/sglang/multimodal_gen/test/unit/test_disagg_roles.py": "27102c5d53420519123ec89e85b5bd852f84ca57012d4035d12c93768c340022", + "python/sglang/multimodal_gen/test/unit/test_disagg_trace.py": "8c7142b84da8444091fec6db64f6da73fbf09503fdad472fb78b2d54d8740495", + "python/sglang/multimodal_gen/test/unit/test_dit_config_boundary.py": "ae7d407efa9399850a1435b98bcf1569e599d73cd6e3d42b89289c7cfbb0b4ee", + "python/sglang/multimodal_gen/test/unit/test_dp_routing.py": "076f2ee98e4e2690bfdd4fb85d0162500197a27819f859c4bbbbbe05174e5638", + "python/sglang/multimodal_gen/test/unit/test_encoder_world_folding.py": "cc5b26ea0db3e4041affbe497b8f4748eeb2b321cfbb2b36ea096ce8663e207a", + "python/sglang/multimodal_gen/test/unit/test_ernie_image_pipeline_config.py": "b352aaa77c5d10ab3b9f7a43c690f167372c770322c11edb2e9c74be4406d85f", + "python/sglang/multimodal_gen/test/unit/test_ernie_rope_geglu_fusion.py": "86d4931d5f99910610067c4d82dcd6813278f0482c817be23c237c8c13969854", + "python/sglang/multimodal_gen/test/unit/test_fp32_layernorm.py": "272897d7c62651e3f3a1edfc4b0f084b8464bdf182f459dafa665204167336fd", + "python/sglang/multimodal_gen/test/unit/test_fsdp_load.py": "b3afe1b8aa1e19d4365f5a73afc75bd054d361aacd640f708adae2f561442a53", + "python/sglang/multimodal_gen/test/unit/test_glm_image_ar.py": "a87d294fc4a4a3ab99fa2148d6f3f5bf7dd49855fa623fe29ffb354d3aad729a", + "python/sglang/multimodal_gen/test/unit/test_glm_image_multi_output.py": "2827c181edb5cb2b297160bb007212f530a047034a4c46d31e4914d19480505f", + "python/sglang/multimodal_gen/test/unit/test_gpu_worker_cpu_threads.py": "4f54f1054b81d715106ddb25090bd3b65665aa2680a63c5a22162d4d62dc02d0", + "python/sglang/multimodal_gen/test/unit/test_health_warmup_gate.py": "e327f6f299eb3470c03c0266f88ad958d7ecd54d3907ae60ce0dda9e1474089b", + "python/sglang/multimodal_gen/test/unit/test_helios_denoising_profiler.py": "fec0ad51a1d3af2ecef97242790cb5f1e0b49ecf9ee8c4c08852166a1aee663e", + "python/sglang/multimodal_gen/test/unit/test_hf_diffusers_utils.py": "a92df55b375b10163786a9d88495c0ec942c4433aed7ca6cea242e5156a635a9", + "python/sglang/multimodal_gen/test/unit/test_hunyuan3d_native_texture_models.py": "bf691073f61a320301720cc910c241851be0e7fc1b4e48129b7f7ce87a755a0f", + "python/sglang/multimodal_gen/test/unit/test_ideogram4.py": "13686014594d1ceef12f6668d43c3b0929dded27c918555d6bb66cac5f8a48f6", + "python/sglang/multimodal_gen/test/unit/test_ideogram_rope_swiglu_fusion.py": "1a580c0c600971e3f9af450f0d3cd13a5eef73230e983905fd2eedd92272cd52", + "python/sglang/multimodal_gen/test/unit/test_input_validation.py": "e2974f836d082e646826fb0cf2fa82d00e78c6a294330351676993e7e32553c9", + "python/sglang/multimodal_gen/test/unit/test_ipc_a2a_lifecycle.py": "6dd8d8bde7e0f3d75a2ad7db46e1a6c75a35ded5a3f3772fe51a9b297ddcc95b", + "python/sglang/multimodal_gen/test/unit/test_ipc_array.py": "48e111472631328dd37507c105ac937f877d201a9bf9e64fccf3e0068f49d7f6", + "python/sglang/multimodal_gen/test/unit/test_krea2_fp8.py": "6626ee3f00bf29c67b247be39c5b724f9d37a90bcb9b28a2ca723cd5cad1e5ae", + "python/sglang/multimodal_gen/test/unit/test_latent_upsampler_group_norm_silu.py": "cd3e5cca062518d6c03c9e9c43fc56259b30be20041cec5286b4d5a9846081f6", + "python/sglang/multimodal_gen/test/unit/test_launch_server_shutdown.py": "a1717d0b2473e40a95b15a3b2b755da9ac2d89667a581e0125073758de288a9c", + "python/sglang/multimodal_gen/test/unit/test_layernorm_cutedsl_dispatch.py": "44a9ba2a8805f68e4be49b83333a232a6665dc9b5ea193a5b4a481f615457ddb", + "python/sglang/multimodal_gen/test/unit/test_layerwise_offload.py": "a67b25e5d6503e03632d9ff4c26f2b1b6ad0b89202ca977c549bb23a2b2273f2", + "python/sglang/multimodal_gen/test/unit/test_lingbot_video_moe.py": "4f7aecf27ed3eb8c16e90ff18faf37ae57459d95d1fd4e19ae71073617625844", + "python/sglang/multimodal_gen/test/unit/test_logging_utils.py": "382884ea99823127654dc15792fcad74073a468651bad714560f87100b3b3e0b", + "python/sglang/multimodal_gen/test/unit/test_longlive2_pipeline_config.py": "553188dfc039669b9956a47daa5013b4c8c8fafd6d7f930fa3504d5de8cafb1b", + "python/sglang/multimodal_gen/test/unit/test_lora_commit_as_base.py": "363492884902832084a9bad92052ccaabe416bf4511929c3119108a6f6e676a6", + "python/sglang/multimodal_gen/test/unit/test_lora_format_adapter.py": "b2c1b2c0300b6b41f58029162768a29bc8fb019dfaa806bc86feca3b156f6740", + "python/sglang/multimodal_gen/test/unit/test_lora_inference_mode.py": "46d22617d42d50d2b6e12d765d27da90067bc33f22c042149cd560b0d400b8b9", + "python/sglang/multimodal_gen/test/unit/test_lora_pipeline.py": "3277b68c2c1437dc3f4898c9ea634418382e348937de6f9bbb07477203254148", + "python/sglang/multimodal_gen/test/unit/test_ltx2_5_config.py": "4228ae199153304dd967bc4d99ff33992bd604eb630ac96b4a05d879247f0caf", + "python/sglang/multimodal_gen/test/unit/test_ltx2_bcg_coords.py": "7a154db58df5e29e79c9121450f5e51c3c8a22fb479b15f6bc6add01b03bcedc", + "python/sglang/multimodal_gen/test/unit/test_ltx2_modulate_mount.py": "811f10ec75e86049beacda79e481fb5b44686e2fddfbd6fec1e391cb9040bbaa", + "python/sglang/multimodal_gen/test/unit/test_ltx2_vae_channels_last.py": "94bf38ce6c1ba11b34d212a84a1dae790a01f672ac21b21ae6f870728c6704c3", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_adaln_cache.py": "1257d2c83d72f22b28d23f6a73f176311185d5800ecb3c63b3c2691a3f8077ad", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_admission.py": "c1d7675c4cd36fae3f9c3218ddcff1dc11ddbc173dfe573ec80b32ebed3ae558", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_denoise_loop.py": "789fdba13794a31536874c77b271704f7920a2b7b3e597874ddf008496a4092c", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_dit_contract.py": "d1e0e39708c11ca25bdfdc6f55f15cc9a65118ee1464032b8fb7913b582caf67", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_encoder_device.py": "4279b1f78def8f649fe15ce37c44ebc289a777b86068bd5962e64bf3538104cb", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_media.py": "0e5b6fa5849891f82241e020b82f56f517f2ad3a7b1ae786b6910e6a13014b86", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_packed_sequence.py": "ac522c4b66cb122f1a20dc171a43c3163f859522c28dbb106f67c3dce4b7dd36", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_vae_parallel_modes.py": "c224d20e4fefc3fbc53985ee954a7ae96e0232f3e167dff006d2337e2f03fb0b", + "python/sglang/multimodal_gen/test/unit/test_ministral3_generation.py": "8a191b73b8913833c5ebc3bf055241c5b316de01a2c950e06093b5201698aad8", + "python/sglang/multimodal_gen/test/unit/test_multi_output_grouping.py": "5fa6a37a9cf253ea8293355ffd5d4c6b3bf62f2684f21e284cd5e7df3a38a4a7", + "python/sglang/multimodal_gen/test/unit/test_nvtx_pytorch_hooks.py": "570133cc614254a71e53c300c064e566b805f4146d1e0ba477c2ae3647d89266", + "python/sglang/multimodal_gen/test/unit/test_openai_image_api.py": "0b4fdafc55b8a37145df35bf3afe236aece05a2c3916bf1cf0787e3eceb53b20", + "python/sglang/multimodal_gen/test/unit/test_openai_utils.py": "1faa2497375fbafa513b06e3be292b40cd632a8573d34054eb531c575e1e8ed8", + "python/sglang/multimodal_gen/test/unit/test_output_saving.py": "44de3435b4a3b32b53aadc07e4c43e31f638268260d2499c8cd30b4c33fa02b2", + "python/sglang/multimodal_gen/test/unit/test_parallel_linear_weight_loading.py": "1078ab19b38d2a05d50d3cee3f7130b67de32183ef5e9e05d05adfbf8e17e069", + "python/sglang/multimodal_gen/test/unit/test_pi05_action_api.py": "ea32f5fbbdd93ef9c336e7f3dbf4e7d90829c0916fad49132a09336c27d88083", + "python/sglang/multimodal_gen/test/unit/test_pi05_prefix_cache.py": "63807e8798a896c1e9c0bf6a013dea53c06520df14f0347662602a39a814a420", + "python/sglang/multimodal_gen/test/unit/test_pi05_runtime_helpers.py": "2a37459d826e10db7f42346681f482f9bd3fb8b09819be7149159a6194f1f808", + "python/sglang/multimodal_gen/test/unit/test_pipeline_executor.py": "1982aab00c76005a0f620ce0f34960bbe0c27fa66053cca7d114d76a0c767e71", + "python/sglang/multimodal_gen/test/unit/test_pipeline_stage_profiling.py": "7c2b0f47030fb343c522ce209f746316c5c86d21d55546a362d747bc434dedfd", + "python/sglang/multimodal_gen/test/unit/test_platform_detection.py": "98cec8438a7fe11bd34c125ad74f483c460c0ea8a4fee364885292c528523f4b", + "python/sglang/multimodal_gen/test/unit/test_precision_consistency.py": "659d79f1395bd4713bce9041159387c996761d84d5464ff6fbc207caa8250f6b", + "python/sglang/multimodal_gen/test/unit/test_qvg_packed_kv.py": "fc70624be7a3bdd27265dd65db47de11428ff8ce42ce1fd79ce05fa1caf5a728", + "python/sglang/multimodal_gen/test/unit/test_qwen2_5vl_generation.py": "e422d7fecf3bf95c694321b879007107c4d0fccdf7b222356214d14a873252b5", + "python/sglang/multimodal_gen/test/unit/test_qwen3_encoder.py": "bc809d7348a5a85867f76503890d2205a2c10488e46e57fab5844086784bdbf9", + "python/sglang/multimodal_gen/test/unit/test_qwen3vl_vision.py": "3f70dfa66e018234987a65344e3ef4030425b602e784b41fcb3ad3cf9ffcce83", + "python/sglang/multimodal_gen/test/unit/test_qwen_image_layered.py": "5d12f06487dc2260186d53388a5b5dbddd20de6a9541943b8ae9c41c1d4f63f2", + "python/sglang/multimodal_gen/test/unit/test_regional_torch_compile.py": "fd9ae1eacaeb7ebe007b6be16fd0d74cb2450675e3bc7cc3249684d7d339903a", + "python/sglang/multimodal_gen/test/unit/test_request_manifest.py": "abb547707845f2c2b3c8259072be646f78e8ce1fc5cf1079568eddc89b02e2dd", + "python/sglang/multimodal_gen/test/unit/test_resolve_prompts.py": "86d83ef7c1a60b7b7595549fca6a6968ada97feac167669d8d5046f2077107b4", + "python/sglang/multimodal_gen/test/unit/test_ring_admission.py": "eb65b85e26d0bc109290a36b4e3d6f1e79296b8ef2883feb05f86467d8b9320d", + "python/sglang/multimodal_gen/test/unit/test_rollout_api.py": "230b4bfb1c36f1eade7eabbfc8f80eff5b527e192cdcc9384729de9b4556876a", + "python/sglang/multimodal_gen/test/unit/test_sampling_params.py": "572464bd87c88fb9e94bf2d5c60c95486245ed994b08286dd6e968a5932def60", + "python/sglang/multimodal_gen/test/unit/test_sana_video.py": "9b299bbb59f8bcab505731358b069f1f022f42b77959a062dfb8d10135b8af04", + "python/sglang/multimodal_gen/test/unit/test_scheduler_client.py": "0e0f89b7b436f92728ba6cfdec6aa04498076352533b512d714dbe54590ab325", + "python/sglang/multimodal_gen/test/unit/test_scheduler_rollout_unit.py": "45f0fea54e357584202c4ff576fd4d055db938eb7de2b8e7f769962885477c1e", + "python/sglang/multimodal_gen/test/unit/test_served_model_name.py": "640511a9bcbfcdb8fde83aa254840740e937af6fc46c0683ad99e0e99ace6bfd", + "python/sglang/multimodal_gen/test/unit/test_server_args.py": "7d43d677fac5c74597468e3a8c15943b99b5f8297463e37b1b9dfbf4271fcdbf", + "python/sglang/multimodal_gen/test/unit/test_server_warmup_progress.py": "34969836322f4605d1f130d70861e011f8632bbb3360f5fe2ea845ebd148547a", + "python/sglang/multimodal_gen/test/unit/test_sol_attn_backend.py": "60c62121cc51c11ce3e22e47826c041f794851537a65cb9e417ac332751220da", + "python/sglang/multimodal_gen/test/unit/test_sp_shard.py": "21260c6afd868f720beb75070e84c4a8ce9f8142d87d37d43e5ba8c165dd6205", + "python/sglang/multimodal_gen/test/unit/test_spectrum.py": "1ef56f3a12733299ecc05101a1be6fcbf17c4eb150c46eb75dd5499e588fc736", + "python/sglang/multimodal_gen/test/unit/test_storage.py": "432d4874dadf9e6efca474402935cac087536fed28f81c5bfce702c9a8b24fa4", + "python/sglang/multimodal_gen/test/unit/test_subblock_sparse_attention.py": "9639bcf0dd78d20092e8a6d75ef4d0adcfe69217a2531f8dff281c259516d407", + "python/sglang/multimodal_gen/test/unit/test_suite_partitioning.py": "d234973ac26244662524917c2d2a7d8086c0101f6c57d42d6f74dc0f4661c677", + "python/sglang/multimodal_gen/test/unit/test_text_encoder_loader.py": "a907c40435b3996ae022ddcf5160e3689227c538f9c4f1652db159714b061452", + "python/sglang/multimodal_gen/test/unit/test_text_encoding_cache.py": "f5911a1f91a27cc78f171deb1449d0ce7acf270b98550c6ba60db5543df74687", + "python/sglang/multimodal_gen/test/unit/test_transformer_quant.py": "dd81b12b3f01e27d03b4428bad4dad730e063537cdf20cf4a23d1927146cf37b", + "python/sglang/multimodal_gen/test/unit/test_turbo_wan_backend.py": "44ef6c562cdf022231b42c1fd74d3c67d05a01cec4cb3036d58ea9ebbd5f0c88", + "python/sglang/multimodal_gen/test/unit/test_usp_attention_kv_gather.py": "1922296471236f1d0a0c3a8332ff5c4424f406f8bad0877a55885e39b7b27204", + "python/sglang/multimodal_gen/test/unit/test_usp_attention_replicated_prefix.py": "325c9e94eccbb59fe573581ee7623a82e3da845c1f422be82691014cb0c8bed6", + "python/sglang/multimodal_gen/test/unit/test_usp_ipc_a2a_guard.py": "583a816b34ea8be2fd127dae3ee4c41e30c2474d2f60be99635e700847bfcfac", + "python/sglang/multimodal_gen/test/unit/test_usp_packed_qkv_a2a.py": "d2465417704b06b8cb1fbfea6da468d7ed1eddf424862986e264cd84ae5823ae", + "python/sglang/multimodal_gen/test/unit/test_usp_ring_replicated.py": "2728cd0df270cff9fbe030522a6ce313acf8e01ebbd2279fba50c7553dd6379d", + "python/sglang/multimodal_gen/test/unit/test_usp_ring_tail_pad.py": "f5c8e11db115f8c45b5a628372a59ec2ce4bc3e0a3ccb63a57d717007c0f8c43", + "python/sglang/multimodal_gen/test/unit/test_utils_parent_death.py": "cb6431dce85fbb346cb9fd87a56ead1ef4872732ee46f3392c3970c2ba028b3e", + "python/sglang/multimodal_gen/test/unit/test_vae_fast_path_gate.py": "539323a3a03f0fcecaae3c62005722d231e3646399dd32fa837e63f8e282634a", + "python/sglang/multimodal_gen/test/unit/test_vae_loader.py": "389d55dbcb259e58f9ee8cc613e7e42f1e7f1a8e37a6bff6ef5dd545076ec9be", + "python/sglang/multimodal_gen/test/unit/test_vae_spatial_parallel_decode.py": "0ab8f20f8c3c7736037b33295cf39f12c3762954e82102bb971d8069c6090702", + "python/sglang/multimodal_gen/test/unit/test_varlen_meta_host_build.py": "73e5a3cd4df4a2ebfd0ef6e287887274109120b2b17c2a7f63c3e139a45220d1", + "python/sglang/multimodal_gen/test/unit/test_video_api_profiling.py": "476abe2e34bc93da02e9b9645820339e75d4c33469272d01209725460b85a9ae", + "python/sglang/multimodal_gen/test/unit/test_video_job_lifecycle.py": "3abb207002925a08463a464f35e4836f2cca917d9ebcbc87f1babe60f3adce06", + "python/sglang/multimodal_gen/test/unit/test_video_sparse_attention.py": "8f77284fe1a7a77420e6bca8971d753eb1c9bb611e23725d2cc948e5ee6c5fa0", + "python/sglang/multimodal_gen/test/unit/test_wan_attention_backend.py": "f5b062daac1235fee733df482b165c719a6fda0c4097e4cd7f51be4abb851d51", + "python/sglang/multimodal_gen/test/unit/test_wan_pipeline_config.py": "8ee0a9d78dee527469bf9566a93990ececc3c97d8d25491eb40f31cb9a6a5419", + "python/sglang/multimodal_gen/test/unit/test_wan_temb_table_slices.py": "34262645c636b4e739371bb6244b3e9b3b8a7ffc03396c458e1989808f2a7b58", + "python/sglang/multimodal_gen/test/unit/test_wan_ti2v_helpers.py": "27d32547c702c450c8c1d4ccec8adb1fe80c24ec929012743acf96f5e071ed93", + "python/sglang/multimodal_gen/test/unit/test_weight_only_fp8_dequant_cache.py": "cef60ec2188bf588c91df47f95351ec909a019efa83631f5e01519b9e0c3f503", + "python/sglang/multimodal_gen/test/unit/test_weight_utils.py": "7a6ad15a3fa4d37eaaaf5e5a143c2c9a3383d5f610b9c4124deaa61c605b9140", + "python/sglang/multimodal_gen/test/unit/test_zimage_pipeline_config.py": "95fc4164eccf66b6434df6d80ff930bcf791d72f55b28b1a77127270324884ab", + "python/sglang/multimodal_gen/test/unit/test_zimage_qknorm_fusion.py": "c0ede506f9e2c1ed0585e8ebfa26508a8354ed91d031aa4a8a728d0605c1a64c", + "python/sglang/multimodal_gen/third_party/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/third_party/pynvml.py": "79ea49facf590fa182e0bf77c6855a845e4ab3141bcbfce6770ecc13a80da252", + "python/sglang/multimodal_gen/tools/build_minimax_h3_adaln_cache.py": "1116d5878e2255bade2b020a7c49618f691086cafd86f75870271b958de5773e", + "python/sglang/multimodal_gen/tools/build_modelopt_fp8_transformer.py": "c30c1acac5b2c6086498c81487bb8bf482cd1dd9b32a5b0829a553c1aac942b7", + "python/sglang/multimodal_gen/tools/build_modelopt_nvfp4_transformer.py": "1a43b877e0124b7f90242d7abcf6054eb9606387b9509bf3af83ce9116be506f", + "python/sglang/multimodal_gen/tools/compare_diffusion_trajectory_similarity.py": "0140a3da68ba10cbee834f0a96d9d163a6b519ed151048fe67c179302e18377d", + "python/sglang/multimodal_gen/tools/convert_hf_to_fp8.py": "911372836e00b7f34e9b757d68531c0420cfb5b77e13a3a2c850d5d0a1c153ea", + "python/sglang/multimodal_gen/tools/wan_repack.py": "a64a833bf6c573a1bb837c59089916d96ae617186c2cc656a8bbf2d0d3cb2d97", + "python/sglang/multimodal_gen/utils.py": "05642a8530529531bd17bc047014ea7e7d1b1843a5cad0546d7ea06e1e7f1bf6", + "python/sglang/profiler.py": "976f4b38ef11112ed5334a3c4920026a44ead0bfcc16a105c142bb061ef1bace", + "python/sglang/srt/arg_groups/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/arg_groups/arg_utils.py": "6abaa9be570c10b0d9e17ab1a324a07902aadffad5cb9c9b737ee885132b1eb0", + "python/sglang/srt/arg_groups/argparse_actions.py": "455a006dad5caa73ff089e705e5a217c1b56e78c405c4c284e8ea8a5cd55ab38", + "python/sglang/srt/arg_groups/deepseek_v4_hook.py": "b5c7090cba19eb8613a5a2b2440911c92e6e60040fafb6a68104f3540bbdd7b3", + "python/sglang/srt/arg_groups/hisparse_hook.py": "c23d69f90cbaba4459ebaaf5089a4a18b9e82fa749fdb5394bfd495068b7fc2b", + "python/sglang/srt/arg_groups/kimi_k3_hook.py": "28edb2663343894cc7bd7a5d3782ce5b871841f7203c61e1070a7312122cfd82", + "python/sglang/srt/arg_groups/overrides.py": "d3a1ccc96359d544b124ca9d666e161f2de4cdbfa649b8f0239bcdb6fe3f8692", + "python/sglang/srt/arg_groups/pd_disaggregation_hook.py": "5d4b5330a5375828179ed50f2708d68de90ecdde804832b252919b6a05a2a17e", + "python/sglang/srt/arg_groups/speculative_hook.py": "a97e3a7b427328559fa99e2078d2fec38d8380a6c8c17bfea898cb4eee2e8123", + "python/sglang/srt/batch_invariant_ops/__init__.py": "e277fb7cc6addb8f34f40a7692db170d4fe2e3474ec740fd6aa2b89415748ff0", + "python/sglang/srt/batch_invariant_ops/batch_invariant_ops.py": "9a9fdb89d84f8c392ae9a46f46c0a846b332e78f4ae77c24f240f8db55e6a6e4", + "python/sglang/srt/batch_overlap/operations.py": "4fa10e000917528813f53ec522a9bf61b90cfaa47f90436a2ec62c59821d271c", + "python/sglang/srt/batch_overlap/operations_strategy.py": "a9c4b5cbe65975058a68982f9d40a9a6afeff34daeff3bc162a91ec617dea47b", + "python/sglang/srt/batch_overlap/single_batch_overlap.py": "3c23bcfe109466ca63b46a925ac1ae1711c8d0703683673b3982c41b732f56df", + "python/sglang/srt/batch_overlap/two_batch_overlap.py": "ee395ac23f7722b9fc42ae05d4a64d23b2dc5d118ac90a3a8ffc48f3e8352a37", + "python/sglang/srt/checkpoint_engine/__init__.py": "15a5b6328c26066c089ec2e09e1f8278d2cb3f9b4f9155eda44ba3b4e6f25bd0", + "python/sglang/srt/checkpoint_engine/checkpoint_engine_worker.py": "67c1b669a4a36c56b0bbb1d7297014e55638c157b6ca5ec15b617a045f6dc187", + "python/sglang/srt/checkpoint_engine/update.py": "222774bdb2b632b4a9165c9609b445630053da8a549d478f9a4e6d60391901d4", + "python/sglang/srt/compilation/backend.py": "7c51043151a1050c0b870a4eb04a5ed477a2620c6c19b6f52766735968636fae", + "python/sglang/srt/compilation/compilation_config.py": "0eb0d6586ad6d28a194ffa084e5d4b326caa317cbd09d0d8dd809219d75aac41", + "python/sglang/srt/compilation/compilation_counter.py": "168ddfa11af24e4650290321ee9d1085412c57023a0976b592fa7101490dc1ec", + "python/sglang/srt/compilation/compile.py": "e80a9f13f23cfd073fc0a1d6075e8c8593dc26be9c7f2362611fa8937b5983f7", + "python/sglang/srt/compilation/compile_phase.py": "969248e4cd4a86b922bb2b09d429691b19c6a4333a86198a9388c445b88d5a7f", + "python/sglang/srt/compilation/compiler_interface.py": "8c66f1f363c9c76d7a4e74aa0985fee6506a24f3dc8678b5a62e3a9485f6c17e", + "python/sglang/srt/compilation/cuda_piecewise_backend.py": "1d7258fa1773fba3d0355a54f92a9f11cd866b37c618e9f45e0123462145b9b1", + "python/sglang/srt/compilation/fix_functionalization.py": "14c65bb9aac87a6046279ca22abdfbaead820dfe7f2f16e171588563e63a6be2", + "python/sglang/srt/compilation/fx_utils.py": "abf64f0e11f3d9243cd706c95d338559c3979c7d1e88a529949aefb905e29714", + "python/sglang/srt/compilation/inductor_pass.py": "8a54a6c65cd352c2b2fbd49107b10c8cb0587d90de3c45aa4e5f8cdc6c2fac74", + "python/sglang/srt/compilation/npu_piecewise_backend.py": "47bf1f91e134235867e954ee1c7a04ef25c36c5dc38ec4bae31c425a022f7497", + "python/sglang/srt/compilation/pass_manager.py": "8d36e29702bb5cecd1d666e9ef6e79ddbff11bdadbdc4a0dda1b7a16bba11744", + "python/sglang/srt/compilation/torch_compile_decoration.py": "86c7a5c495632bc42d22719f87f0ad0c8fadd52f189994243eec41d80b47ed28", + "python/sglang/srt/compilation/weak_ref_tensor.py": "3085290d6076f83aea4cbcccd221adbb55636367da1b9721be31946c68934cb4", + "python/sglang/srt/compilation/xpu_piecewise_backend.py": "ad31b9caceebb23503a5bdc093c4c14b278fcea505ba2688d94f049bf85428cf", + "python/sglang/srt/configs/__init__.py": "388f9df4bb3078eba0f03048b4a8bdc72325c1f2a1c7ac16720beb4012cdd1e5", + "python/sglang/srt/configs/afmoe.py": "7ab65afe8a3afb6934916907313ba8aadc3db3b733bbb5447399c69ad8e98cec", + "python/sglang/srt/configs/bailing_hybrid.py": "95fab0e74aadb9927a92c09d345beabf941228f2b8317110e4db2707873a3a9a", + "python/sglang/srt/configs/chatglm.py": "a1b9af316a8cad3ebcffc83103e3d1a748cae081ca3364f0ab73c5b2089526ee", + "python/sglang/srt/configs/cohere2_moe.py": "e62e7ae6f6a851ff94900b8f106600575e08768862f2dbe97c502aaf0222c36f", + "python/sglang/srt/configs/dbrx.py": "b5d848917010975cabd0cc6a166b031b51347b6a6e4534ca9ba513c803412da7", + "python/sglang/srt/configs/deepseek_ocr.py": "49d86bde31f77bdbadfa81b161fd32ee77834768819baa446dbc9da2c385426e", + "python/sglang/srt/configs/deepseek_v4.py": "9adf7030a4f6a39459934d28bdd3e7fb8def1f524bb91ce786212f4d404c326f", + "python/sglang/srt/configs/deepseekvl2.py": "d75a2c667ecfe3c591b5c2eb67aa20ab4d9386a9f504f85c98d29c97f334d059", + "python/sglang/srt/configs/device_config.py": "141b372d33a2f0aa3a7059f2f8bf0b1c30eda6032c69bad30f87b7c47a6af1cd", + "python/sglang/srt/configs/dots_ocr.py": "23093622e7984d04cec4fc3a4479b4c525fd850579f62de805a4dc8c6061c134", + "python/sglang/srt/configs/dots_vlm.py": "436a9a3fae6c6022869a0fdbbdce20e726fea5ab1d64dc78c679e5ceee847755", + "python/sglang/srt/configs/embedding_model_spec.py": "0fa197fbb5cec16b4bc6a0a02088fdd672a01ab77044ec68251fa74ba7177b32", + "python/sglang/srt/configs/exaone.py": "a25dd4679414f075e5edd34af38945f451138d4c51d2d0937ecee477f66f98e7", + "python/sglang/srt/configs/falcon_h1.py": "b3530c0499b64677ec0602d9d2c334421a6e9e2bb31265bbad55894f652e1622", + "python/sglang/srt/configs/granitemoehybrid.py": "1c5628293eeabcfa742dddbd9f29835dc698aecb0e9df9ab954c7af2af99cc0b", + "python/sglang/srt/configs/hybrid_arch.py": "48b4bcf47cffb2cd71b835588979edd3b80c6539a3328567f35f36f550a8b7ce", + "python/sglang/srt/configs/inkling.py": "cb0fd450818a2c0667bfd387423f7a46b97a976616d3fddfd933dd049ad62c6f", + "python/sglang/srt/configs/interns2_mobius.py": "a8dd86da6d06667293918acf21315f6d41500ac1f23ada810cfbc8a7c62dd41b", + "python/sglang/srt/configs/interns2preview.py": "988c6190727a5a3fae89184dacb8c0670e0a3a0eaf7cd6e05d6372ff8db34940", + "python/sglang/srt/configs/internvl.py": "1bd0d64b0414ae1bd48486ffe46dff08c9041ae93adcebc58caf6c2ffb925733", + "python/sglang/srt/configs/janus_pro.py": "3575df5c35a1ffc9d0a885d578b0f29343575311972a780a4e111107531e4e10", + "python/sglang/srt/configs/jet_nemotron.py": "832c015209fc1a2f5003781b730a0fca5782e942c98a0c13fbc1a4eba4586522", + "python/sglang/srt/configs/jet_vlm.py": "503e645fa2ae2940aa619addeb6c8f6ea8752d9bf8138674c9f2f75762efb3fb", + "python/sglang/srt/configs/kimi_k25.py": "30210e7ef5c728c69ee4ce6975903e82a22216ff896c63f2758468cc753e7af6", + "python/sglang/srt/configs/kimi_k3.py": "e4e9adeccb746c358880e1734a98073ceea58acc21353dde2a33107ae76896ce", + "python/sglang/srt/configs/kimi_linear.py": "25d7c7fa629626e49a07cb78daf63aab5f7f32456a652ece2813bc24c2491685", + "python/sglang/srt/configs/kimi_vl.py": "6049ff02df4d0ce0e816622c1c6f33dc8092b5c7f991412feae895b63a70e737", + "python/sglang/srt/configs/kimi_vl_moonvit.py": "871d91b7825215bbf2d8751378b8c1a607bcee6f0ce884c086ab2074d7ff25de", + "python/sglang/srt/configs/laguna.py": "f4c9139ec09cc1ea1fb92174453c003b8998d0a0a8717b34aa51653cd6d080f1", + "python/sglang/srt/configs/lfm2.py": "0763b5bb25964872d4c6833f401b2baab08425612b5b75fd7253d643789c936a", + "python/sglang/srt/configs/lfm2_moe.py": "a948fc589dea7a31d54102f1186fb31783b18afd7ec09e7dfa2a85567ffbf1d8", + "python/sglang/srt/configs/lfm2_vl.py": "9ca6f220a548849f04109a215bd8bfd17a98a35d58febea044046d5d90b5be7c", + "python/sglang/srt/configs/linear_attn_model_registry.py": "34478d80112b8ef8ebda86b8b85b5a7ce04359fa2baf013cf19432b7e7980606", + "python/sglang/srt/configs/load_config.py": "b404a18d3f0153f43dc24b6c28c6a8932ac76e19dd7b710efe755ec96e2b6117", + "python/sglang/srt/configs/locate_anything.py": "30223f8d0865ac98815ec9967fb6ed8abe3f5af47ddb547df86e84aa7f742042", + "python/sglang/srt/configs/longcat_flash.py": "b791b526e912b4c43660912ab5e8dc642575ea2416942c366e2bab2d041be8bd", + "python/sglang/srt/configs/mamba_utils.py": "820627a476130e36e8c9aeec2f1ded01d0c068369149e014cc0ef074f1e90808", + "python/sglang/srt/configs/minicpmv4_6.py": "4ff4f19844846a36feb303042ef257e6ebffdff0173f74fd3ec449e4336f226d", + "python/sglang/srt/configs/minimax_vl.py": "85528b038441724e90aea555d9e8d28575810b9f078889fe4c9fbb7ad4a8a915", + "python/sglang/srt/configs/model_config.py": "f3c7f7648bb80ba1ed07f839376779136d98f04cdd389f80112883720b741712", + "python/sglang/srt/configs/model_config_parser_registry.py": "4f11ddb4ecde882e267f96eaceb6e61efc4b38f72f9f977d91fb8d113c45c2e9", + "python/sglang/srt/configs/modelopt_config.py": "a6be10fc9e06d457fec32db805847359a374508df8aeb78679fecdb7a7745f73", + "python/sglang/srt/configs/muse_glimmer.py": "c814216a3470abb67abea26bf82bfc2fd2963980e43527a1188741650ad3607b", + "python/sglang/srt/configs/muse_glimmer_processing.py": "e822f8d7fb526e6ab8188ed47702044b24782da062327a08ef10581f9a8ac59e", + "python/sglang/srt/configs/nano_nemotron_vl.py": "b7ac0cb5eee99f39cf744d8ef98a0c98311bcb371d01e5c6d9638d3104c31a35", + "python/sglang/srt/configs/nemotron_h.py": "9b6c4a801032da1b5404fe5f04e5aee1c9d60252d0d650734d9eefe2eb304889", + "python/sglang/srt/configs/olmo3.py": "1d000a323ca4883ea4cd80af01885b7a874d56a82a34ea1e1bfb6f9bbe3c3313", + "python/sglang/srt/configs/parakeet.py": "09efe3620d488685e1a11c2236028642ceef182ff152aed3520e70f3f44d6141", + "python/sglang/srt/configs/points_v15_chat.py": "a9a9dded631cdcbf7ac20fb0cc0f58aa7ccccfb65433aaae02e4e18ced6b7ccf", + "python/sglang/srt/configs/qwen3_5.py": "72592dde421a945050b7f3e16ac0ffc9836dfadba16fcbccc473bf1ee9e9f1a8", + "python/sglang/srt/configs/qwen3_asr.py": "3ce79252169d974a777a3c7226d6a4186696143c0d1fd039f19249b10cd1d719", + "python/sglang/srt/configs/qwen3_next.py": "071ce509469c3d3320a7c7dcdb58702a53045fa9856d1c858501e2740b9c5df2", + "python/sglang/srt/configs/qwen3_omni.py": "843096226e123f12de5d1ba6dc62c3f0080787ab57da54bd7b094d0f638fbdcf", + "python/sglang/srt/configs/qwen3_vl.py": "3d5d16958d65d7de6d3268ccdc30b8f7508853f1ff0bba9606c0ef5be7b426fe", + "python/sglang/srt/configs/qwen4_exp.py": "ad2a5a26bb76b8df281b4c27271b827eaa9d0df3e6561a5e593f3f3095acaa0a", + "python/sglang/srt/configs/radio.py": "bc6557ca461e83c76b938949eda17d65cc8d0596a93e7ee54a94bd1d85660966", + "python/sglang/srt/configs/step3_vl.py": "fceb609f29b9ec356007f919ffff1cd7f62ce6049a940fcad19b958dc1b9d53d", + "python/sglang/srt/configs/step3p5.py": "3c816182ede55d65fd9200be63fb1cddb55c2eaf54fde830d5e0da1ac46eee91", + "python/sglang/srt/configs/step3p7.py": "5f2e2f3a538f38ea1b4d67ff4cd2ff72233b00519765df9c4a67dec332c1958c", + "python/sglang/srt/configs/unlimited_ocr.py": "12897bcb503f2f5e7ddfdff85323aab335d58734aac87cfcb4ae6828bc03bdad", + "python/sglang/srt/configs/update_config.py": "31a2609836edd20659c5876687e75bc4b42f1ed44c647ad2920005f722a406fe", + "python/sglang/srt/configs/utils.py": "25ffe3de229612d00dde2dbb96a0f7c945ea77f7f0ab6700dca16972dbd1f5dc", + "python/sglang/srt/configs/zaya.py": "16935923c2cf235182682fa6d78618e1f44513a7266ccbfbfa3737112ac0174a", + "python/sglang/srt/connector/__init__.py": "704cb5da6e56637690e5716243bf910e72f963c4dd83f7a3a253a5c18af05a8d", + "python/sglang/srt/connector/azure.py": "3242adcc7b713499b0e2bc0bc47aeca55c2bb2b53fb8f2ed767b69a7de5f8208", + "python/sglang/srt/connector/base_connector.py": "2c22ac4d7ff25877253ebccd341d5f2f054237cac80ca65a661a87439e01f4c5", + "python/sglang/srt/connector/redis.py": "2b77c94a6dab66c77447f2a42025778c858ab6bc315c4d6d624b569e8bcb6f3e", + "python/sglang/srt/connector/remote_instance.py": "42f3ad17a899487ffcda88dca0464cf5eb01420909a8baa20098e06ca84b8042", + "python/sglang/srt/connector/s3.py": "867e4ec3d63a22d4bc44c243c274d07b941a890ec728c822c20804f509d47b03", + "python/sglang/srt/connector/serde/__init__.py": "cee95ec9837e8eb0f288f8978d36d0280dbb9656f81fb1ee0d365c070acb9355", + "python/sglang/srt/connector/serde/safe_serde.py": "5d28dbf6646fd47a9e1ba262c3adf710e41896b708db7436d5496e62a3d96960", + "python/sglang/srt/connector/serde/serde.py": "9f9f48d8c5cb6bb582c8dffca4477c2feb1c264ee53219845fe18e508845d190", + "python/sglang/srt/connector/utils.py": "8ac4efc5abb3d7ff27a39316ea9f01c23d87f66424c1e6913bf452c003c0ed1f", + "python/sglang/srt/constants.py": "763bc7110ea28b1454768f722f10b58065618d3d160b2c5b9746fd95f6595008", + "python/sglang/srt/constrained/base_grammar_backend.py": "6bf74add13594e0f7bd26f069be39c734e0edc01cf480d4f601df7c76806434f", + "python/sglang/srt/constrained/grammar_manager.py": "dc4c94674191877a689c671713c739ab4693675f4fd26f68331a4751ecbc1903", + "python/sglang/srt/constrained/llguidance_backend.py": "34150debf617586cadbd3aab921cc151118c99d088e09c1beed71f4940cd2fd6", + "python/sglang/srt/constrained/outlines_backend.py": "ffef75513c79b201136730343165a9ee7444e159faa50d4c7f77bbbb95470dda", + "python/sglang/srt/constrained/outlines_jump_forward.py": "766dcf56cc31da813f25f02ffad3ddee2acc23de550aae1c653f8017e3a1c77b", + "python/sglang/srt/constrained/reasoner_grammar_backend.py": "6087173aaf0434665bdb57a4c8105407a44a7dc31fab4f9e66a19ed6666c1374", + "python/sglang/srt/constrained/torch_ops/token_filter_torch_ops.py": "019bb1e4b1c1f9d133f4fcd3849c81f58677e6b6fe21c697828c8e3e71753041", + "python/sglang/srt/constrained/utils.py": "6435eec8a8c66077cfa37661720c597bba64fd06f8fe29415765a36c34572837", + "python/sglang/srt/constrained/xgrammar_backend.py": "841651917a3a302c7a08ce1743aa284b3914e96b95c20cdfbf61df84125b21f2", + "python/sglang/srt/cuda_vmm_utils.py": "51b28fa463a48d89834efb7001fb10f86d7246e02d886479f9b51b2f80041562", + "python/sglang/srt/debug_utils/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/__init__.py": "ba899925697e772004b7006a273ba4b921c355042b6c7ea774b4ac582c8a3904", + "python/sglang/srt/debug_utils/comparator/__main__.py": "03c35164c976258d62a689631670a8708950e892904587c5f434406ae6a21238", + "python/sglang/srt/debug_utils/comparator/aligner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/axis_aligner.py": "5bd5cb33219bc892935ea5dec5f1c76dfec5bcb083f2027c55fa859a1e35e574", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/executor.py": "6357cc1ec00fd970650582d5b9e67354bab72be3b4b3e8e9e3f004b8af1405da", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/planner.py": "5a2ebf4b06c3d3b873ac557f0ceb88ea3607ea88c6395a0f9b741eb5dfed5bae", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/traced_types.py": "1b726e91f716ffe5619e5cb24c66ec51943ee222cd496dc3322c38614c66273d", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/types.py": "e7b05cacd428ef416cb1ec841742f9407980c23dec611ef2ed395ed9134d708c", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/executor.py": "d5358363b28da93650eed8ab53d08759064db776114cd062ec0656ef3e7acf43", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/planner.py": "706bdd7b9ad08ba66229438196cf430d7e981c9454b2f82414c66acd978cdfd2", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/types.py": "07b9f9ff535aa2a0784dcb3da9e73ab325c5a81cb896992866f782a86bc37737", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/concat_steps/__init__.py": "7fe61fc5a08193360663da64a88b72ef8fcc3f65b0158f6bc669a6cfda0c7a72", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/concat_steps/executor.py": "8dc2c35d646be7e17bb51f4d1489f881251923dbdfa3fb6e0b1dcf21ce0b925e", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/concat_steps/thd_seq_lens_loader.py": "83856e6b531064768ac1acc07f70ba9ff60187976795de390fedc57cf1674aff", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/entrypoint.py": "4b3bac51cf0d92517c72bc0a24f9bb96673bbb11a37c3a209ebbe9524b4d3e36", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/aux_loader.py": "16aba02f0575409def056b015df45d8721e4a2c95884e6ea373f634dad1a0909", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/aux_plugins.py": "928733bcb4f435bf3ac4cde31ef52ef92703f151806fb261bab70c75acde46a0", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/executor.py": "5385ad7e3ba6dbcab9ec4e7f11184b5e965e298925ad2e016ea035c941a35089", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/planner.py": "4b7a26f545265817541d0092beb8003da2ca358c0677134d6d231f2636e75dc8", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/seq_info_builder.py": "f7255824a0e700cb6fc189afa4c33f75d4aa841c4a5aae379bf6c2b89f89dac7", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/types.py": "52fc9981a45d10033b41df08b962032da6b0f8b18a999f5e4649ec6d0c166669", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/executor.py": "3d675494348bbd827361e6dd16fa8409b516991ca29cf8cfd141c070074ffd1f", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/parallel_info.py": "b329865a2dc4b496a6909a08b25f0d95aeb0c19dc963cce9fa3286f0ddc875b0", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/planner.py": "d9dd33cf4fa77c633d44b6ef0d86557d0dbf12f4c817088e36d7882282179f04", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/types.py": "4d496ecf4478a23a85bb10094f383c762aa7a84998ba36bda157077f4affb5ae", + "python/sglang/srt/debug_utils/comparator/bundle_comparator.py": "8fc478891082c0fb26910d4e1a7d04120e7f11cb95172279d6774be561398b4f", + "python/sglang/srt/debug_utils/comparator/bundle_matcher.py": "0d76a932b2d8c3fe645764aefcdbcc786680db752f3b33cfef43e1a7928a7ae5", + "python/sglang/srt/debug_utils/comparator/dims_spec/__init__.py": "56c9da9703564fa42dbcfb01543a5e7f5e2b1acc0df035667edd731b44575cf6", + "python/sglang/srt/debug_utils/comparator/dims_spec/comment_parser.py": "6483ebf41a165e05c68d3e0562328a15cd947e5ec43cab12e6d6acc65af9e57b", + "python/sglang/srt/debug_utils/comparator/dims_spec/dim_parser.py": "b0520f348fc496a2a30dbecc9fc17162691626ef43912bf293e7c088f3099408", + "python/sglang/srt/debug_utils/comparator/dims_spec/dims_parser.py": "be475e593f7047b5c20ccf1dabbd71016ad946990c18ed884b5fef7ae75986c9", + "python/sglang/srt/debug_utils/comparator/dims_spec/modifier_parser.py": "532b1c1d6322f0cf91fea7d0e3410a1110064107df4448cc13faccfc5c7bdffd", + "python/sglang/srt/debug_utils/comparator/dims_spec/tensor_naming.py": "529602f555d92b3742ae643c4da4d50e338b09cbef8de3f3429f72d530184b3f", + "python/sglang/srt/debug_utils/comparator/dims_spec/types.py": "382ae1758d94e30f30c8f479213300e37b483fef2b7021613548c8c504bb463d", + "python/sglang/srt/debug_utils/comparator/display.py": "77408d505b99430652a9e7d4011a116dc31848c205765a030291e9ca3e7ce916", + "python/sglang/srt/debug_utils/comparator/dp_utils.py": "84400e5e24870b45bb571df3ec368807f9ab1a8581e814e210ba6303c9b968c8", + "python/sglang/srt/debug_utils/comparator/entrypoint.py": "9ab81ec2b9dac39036af50ed9fccfe5e3b5b6470e707b76539364c574c845ba4", + "python/sglang/srt/debug_utils/comparator/log_sink.py": "1ac2c147568fc654f15c4873021fce2caff54f739dcde1821baf0286bf4aea97", + "python/sglang/srt/debug_utils/comparator/meta_overrider.py": "401f7d4046dac7ec8ce37dc5db0159de9c7a9e52608b9083eedac86852630a60", + "python/sglang/srt/debug_utils/comparator/output_formatter.py": "3467b9dd45ad860149e8b3fd28f5b6b75e10123641373d1bf06945727837b222", + "python/sglang/srt/debug_utils/comparator/output_types.py": "e44d68b341983720d47ad2837ddad20e107b6dedc95ed2aabba0e3c004b03927", + "python/sglang/srt/debug_utils/comparator/per_token_visualizer.py": "5cb7281c5a069ec59683ddc235bd25f734583d60ddb4ba72886ab44092389708", + "python/sglang/srt/debug_utils/comparator/preset.py": "6c3e37ff7740c70fb107568ee052183da9ba9f81524e843eef8d1e7da19a9eb6", + "python/sglang/srt/debug_utils/comparator/report_sink.py": "a99936f8c3f16d96fac1cfa21daab1855302ae66128c8671122cc238d9097911", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/__init__.py": "cd2a1d53637ade9e059e68f035b9cfe128cd818e04aca67c34d7a28232c5aeb9", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/comparator.py": "9145cf7268a7d62d229774838743c8903902d53834ad6ddf1c877430841dd986", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/formatter.py": "29103f1001727bc9c76f9da509cbab3bf061da9d6294c289ffc9a2b5d685bd3f", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/types.py": "75ab76c25508b582f692a0b7cb1f3671b38407251e22e0d2e5126f497310170c", + "python/sglang/srt/debug_utils/comparator/threshold_dsl.py": "12f8d64c54531eba8dff66c82b5c94f7cd5eaa19cdf3a490b6b43c035c9015f3", + "python/sglang/srt/debug_utils/comparator/utils.py": "f4fcca8b10e2800d5ceccca1ac7835f79c4a98cc6be3cd6a3945f80127c40681", + "python/sglang/srt/debug_utils/comparator/visualizer/__init__.py": "44943a29e99fe88b4581f4b5bf6297f70d0a2240964d6401f8d4664dc4eed897", + "python/sglang/srt/debug_utils/comparator/visualizer/figure.py": "4868cc81a725f1173204c74ac3fb9565c487a641a73b02d0f85b97c74a10712e", + "python/sglang/srt/debug_utils/comparator/visualizer/panels.py": "7d7f11aecd0b88149f95efb7cad0a28e4c2cf136d6256b7e7cae5a7d66a90a13", + "python/sglang/srt/debug_utils/comparator/visualizer/preprocessing.py": "8c95090499deeddfe00ba4c4374f2b9342b6b95825637c49a6e7c956d75442eb", + "python/sglang/srt/debug_utils/cuda_coredump.py": "3c988b25ce932682ed7107187597eebd0b9ac507d6fb8f164bbb3caa32808ff2", + "python/sglang/srt/debug_utils/dump_comparator.py": "85d69da52a5df9f1cd03f77da52675e34172378f3c6a6dd9595ecfe9ec97955a", + "python/sglang/srt/debug_utils/dump_loader.py": "1b362653debc9b64028cb470ba5b4154a4c9ced321ce2e28e430b0dae41b45be", + "python/sglang/srt/debug_utils/dumper.py": "57d9bafc9dea9d42e8abb7576c6010f070a065655f07ad66456b49113e261f86", + "python/sglang/srt/debug_utils/log_parser.py": "5dbfc6315d4d785bf3159749c6fced6008c75aea1aa8cf8a00b85c8817cbe409", + "python/sglang/srt/debug_utils/model_truncator.py": "23b64417aa8f9aa8c5c18e24cb813816da16af1a079fa81e5513ac14b1516a0e", + "python/sglang/srt/debug_utils/pr_fix_toggle.py": "4127ecac4471b48749d7396d77be1599169906d425b88c47642b1bdfad6a042a", + "python/sglang/srt/debug_utils/schedule_simulator/__init__.py": "be50bbf5e92de060a8cfecc831bcdb8609bd0f490db225f8802fa3d1a8eefb2a", + "python/sglang/srt/debug_utils/schedule_simulator/__main__.py": "6a22701f5fa52c27ffba46d8ed6f00c6588cee1189cac2b6eac09fd7d63d13e4", + "python/sglang/srt/debug_utils/schedule_simulator/data_source/__init__.py": "0053b87e19565964b92f4034281183dc8658cf1965aa6622cd5bfba9a5e5d22a", + "python/sglang/srt/debug_utils/schedule_simulator/data_source/data_loader.py": "8b0145833ddf087466c7bd52f43ca6570c265ccdffcfd9f58650761f37622a60", + "python/sglang/srt/debug_utils/schedule_simulator/data_source/data_synthesis.py": "2db55c12bdeb311fc836b26d697b5f20a323bd49bdc279cd56f33efe71b2d1b7", + "python/sglang/srt/debug_utils/schedule_simulator/entrypoint.py": "cc9efd82716dc6af909257b54bbf0b34496c797ebd1aa8c47f2bb86b2569f4d6", + "python/sglang/srt/debug_utils/schedule_simulator/gpu_state.py": "14b3a6961c92dbd7e12c7378e8fb3cb271f1d656d9691e2c5e2cee6fc8148f6f", + "python/sglang/srt/debug_utils/schedule_simulator/metrics.py": "6924f565b7a383a0d3ab535bf5b7db06b862adc7f08b24d7ed8f3c9e741c5ea1", + "python/sglang/srt/debug_utils/schedule_simulator/request.py": "4c131bdf9ce5ad0a1fee449ad75b8149d7d56fa917567cbe483ca000af43d6da", + "python/sglang/srt/debug_utils/schedule_simulator/routers/__init__.py": "7dd9829746d315b52eace6e42de74235f7bc4e14b78e8599ecd332eb3347f3dd", + "python/sglang/srt/debug_utils/schedule_simulator/routers/base.py": "130391a3c01b4a0b171029460c689071f883c3072d891c8adae4828f56322e1a", + "python/sglang/srt/debug_utils/schedule_simulator/routers/random_router.py": "b8b249cd5e5f39ab41b9e7f2e09f8ba4d65cdac86d61054e1aaae427c24a3651", + "python/sglang/srt/debug_utils/schedule_simulator/routers/round_robin_router.py": "01f001ae738dfcc4827efaec81812ffc0d5876519dfac2f7d6bc88b3c9760ef3", + "python/sglang/srt/debug_utils/schedule_simulator/routers/sticky_router.py": "641f0cea9d16f4f1ac3a8532acdc0a612fdcaee452caf723a9d1f6a72c065b07", + "python/sglang/srt/debug_utils/schedule_simulator/schedulers/__init__.py": "db56bc0e85b416a109523bf79df4d75dcc5867fa9e9876d4df1a275852a93b2f", + "python/sglang/srt/debug_utils/schedule_simulator/schedulers/base.py": "3d6045e82080d978fa3d4b5d25f856b98c9a0fff019b93982c99d50c88e8c97a", + "python/sglang/srt/debug_utils/schedule_simulator/schedulers/fifo_scheduler.py": "77b9cc73f537206969673037837310cd74c76633e28c9d8c25cf0aae59a287e9", + "python/sglang/srt/debug_utils/schedule_simulator/simulator.py": "8ca17b8189bc2607f859b64da6d48b3d04367b972b5f37197cbce5aa90b2f9f3", + "python/sglang/srt/debug_utils/source_patcher/__init__.py": "ee249b365a88fa36dd5d6ef0640f67514e96a2acb960b7931b471d931d3844b7", + "python/sglang/srt/debug_utils/source_patcher/code_patcher.py": "5e77ac348627d6e8356d5f31171daf83760a3d102717f1c7f827236f33d82d7d", + "python/sglang/srt/debug_utils/source_patcher/source_editor.py": "32d4c2da0ce8084b62a08e98111c22a7439bf5c0bf8508a5ec18a6d993b7425f", + "python/sglang/srt/debug_utils/source_patcher/types.py": "4bfdb4296d54f9a845a717502f41c292e7f0b6cc0c5c35971197e89d55a4b975", + "python/sglang/srt/debug_utils/tensor_dump_forward_hook.py": "bd5e33a56fec09580c4e97e09b8c64cf9201692ed08478d10fd73bac688a1c13", + "python/sglang/srt/debug_utils/text_comparator.py": "34b25d8d48a45bef9b5a719058878525eb32baf6765678b64b9ddf2040fe9bcb", + "python/sglang/srt/disaggregation/ascend/__init__.py": "fa5c6789c6ba7d962660da4ac2613cc84494a50e52c5fd83899a011f36e829cf", + "python/sglang/srt/disaggregation/ascend/conn.py": "fd2545df9bbf4d35d1e09217c5652781e1249f5c8ca25a700865b7dfb8c58e70", + "python/sglang/srt/disaggregation/ascend/transfer_engine.py": "f51f8e1476bbbfb219e41e75e768d5afc73d5ba84612ca9c31795480e347be4d", + "python/sglang/srt/disaggregation/base/__init__.py": "e15c14bf4696c709952f5d38f572bcd9a2d33719add1663944fcbd962fb0c959", + "python/sglang/srt/disaggregation/base/conn.py": "c3d84c421281ed0c5c4da6309a1efaafc5f66a802ce8a778c63c01903cfeec0b", + "python/sglang/srt/disaggregation/common/__init__.py": "ef297e1062cc54a46905468617fee5c00b30d89fe6aa9459574db7f151b10fda", + "python/sglang/srt/disaggregation/common/conn.py": "dc28d75e40b63163334b78e097b5eaa07ed768d596ce4c3903297cd20a3debf3", + "python/sglang/srt/disaggregation/common/staging_buffer.py": "85eef58786fc4132772b378a712600d1ae23834d4d8b1bfef553cb26e730d739", + "python/sglang/srt/disaggregation/common/staging_handler.py": "501a6476d345a1c795b2bc5cd56bfbb54e66e1696f882172602b74899982908e", + "python/sglang/srt/disaggregation/common/utils.py": "257f4d3df55e6eb3e1368186a410a6f73380f03444faab9af5f6966ceb986c5f", + "python/sglang/srt/disaggregation/decode.py": "28b8406736abc1601ccac6e1e73ee5827bc3eb7527c3e34ea824ba91a132bc52", + "python/sglang/srt/disaggregation/decode_hicache_mixin.py": "9c7775030f97c542024e48da95af001a392f52ee589658a38635ea0303f171b2", + "python/sglang/srt/disaggregation/decode_kvcache_offload_manager.py": "fb202374c211c3cad7a6ca39bbf00dee4877268e9e3c14dba9f506a3d190502f", + "python/sglang/srt/disaggregation/decode_schedule_batch_mixin.py": "c9bce6e98d54c415794eee6c75eeda96e168c64a8bc526c06e2f3960c01bb40a", + "python/sglang/srt/disaggregation/encode_grpc_server.py": "e48a34147806d9a66904b43fef34766c34355c213acef5356309bda8ef6ade4a", + "python/sglang/srt/disaggregation/encode_receiver.py": "54f11034ba24bc73ed50b7b5b44186feb371e7a005ac18885c2d0444f8d87ef1", + "python/sglang/srt/disaggregation/encode_server.py": "f990cc97fd1ba474828993f16a3455b25d21bc570ced5c39e3751221956c06f0", + "python/sglang/srt/disaggregation/fake/__init__.py": "9513a6c428234978b619d68e1eb1cdfb3d6c9ca4c075c3f56ddc2da0b48d612b", + "python/sglang/srt/disaggregation/fake/conn.py": "b0d6a7889317b68308bc258a56bf2b72b8feae7b4ad37a272f9372904d204375", + "python/sglang/srt/disaggregation/kv_events.py": "656a6340cbccb758720b3c63517c078f943f5a438a7129d12a545d0d292ff8fc", + "python/sglang/srt/disaggregation/mooncake/__init__.py": "d1382a9007502356329db1d8e9cd10212bd5a0e4a4fb44b0088ab9ae33d29a01", + "python/sglang/srt/disaggregation/mooncake/conn.py": "5bfac4cc28ee29368d4f73e317be2c2bcf637738f28f03aa5ee81017bb9d45db", + "python/sglang/srt/disaggregation/mooncake/utils.py": "485af0e04627b3c9924c140791365e334d8320d004808c8abf228dec7240f65c", + "python/sglang/srt/disaggregation/mori/__init__.py": "0420a96d3e9123efc762c340b0024959679de25e95c997b8e72e2eac030a0800", + "python/sglang/srt/disaggregation/mori/conn.py": "8f540fb0a31fa521764cc63da0e794a6707fa77684703ae2ea029ebdd2b4a385", + "python/sglang/srt/disaggregation/nixl/__init__.py": "a8e0d53c8196517297ab8cec44870c62802801e83a9c120df6f7503a554c00d1", + "python/sglang/srt/disaggregation/nixl/conn.py": "b682bc4f567d08734ea1c97de69c2356fa3045c84365503d8c138c0f7c7660d9", + "python/sglang/srt/disaggregation/prefill.py": "fb3bbb73be9c15900d06fa0a35ba4404d0942b86532e1456a61a00fc58a8b1d6", + "python/sglang/srt/disaggregation/utils.py": "b10628773d806f4b36afa25ad58f37390fe3d230392842e0f8c749e95bf84c4a", + "python/sglang/srt/distributed/__init__.py": "8c539ccadfb01403cc05401ff739196a535096dfb8aea993ea908a073d44e2aa", + "python/sglang/srt/distributed/bootstrap.py": "7516a5dfd3850a561fbccc272bf8762fbb293ce3f9101c662dd1d3cb28033ebb", + "python/sglang/srt/distributed/communication_op.py": "cd887fe137e5af7a7d52a8c6005abf82ce374717445259996306ca9b8a5eb0c4", + "python/sglang/srt/distributed/communication_tags.py": "b7d784c0f7d7f780b58097e9dbc81d6d99348c1241416fc55ebf0192edc00539", + "python/sglang/srt/distributed/device_communicators/all_reduce_utils.py": "df4c56d0dc1293c41caa3bc27779bc58eb2823f89aef70b21911a90a259864e4", + "python/sglang/srt/distributed/device_communicators/configs/__init__.py": "c6ee6b29d0caf265aff5dc0d03fc7cffbf8a0c855064c2b053cbb86ba0cad85b", + "python/sglang/srt/distributed/device_communicators/configs/custom_all_reduce_v2.py": "45d3ca8df482cb66363498e3d8fd80821adf2adb3f37f6ad083aa7263e655b7b", + "python/sglang/srt/distributed/device_communicators/cuda_wrapper.py": "a04c2ccd99745529e937479d5ebc6e1c71f6b24837572711e1c60af27f3e01ab", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce.py": "fe4ef6eee5003f0422accd49db00e2b4523e516645aeba2a2a63d545cfbb8de5", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce_ops.py": "f184bca25226c0f50faa293cff0e5014ffd38037631c614c86fee28827278ce3", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce_utils.py": "92445ac35010cbad04da7777d0b4f7d83f941845a1a527535de5337671030a38", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce_v2.py": "73c91972c29b06bade34438dcab21b21db70bee65722f264bf907118f223131a", + "python/sglang/srt/distributed/device_communicators/hpu_communicator.py": "9bb3dd5f928a696cd54daac574ac3e07ab62de2266adf2040721162bcdb90144", + "python/sglang/srt/distributed/device_communicators/mooncake_transfer_engine.py": "14b672668a09728ad09afbe826780657db40641d06a0e0c645c8a70fd5be3054", + "python/sglang/srt/distributed/device_communicators/npu_communicator.py": "379821f6244ef5eedc22fe732a214223a45a2a0f4d62e5c097f6609cd3889f46", + "python/sglang/srt/distributed/device_communicators/pymscclpp.py": "acf231612b176dd5c9775ab02d00b00ecb11cb521b238e6ee160164453c73c03", + "python/sglang/srt/distributed/device_communicators/pynccl.py": "54552a59dca74451e5553d8684a0ab112a7c8abf5b7b4c6ad524322f30a1e6ac", + "python/sglang/srt/distributed/device_communicators/pynccl_allocator.py": "f48992132d2c46396e201ec0d8aa8375d9e50b20aa7460f1421cb000e9cd99e1", + "python/sglang/srt/distributed/device_communicators/pynccl_wrapper.py": "e1d5df28ee32a5fe19238834107c6b2c9b2b33b28e8300d7fa337e28d4ecb4b5", + "python/sglang/srt/distributed/device_communicators/quick_all_reduce.py": "67e08aec7f57047e8d0158507cb1501b87809c1469b71740f630a9077d10d427", + "python/sglang/srt/distributed/device_communicators/shm_broadcast.py": "c7c43695929f1c89e42c7913b00b7c18a0edb9016604cb823d46ca4d9ed8554a", + "python/sglang/srt/distributed/device_communicators/torch_symm_mem.py": "e014a5da40b1ccba8595e583591afaf600d425043035f1f8f24067267ff9b87c", + "python/sglang/srt/distributed/device_communicators/triton_symm_mem_ag.py": "9dc59d39cd9cec94b29fcb430876a1f4ec1b6672812e1087cb230eddaf508184", + "python/sglang/srt/distributed/device_communicators/xpu_communicator.py": "10a5cca32a8927562ff45d3c8ea40f9089222c56055ae909134fb05d321ffba7", + "python/sglang/srt/distributed/naive_distributed.py": "197ec21e151bf6b210b9a20f5f84d89b4d52ed741d057bdda9a2683ddc45c802", + "python/sglang/srt/distributed/parallel_state.py": "2ac5574bb2eb79c7f2c5db31f1ad8f98d45f7cf97356019b2e1d5a80ad2c2997", + "python/sglang/srt/distributed/parallel_state_wrapper.py": "910ac5af01eb34f2c2a5abf4699f5a40f637989d727bb3beb657e68e7ed72e8b", + "python/sglang/srt/distributed/utils.py": "4a77a5f0b658e3917524c608ab6671e7802ca317593238c24c3572340632dc87", + "python/sglang/srt/dllm/algorithm/__init__.py": "d82c8387e0e9273285b1af703124ac82559103dade001a6d5ce539250091e63d", + "python/sglang/srt/dllm/algorithm/base.py": "897aa76dbb78e5788bd3498832b852153042bc7afa65aa81ee935a981144af66", + "python/sglang/srt/dllm/algorithm/joint_threshold.py": "6737b59f5c15413de1cac22d1097ee53dae854406dff61d58a6fb18d826c14e4", + "python/sglang/srt/dllm/algorithm/low_confidence.py": "a26bd3ef20ca6d930b775289f72faac1ed1f8e9e2ccdbdb850378eee9a43746b", + "python/sglang/srt/dllm/config.py": "ce954cf0983ebb9ff3503f00e2fc2dc423c21b0c530ae23dd56856038a6fd057", + "python/sglang/srt/dllm/mixin/req.py": "e226b29777fded0e6748416d93c08f34cb6513f0ed77a696f4422253b9f659fa", + "python/sglang/srt/dllm/mixin/scheduler.py": "6886f4c1420ad256d796bf7f3f5fd31c1a2fbada26ed8cf985a30edfad1e6d7d", + "python/sglang/srt/elastic_ep/elastic_ep.py": "b6c63a9ff106bc957ce75bc2152e7d847e5360d4dc88cc8d82faba48273578ea", + "python/sglang/srt/elastic_ep/expert_backup_client.py": "66efd9f51210cc2aaef5b68eec866a72d5c60e41223b4917b55aaae3fe2adde5", + "python/sglang/srt/elastic_ep/expert_backup_manager.py": "683e33cf46ef9ba7a87950c4b6dc04cc2cd6a78df6f7069c491a348e769be0f1", + "python/sglang/srt/entrypoints/EngineBase.py": "e9cdddf9e4a9e74663d445b69458ebd24f69a43f63e42979fe0923cf96140473", + "python/sglang/srt/entrypoints/anthropic/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/entrypoints/anthropic/protocol.py": "ca5ee76a2f4fa02fbeb4f2bd43cab2914a36137a0f0c622aeefed81cef16b2dd", + "python/sglang/srt/entrypoints/anthropic/serving.py": "4ed918fefb7fe9fe3906faea105ff8b67fac15d987aedfb39e33f305f94dee6f", + "python/sglang/srt/entrypoints/context.py": "cb408e9626344f07a572dbaed8ce88d51a979be07725f4adacff41e33478ddb3", + "python/sglang/srt/entrypoints/elastic_ep.py": "1f86efb98f7b364f56d41c784226bac6ff6d05809086bc8bcfed8025ae0d5590", + "python/sglang/srt/entrypoints/engine.py": "50aba0ce9763a3ff574ccc4be9ebaaa5d3e741045ed1d42a10f6a906c8b4b773", + "python/sglang/srt/entrypoints/engine_info_bootstrap_server.py": "42d58f530ec46f50f88e09d8e5c42d9b014e51ca023343fbb042758d854b2c6f", + "python/sglang/srt/entrypoints/engine_score_mixin.py": "904b711fa54795a19cd3ab0691205ba373ca9fdfee0a8c6b4a1e07f670253789", + "python/sglang/srt/entrypoints/grpc_bridge.py": "cb30520b01dd46e51c79c3812f54014b2f3376e96167e6916137396828a67d94", + "python/sglang/srt/entrypoints/grpc_server.py": "4b62f049035c16f717974ddb8145201f205bf06dddcffe4eebead7c7a7e71e28", + "python/sglang/srt/entrypoints/harmony_utils.py": "68b50da39f22701e1046b18f539faaee3ce26d8684ca1d213ab7abb7facc39c5", + "python/sglang/srt/entrypoints/http_request_decompression.py": "69442d129fe79f4449268c3804f0203af9a86dc616f997fbd729ab66f43c0e9c", + "python/sglang/srt/entrypoints/http_server.py": "5dbb62c787b120d70ca62241400705d34c4b7cb3e3100e1032c25989638e1f2a", + "python/sglang/srt/entrypoints/http_server_engine.py": "57b03db3ebff5207daafbbefa20c1138a8efaf00e6c8c0cbb843ccab448c5bbe", + "python/sglang/srt/entrypoints/ollama/README.md": "25ac552829f224e0fb0100d8c9391a7e028b89a975ff58170230fa9a5438f35b", + "python/sglang/srt/entrypoints/ollama/__init__.py": "786b829e3671aa72305b1948175314c7f631609b2ca3973bbe74790149eff0b4", + "python/sglang/srt/entrypoints/ollama/protocol.py": "08f1e67f0ea75fdba42cba0230bfdeb8fca46fff0b6226088d97ae70609e51c8", + "python/sglang/srt/entrypoints/ollama/serving.py": "b9b23646ef92565e02354b9c2599aab2acfccc57eabc3f53e0e25043230a95af", + "python/sglang/srt/entrypoints/ollama/smart_router.py": "6e83e521aa3ef6c98c74e82a1336594099531e106687e68b60f8ddf87d0bd968", + "python/sglang/srt/entrypoints/openai/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/entrypoints/openai/audio_chunking.py": "1786fe94d17c4e4ae07311b4d2f8a772e556832847dfc0f7c80a1297b48612a5", + "python/sglang/srt/entrypoints/openai/chat_encoding.py": "4cc93655ba72dabc45b40a23a107c76c2208cb7c5c612193f6832388fe2c624c", + "python/sglang/srt/entrypoints/openai/encoding_dsv32.py": "67ddda353a0026f4e3268255041e473934359ab7b8513e527821eea06ceb4e91", + "python/sglang/srt/entrypoints/openai/encoding_dsv4.py": "764dcfb28a57c3196975475747cb525ccacb4110556e3d9d35f038d6283ca527", + "python/sglang/srt/entrypoints/openai/protocol.py": "0d4ab08ef507764b1a477d12ff63ca6a70c48151b1464881c29928a87e392165", + "python/sglang/srt/entrypoints/openai/realtime/__init__.py": "6f1c7f2781cd8ad335bfb2cfe7cd29d040595b4ac86c972ca31d336e8438b597", + "python/sglang/srt/entrypoints/openai/realtime/handler.py": "d847da4ddba5c26fe01533aaf36a41778dc0fe28cb7f3f35fd6b5d27dd8ffd04", + "python/sglang/srt/entrypoints/openai/realtime/protocol.py": "6e1f9ea317f4c20bbe8ab8fcfa89aad849317115df619a179c0e8737a0071b1f", + "python/sglang/srt/entrypoints/openai/realtime/session.py": "3689c4b302059606ca144e782dd171f14a173881fb58365adc66021d8e17ce87", + "python/sglang/srt/entrypoints/openai/responses_compat.py": "72bfe1e5e45073d57f09dc90ba7b2ea6b87df932cfbcb67ed8116f25c5830037", + "python/sglang/srt/entrypoints/openai/serving_base.py": "3d0613b92abae51e8566a11ae80a2369a46422b49bd63c4cd6aa593d8a4bdbc2", + "python/sglang/srt/entrypoints/openai/serving_chat.py": "6d881d19da2c4a7028b0fb179cf5cdb958480612d4192c1606dfd25f98a9ba56", + "python/sglang/srt/entrypoints/openai/serving_classify.py": "b05079d8e3930397653a4ddcdef560250d6d7cf3a3af0cd749a9e7ed7c679005", + "python/sglang/srt/entrypoints/openai/serving_completions.py": "67f08075f21481b03e246327c7453f57ac001d0f3e78f5a9247caa553e1942e3", + "python/sglang/srt/entrypoints/openai/serving_embedding.py": "cf1b283df88e1286b7f803f2173bf89499c65e25c93462bc299b2c64539d77b8", + "python/sglang/srt/entrypoints/openai/serving_rerank.py": "5242cd42c8ccba74fbdf13e2c7eee63b5551e3d6bef09933aba213d690cb3329", + "python/sglang/srt/entrypoints/openai/serving_responses.py": "2d74b6b58076ae90770198c73f99bee6442fa6d006ae49f2118d02012ea51371", + "python/sglang/srt/entrypoints/openai/serving_score.py": "203748c564cd979d03d54dee44140c63caef59490d1ca508ccb1aca3f69ffccd", + "python/sglang/srt/entrypoints/openai/serving_tokenize.py": "f1791dbe89245cf80f2ae3c3f052e944c0b602deaf45909a31d2e4aabfc95711", + "python/sglang/srt/entrypoints/openai/serving_transcription.py": "0f15eac62ea22d5cd531f19e9419a5db61f6a3109a25f0e6d87e84d215c4128d", + "python/sglang/srt/entrypoints/openai/sse_utils.py": "a04b5b4548067c8932466aa99f9758d7a87d547f6a1843f9d104bbbfe3ea2ac4", + "python/sglang/srt/entrypoints/openai/streaming_asr.py": "2cacd66732a167beb72521e614ff1b704c6e09471fc9795c2baaf2a139aa2a19", + "python/sglang/srt/entrypoints/openai/tool_server.py": "910ad836c563cdc4a27412f9fefae9febad1cb1f095b2d7108a8e993e14d846b", + "python/sglang/srt/entrypoints/openai/transcription_adapters/__init__.py": "058c8a2dde5657747cc591f0933d986fc7b99f6cbcec761aaa611ea692bd2ddf", + "python/sglang/srt/entrypoints/openai/transcription_adapters/base.py": "5a9cf360b2dd1f8991094b3653a571e12f688d3e04d5740df51516ad86f7554a", + "python/sglang/srt/entrypoints/openai/transcription_adapters/mimo_v2_asr.py": "41db26f4d8b2f2485b95e17c15c289c0c9d2c9d27d8279ada178da4721834c35", + "python/sglang/srt/entrypoints/openai/transcription_adapters/qwen3_asr.py": "6095a17613e443f06060ff2a4536fd5aa0894293e554435060d9e2c4c6445b47", + "python/sglang/srt/entrypoints/openai/transcription_adapters/whisper.py": "3569731f715a293275cc11aa8ccd237d1431c2102efab8843b289ce25040000f", + "python/sglang/srt/entrypoints/openai/usage_processor.py": "883c4c3ba95eb52fa57d5bf732d128063bac0b032f484776331220f61b7498a5", + "python/sglang/srt/entrypoints/openai/utils.py": "6057816db2a0851dada70399266f4c678b0a56c576e145d3dfd442e2b2300624", + "python/sglang/srt/entrypoints/request_headers.py": "dcf5b40b22cfb44e56041a329b80abcc6eb420de369d40bbefc0830d99ae5c55", + "python/sglang/srt/entrypoints/search/__init__.py": "f6993cc104837ed956524568f6bdce8cba587aec7acc5be478b2027834223ad9", + "python/sglang/srt/entrypoints/search/exa_client.py": "4ce2e0c3dabdf567757664030c1960617e3e94921ab514d106b7aac68ceb3deb", + "python/sglang/srt/entrypoints/sidecar.py": "3c1426b338f234b3806862ad298132fbaf8c7c2e2c6e1b7a361a70568d7c421b", + "python/sglang/srt/entrypoints/ssl_utils.py": "3f56a50ac45d549fcbbdd670d8a456593a66ed07203007dafe8c80fe86416342", + "python/sglang/srt/entrypoints/tool.py": "2867140746cfde17ba0e7b82da4bad255226fd97df376c40922cd4fb704575b3", + "python/sglang/srt/entrypoints/v1_loads.py": "528deeb3210d8ea9039b9e20fbeff28d326d8efe49d16c55ef662e8091c22bd2", + "python/sglang/srt/entrypoints/warmup.py": "39213d17c3435842a715ee46502f2a664ecf5bd3d1efa829ba721052938f2f06", + "python/sglang/srt/environ.py": "aa2cfbe7c61e27607ef443aaab7988e1fce58d995711e4b2f4f3ac9bb86583ca", + "python/sglang/srt/eplb/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/eplb/eplb_algorithms/__init__.py": "69f58f4c8c7e6eb9dc70dd124cc9b3564dbabfda6318d1b66d658822ccbdf323", + "python/sglang/srt/eplb/eplb_algorithms/deepseek.py": "7c42cd0cb0f03da5dc68d13d38833f2986625ac96813dae4853521341cc5219c", + "python/sglang/srt/eplb/eplb_algorithms/deepseek_vec.py": "573cb921aaee6b5560547ce304d65a555fefb752d8d412ed273ecf9b307bd359", + "python/sglang/srt/eplb/eplb_algorithms/elasticity_aware.py": "c7a69bf06fc209a5279050e623a25dcd0a9a3485f21135b5a02b02c783cfc4a6", + "python/sglang/srt/eplb/eplb_manager.py": "d0d4a739edc70f2f7972a361cbbd6b72f31233539bd56024e96f22ac5fa8b019", + "python/sglang/srt/eplb/eplb_simulator/__init__.py": "1c865a5eab2fb0e08c309f35752b3569f4866791ba3a239912d1e996dcb3ce36", + "python/sglang/srt/eplb/eplb_simulator/reader.py": "3a5b16aacb97a95418ecf7efbeb3febec9765b0d8a838bc3fcaf4196d33f407a", + "python/sglang/srt/eplb/expert_distribution.py": "74ae213a2295777d56208d5f593bc603782c7992bf91e60a3f1395ceb6d7442c", + "python/sglang/srt/eplb/expert_location.py": "879172c5669cd1a7950a37440698393b4419c073d826fe3bce39d5854bca2ed5", + "python/sglang/srt/eplb/expert_location_dispatch.py": "c7f6b68fb9c6262ab781de8c31514580f36046732ecf75868e3fdc0c6a9e11b0", + "python/sglang/srt/eplb/expert_location_updater.py": "b1e03dd4a8dc42d3987c16e3b0fa6dafa40e21f1f0363763bb673cf67a03199c", + "python/sglang/srt/eplb/lplb_solver.py": "3201e927a9513f92f6410fc25fa10e7804e21a05156f7c124ce936b2d3abc3a1", + "python/sglang/srt/function_call/apertus2509_detector.py": "10b776d3364f3bce87d8564903ae0b7f266e7cee2912f610f64299862f855b15", + "python/sglang/srt/function_call/base_format_detector.py": "0e56a1402b1d27dd92c5299f4bdeed3bc4499660df3c910c473a9691ba23265a", + "python/sglang/srt/function_call/cohere_command4_detector.py": "008deb2e5c078d5371a571479988c1b001f8b162287ce225b041484f0498b1a0", + "python/sglang/srt/function_call/core_types.py": "c0b52c5bc99403e8be212cf94140cbec48eaef65be2b51c88456bd5a6fbfa00f", + "python/sglang/srt/function_call/deepseekv31_detector.py": "ec6374c040a86dd2021b7ea7b989300299dea623fdaa3c71d6d9aa3f18e845d7", + "python/sglang/srt/function_call/deepseekv32_detector.py": "a7d6263b1e9d5ec3742ca399d1df2f7d4ff91a8d8c079d953035a976b6090a4f", + "python/sglang/srt/function_call/deepseekv3_detector.py": "a555137527cd524f51a888ee49224d4761856f5b4a9d93d3ca77abfb755c06d5", + "python/sglang/srt/function_call/deepseekv4_detector.py": "d826876e0b6229ff5d363da16b6c954c3211a080d72edb81cd56b0fd477487ba", + "python/sglang/srt/function_call/function_call_parser.py": "578defd8404b88a6dd4786a19fad9777e889898b4211a7bdde2f6ac7c11a4531", + "python/sglang/srt/function_call/gemma4_detector.py": "712146a24e1873fe5d2872253a1688399a8929f7d5c04094e2027428ff767d99", + "python/sglang/srt/function_call/gigachat3_detector.py": "f544d3bf51e1afaf9c8fe62878c5ec9e929c1db2eb9b1e4040daeb0be81c413a", + "python/sglang/srt/function_call/glm47_moe_detector.py": "93c882d0d3d5613c792a4a20da22a9e54d4f36ebb828846dce05a1acb81d83cb", + "python/sglang/srt/function_call/glm4_moe_detector.py": "a8daa4f4ef6d45aaf612b0e0fd3f922e5b52a406ac85abcf7c2cc2e39857ed81", + "python/sglang/srt/function_call/gpt_oss_detector.py": "5c81fe623acd20c19106ce946d8d902a285769babba43e8ddc4c181a5a9da3e7", + "python/sglang/srt/function_call/hermes_detector.py": "5dc30e64c7ccd453f3b5fc50be0321c3bb404dac3e689ad4cc384ab2c45de27c", + "python/sglang/srt/function_call/hunyuan_detector.py": "546cf13fa2951d89641b02394fb4da0913baae82d5f5e4db7e2f48f76126b329", + "python/sglang/srt/function_call/inkling_detector.py": "52273f962e652026e86324d2e6320225e10cd24cf1b002674d1d7e1659680d99", + "python/sglang/srt/function_call/internlm_detector.py": "a2339f334c5bcc7fe36d7cb7cb3b7621918eed857397df47e6f3ecee28b38133", + "python/sglang/srt/function_call/json_array_parser.py": "7ebbff7e8ad4fd1ca0f227b9edc345715d637387301710fb8ab619286a31b934", + "python/sglang/srt/function_call/kimik2_detector.py": "92d6dd3751ba1bdcc5ef64eca0db87c1e341d0f81bbd764664ac6ff38f08f839", + "python/sglang/srt/function_call/kimik3_detector.py": "423aaa042a963f7b3c091991c9a356d23e2f161c05d0e3d4dfa07da17be87838", + "python/sglang/srt/function_call/kimik3_format.py": "65b893bb3314c02ef2537cc4a8c85b3d798101a5cebebb548a2cac1caa5a3a63", + "python/sglang/srt/function_call/kimik3_structural_tag.py": "bd00d77898be7f6231f165eaf716f0c0cb71cff66036495e261fffd39f462aa1", + "python/sglang/srt/function_call/lfm2_detector.py": "2d2307a9c62a48ca553735b4018d0b02471f08e8ef2eaa0a53cf82b18a1ca534", + "python/sglang/srt/function_call/llama32_detector.py": "e83ee75917cc1921c21ce899e0103af4b94bc492195f87843364580dac73eb5b", + "python/sglang/srt/function_call/mimo_detector.py": "2b4ca63e1de0b232c69cf26609e87d0da9a8a3be9c4acd29f0db62e2dbb0db45", + "python/sglang/srt/function_call/minicpm5_detector.py": "12fc0378e86b337706ee1e64e3b3c96b8550eaefda74a97e8dde54dee954c1e0", + "python/sglang/srt/function_call/minimax_m2.py": "fe1dba10e3d9a76c3549a20c2b8ba1b609eefa4a817197abba8175b725a724fc", + "python/sglang/srt/function_call/minimax_m3.py": "cbd83122df28c1ef6d6ab34007bd7d64eb56f902614fa3bd74e5c681f2fd0e65", + "python/sglang/srt/function_call/mistral_detector.py": "ecb2637d1766f096c698b6b8eaadeb6e772aa3487d6566f61f665c145dd73336", + "python/sglang/srt/function_call/muse_glimmer_detector.py": "c7becee4831996d4b3bab24659ed45c10980b1d341ac4f05ffd567bc76a5935f", + "python/sglang/srt/function_call/muse_glimmer_format.py": "91126a99c959c98e287db819411b099a6db3fa0d9060bb736694e33d8b89e8e6", + "python/sglang/srt/function_call/poolside_v1_detector.py": "3bc52645891d5c9bf97c3796f5dcabdf1bfcdcac0f4483aa5786da5bf950d295", + "python/sglang/srt/function_call/pythonic_detector.py": "47e6f58b88db14870864985f51e18965b39332cfd5df293de3d26be7e778c6ec", + "python/sglang/srt/function_call/qwen25_detector.py": "e4ebe052024b4236819932ee3d54941fe2db9bb9107711ec33514d1d68c3c9e4", + "python/sglang/srt/function_call/qwen3_coder_detector.py": "4cea43b633e46ca164492ebd3a26892dbc602e29856024eaa05be65551ce4541", + "python/sglang/srt/function_call/step3_detector.py": "7ece8be2b2f8dcf9285d405baffdf69ba3632cf799ef5a1a942a73b2ae1d1cb6", + "python/sglang/srt/function_call/trinity_detector.py": "868f345fb3129456073497949c913457cdc2d54ec90885d71e302bc85114fca8", + "python/sglang/srt/function_call/utils.py": "fc55c1b3d63a3631841aa1b6b5979cb0647e6ba27a4f5a1f1a1573f46eca8c25", + "python/sglang/srt/hardware_backend/cpu/quantization/awq_kernels.py": "6ab92cf54daa765c6cf55e9f2daba16698f41821abf43a455697dc075d7d79ae", + "python/sglang/srt/hardware_backend/cpu/quantization/gptq_kernels.py": "e0c95772981e9927040988cf41c4e17fc563fe49d45d165da6b600f39bf8bf0e", + "python/sglang/srt/hardware_backend/gpu/quantization/awq_kernels.py": "055053ba8cb17a66a6b86feba08cf9abd0ffe9c01b8be71c2a9e0a990a53d83b", + "python/sglang/srt/hardware_backend/gpu/quantization/gptq_kernels.py": "375085abdd2f4abca3d5831045d5f11d012c1877e0a19f79ebe89593b5568370", + "python/sglang/srt/hardware_backend/mlx/aot.py": "01860d8645b7ea869508430728a97378d657cc2ad1d3589f8bfc244d9d7f832b", + "python/sglang/srt/hardware_backend/mlx/kv_cache/__init__.py": "be7e9e48cb7e6128073c59633331b702c824e7663247988be2c1fddc2678a19b", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_contract.py": "ae36edbde00e162f81bac8b58d9d57081c7606b0204e4d949e7b2345030aaed5", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_kv_cache.py": "b356b0fe2b6c9669a0b531a83cd40fbbe8f7920ba04f4bc8ff127fdeadb40885", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_kv_pool.py": "d4235abf8d7e899e58eee3cc432840549227329aec7524b7721c97846291626b", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_wrapper.py": "c8485033ce1a3363cd6288bb3f7717a3be6e27a7278a9e6a451c0bec22ef7105", + "python/sglang/srt/hardware_backend/mlx/kv_cache/auxiliary_state.py": "31bb2cf55d87f0493658d4a83ec621a2bed590ed47f272534c603d4e62bbeb7a", + "python/sglang/srt/hardware_backend/mlx/kv_cache/layout.py": "e4f3b27e74eb8118c928479e8c1fcc880b3798331b2bd5088bc648af0b25399f", + "python/sglang/srt/hardware_backend/mlx/kv_cache/model_patching.py": "fbdac75437d50d7837c755d7e8950412f49f018e06c2a03c0d982d5bb793285e", + "python/sglang/srt/hardware_backend/mlx/model_runner.py": "48495702c5f080f2e8c063e1ec4d39d93ed7172c6c3eab5480dc7d8d30e46fac", + "python/sglang/srt/hardware_backend/mlx/model_runner_stub.py": "9bad79c3ab1910673856f71d51226bde7c43091cfed4bbf4ad3367ec31ff69d3", + "python/sglang/srt/hardware_backend/mlx/models/muse_glimmer_mlx.py": "e9e2d4dd21a92e0747f6db685bf0518e3d50ea489c52e7f56ef28833d9469339", + "python/sglang/srt/hardware_backend/mlx/moe/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/hardware_backend/mlx/moe/fused_swiglu.py": "7af9920968fbd7186909fd6af144b5233cdb43897f3d446f59e4e77d713569b4", + "python/sglang/srt/hardware_backend/mlx/parent_watchdog.py": "73280296edd1c553cc0df6ed963cd6a17e293291fad1bba300600095be870c31", + "python/sglang/srt/hardware_backend/mlx/profiler.py": "6d344b577c9905922daab260320b936a2ff05a1e0191667a493f48a1f17a2f0f", + "python/sglang/srt/hardware_backend/mlx/remote_code_gate.py": "2fca7faf07b67d8d336e216369562fb3001e21d7366b1dd7799bedc0893f2cd5", + "python/sglang/srt/hardware_backend/mlx/sampling.py": "e9dd918cf5a1bf3fdec697371e393f0335fa333d2eef415047314e4407e9dec8", + "python/sglang/srt/hardware_backend/mlx/scheduler_mixin.py": "61fb35e2492e80a9907fb3e2683e5598d2afd2eff25a0570f41416424ec68288", + "python/sglang/srt/hardware_backend/mlx/tp_worker.py": "b069bad13eb10965c0a4cc3790085d661fcf921b1c301cea12f2738c0c472927", + "python/sglang/srt/hardware_backend/musa/__init__.py": "98c2f352233b032b0a4192efaefb25f2ec3fa153d996dc78c327253723069897", + "python/sglang/srt/hardware_backend/musa/attention/__init__.py": "98adf994f3345c498e7477f82245508600e3f5ded2205e2e6af5c0c80eac616b", + "python/sglang/srt/hardware_backend/musa/attention/flashattention_backend.py": "e95f13b232edbcc785ea63164b186cca3b05b4a64b12adccf14ad19f2e856282", + "python/sglang/srt/hardware_backend/musa/kernels/topk.py": "d9ea6fbfa6c362d419d75b47ca12e1e4a01c01db8d8ccc474e45ccc8eb732496", + "python/sglang/srt/hardware_backend/musa/layers/utils/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/hardware_backend/musa/layers/utils/cp_utils.py": "b63615113b1142ee6667e182a0fad19507eefafb88161f4eea877d41789e126a", + "python/sglang/srt/hardware_backend/musa/utils/patch_torch.py": "d5c2492e9c3389f33cb7ad75ee0f1fc3f62853436911d17962b1f380d2662536", + "python/sglang/srt/hardware_backend/npu/allocator_npu.py": "7c96bdbe2812af59e8f7dd77a085774520ee152d4b051c8e41fb2b87570fa568", + "python/sglang/srt/hardware_backend/npu/attention/ascend_backend.py": "97cba7e5b180bc767998e6150ab89565e16da3180aa666463029b04162e10b4f", + "python/sglang/srt/hardware_backend/npu/attention/ascend_dsv4_backend.py": "b4e74210398435aaee4d9a107649780bb65d3e4ded7e548882d4065a9f06368e", + "python/sglang/srt/hardware_backend/npu/attention/ascend_gdn_backend.py": "b62bf1c59130a56567613206da62a3ffb77333c6943f703267b79c3f1f829337", + "python/sglang/srt/hardware_backend/npu/attention/ascend_hybrid_linear_attn_backend.py": "b2796ba9128da3666433cbaf4ca74d2dfdae63682444abcddfaa1c8255fefaf3", + "python/sglang/srt/hardware_backend/npu/attention/ascend_kda_backend.py": "7fa11a8f05da1b2cbc61d849f50ed23077b5c76d81b25fabc71c05ce8c57f19e", + "python/sglang/srt/hardware_backend/npu/attention/ascend_torch_native_backend.py": "980526716059fb4ffe6eff2a64e6b7e068fcd10f5b2c6075a87e52b04e541e4d", + "python/sglang/srt/hardware_backend/npu/attention/mla_preprocess.py": "b74303957f7b04b20dd17f5830ac5619aa60e1cbb49b2984100922b9ea42c05f", + "python/sglang/srt/hardware_backend/npu/batch_invariant_ops/npu_batch_invariant_ops.py": "594866569d8461e8fca6cb10f86c0200a9afa30a49c22009a3a320d5d5352f73", + "python/sglang/srt/hardware_backend/npu/cmo.py": "2d92b479bfbe32f61c4e6fd3f8a90029917721e7242933bdb7bcf8c43ec17200", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_allocator.py": "de50d12a6c3ee42cbc3ef70078c50d9ddf3ce6fe81044a8da2ab3dca006cd0e2", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_common_hooks.py": "912a18d6e6cfa1da8be500338261df2023d61c1caa43ccd0230e5016388098f4", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_memory_pool.py": "27720a07a169a7ae33cde62f50e73b9c00c3bc365c89b9531a10ffc646b2bc89", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_req_to_token_pool.py": "b08f5e7a7731d64a3bce64f2914789ade1b6a6785deab997792ff80bd2f07efb", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_rope.py": "dcc1e6845a6020ed6f8c38379bd2bb987cd3889223fc669d83bcaa5b492323ed", + "python/sglang/srt/hardware_backend/npu/graph_runner/eagle_draft_extend_npu_graph_runner.py": "158d5c2e4bf741280fdfacea70880877c90aa4810c01f7d5a46f2d4aec57cd91", + "python/sglang/srt/hardware_backend/npu/graph_runner/eagle_draft_npu_graph_runner.py": "5948b09510d88f528819f5c85d1537dae396e9f3cf0634a0a107768a629622e5", + "python/sglang/srt/hardware_backend/npu/graph_runner/multi_layer_eagle_draft_extend_npu_graph_runner.py": "6e4bc0551977692c7905555a78c9899b4bd9d38d4c012ca28f92d3a6b89ee864", + "python/sglang/srt/hardware_backend/npu/graph_runner/npu_cudagraph_backend.py": "4c2a2a4aa41d5076ca2618f259697f5d4e2a18b362d891b43a63afd0445f391d", + "python/sglang/srt/hardware_backend/npu/graph_runner/npu_graph_runner.py": "b664301658e30e0e59607210babf3f47f000c812f8abb0af416bc710ed7d9c83", + "python/sglang/srt/hardware_backend/npu/graph_runner/vit_npu_graph_runner.py": "d602034909d74454a32caa39c57f5498d5bba0b53ca84e33ffba1b4546dbfc37", + "python/sglang/srt/hardware_backend/npu/memory_pool_npu.py": "c2c1d711601d380dbaa0cd19106bd201f1183f30fada4fe10b5b4309a0cf9537", + "python/sglang/srt/hardware_backend/npu/modules/deepseek_v2_attention_mla_npu.py": "7fa76db72e593a8ba108a28d6a6377fb5e2be5da6b005c1ee2f78397965ea9aa", + "python/sglang/srt/hardware_backend/npu/modules/glm46v_processor.py": "d8c17bdf2fe74cfb5981625c99a7532cc3fe442058fd89d31499b49b401ed8f1", + "python/sglang/srt/hardware_backend/npu/modules/minimax_m3_processor.py": "b29ac8d4bd93cb84041c2c9151f4cd190757d0ab5c6956a53e79252da6da111c", + "python/sglang/srt/hardware_backend/npu/modules/qwen_vl_processor.py": "41f6cb1020b188c412b698e80e957cf6b72ffaeca758d5efe9a838b61beb5186", + "python/sglang/srt/hardware_backend/npu/moe/activation.py": "6332eee502bcb38461bf7fec9808860b86063b115b931903a952060e95b259be", + "python/sglang/srt/hardware_backend/npu/moe/finalize_routing.py": "5f405ae3f69794eb21e6fa3a9a72c0c6e3abc954b69bc5895233359b1b341426", + "python/sglang/srt/hardware_backend/npu/moe/fuseep.py": "4f38387bbf29b9ecd8fbca4bbd24643c83476f70980489132e75230064336545", + "python/sglang/srt/hardware_backend/npu/moe/init_routing.py": "7259a3276000c15b0cb9db37905590889c02b0367b45f7aa6444af76738559c7", + "python/sglang/srt/hardware_backend/npu/moe/matmul.py": "103ee3efc3fb7472f123caa90f6bbee78ad54b539ea4c6029728292449343bca", + "python/sglang/srt/hardware_backend/npu/moe/quant.py": "f257a11a9d84899a4bdaec4d50f8851ea00c990304605ce87e03eaa8d2c3e21f", + "python/sglang/srt/hardware_backend/npu/moe/topk.py": "f82f25bb343892b7b8b1eb833a4e6ca376a510ac74a3a935e0a1997dbd072f75", + "python/sglang/srt/hardware_backend/npu/quantization/awq_kernels.py": "fb7e61a875fb16733bad79bb369470c0811b16297538a0096ee99db085ed0ab2", + "python/sglang/srt/hardware_backend/npu/quantization/gptq_kernels.py": "bbe88891a5cce8fa4384ccd792ff8051e57a8c464834066794cf4080a3213ce6", + "python/sglang/srt/hardware_backend/npu/quantization/linear_method_npu.py": "fb048862fa9bb1bfe1082571ce3801c0a67cd706972b9410df01b2d719d56b90", + "python/sglang/srt/hardware_backend/npu/quantization/moe_methods.py": "a2f19e4447754aae0d4c8298006f7bc4f4fe42ffe87d71c08364e90f26924c66", + "python/sglang/srt/hardware_backend/npu/quantization/online_moe_methods.py": "a58fefd0f600f928e639dd8efc3ac20bdf5819af63e447db40e123aa5667a657", + "python/sglang/srt/hardware_backend/npu/utils.py": "eaf2a13ecef1ceaa2871e1ceabe0d39d89d4f32f934a696684acc5f9734deb93", + "python/sglang/srt/hardware_backend/xpu/__init__.py": "64e0d0c737f4e4502cc9ba8f9eeb132f5cff859758e0ce996f84f85a8177c01e", + "python/sglang/srt/hardware_backend/xpu/graph_runner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/hardware_backend/xpu/graph_runner/xpu_full_graph_backend.py": "9f9c31cd0444afd50e806e32163f5e87d200ebcdbe60e382449891063f130d89", + "python/sglang/srt/hardware_backend/xpu/graph_runner/xpu_graph_runner.py": "e46764c9549d4fc90df488e8f87a9d513e3d2c48c7afc58daf5088713f09f4da", + "python/sglang/srt/hardware_backend/xpu/kernels/fla/chunk_delta_h.py": "89bcc1275bf8f3e5f90b8a451060bb720c90f2ab640c75830ee65b59839b45e9", + "python/sglang/srt/hardware_backend/xpu/kernels/fla/chunk_fwd.py": "1a83fb1671688d5cd995007dfcf1d85519a45b9ec8ba1fcc354431e62a851a5b", + "python/sglang/srt/hardware_backend/xpu/kernels/fla/fused_sigmoid_gating_recurrent.py": "f7920b6429af284d909324e43ac29d344bffed456465d52625384a4e7f42fe34", + "python/sglang/srt/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/api.py": "9b52a98d05f5143ad647e67b8aa66cf6fd5d5945153bf6f3e004713cf07cabe8", + "python/sglang/srt/kv_canary/buffer_group.py": "a694b2fd65132e06143a0dac2da636a2880019d7e0c98ab772cf51a2a088d1b3", + "python/sglang/srt/kv_canary/capacities.py": "e4861f85c69f748f36373ecf187750210becef2b33297b8e9141c6b9546f71cc", + "python/sglang/srt/kv_canary/config.py": "b265fe49344de6ba64d8364b128bc59a52ced91dab799c34af65b9e8d7f8b762", + "python/sglang/srt/kv_canary/endpoint.py": "373c89fade17867c597021a7f478757406084b591ad2faf4ad5295ce46c07534", + "python/sglang/srt/kv_canary/expected_inputs.py": "4dce033c1edd272845732099081d9b879eee44bdb642ba4cf20c8e333796e36c", + "python/sglang/srt/kv_canary/perturb/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/perturb/config.py": "7a74803a65a39024bdb9a768b23fd996e233c4f664f6cc0cbfaab78778418837", + "python/sglang/srt/kv_canary/perturb/manager.py": "ab779cf17fa7a651105f5c85166801158203a0c514139d086a830bdb52b8b7e5", + "python/sglang/srt/kv_canary/perturb/next_token_swap.py": "dc755f51b7e5d3a60eaab6eea025298cc547a3042e15bd647e5d543a4e3735fe", + "python/sglang/srt/kv_canary/perturb/real_kv_post_forward.py": "be8863ee30a6f61a8679f0e9243931b89a3d4385b54dc53a967827ef2b19c062", + "python/sglang/srt/kv_canary/perturb/real_kv_unused_cache.py": "b88f803a7763e7d6da908a083cf17219d39f51d2a294c47148cf63c9c7e2183f", + "python/sglang/srt/kv_canary/perturb/real_kv_used.py": "8b8e7e4017e5677f073e03fa40c5c1d879fea249ea019c926d2d334e93c5c12f", + "python/sglang/srt/kv_canary/perturb/req_to_token.py": "edc06725ff16248633bc2240b035179a0d8033e0af788683c94da046a9c3ea18", + "python/sglang/srt/kv_canary/perturb/slot_picker.py": "50eea89b054013310474da5988f8a5dbde694081c9abadec9dfc69b26382bc75", + "python/sglang/srt/kv_canary/perturb/utils.py": "87ed6650884067c64c329a80b589ddc492b21f18e7a26ef8e017681855f1fef2", + "python/sglang/srt/kv_canary/plan_input.py": "c1eec88772e932286e4f85dc74fe52839f4e6cf8f1a4344f5a609766653e64f7", + "python/sglang/srt/kv_canary/pool_patcher/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/pool_patcher/adapters/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/pool_patcher/adapters/dsv4.py": "d2a7114b620c66650242d189cd4106a6e2dfc2cd75df60102b092b44d83cecca", + "python/sglang/srt/kv_canary/pool_patcher/adapters/mha.py": "107fadcc284058e68e915870e66f33796b111875165568810b938d393dd4bf97", + "python/sglang/srt/kv_canary/pool_patcher/adapters/swa.py": "89c39c8b621743e4b131052d3a2d0306ebe46c0e3ce4d0b32302b644a30d1b42", + "python/sglang/srt/kv_canary/pool_patcher/api.py": "efa0c95a02c535b7bd2216656f724de73d0ae4af628761fd2feb89f97dbf675e", + "python/sglang/srt/kv_canary/pool_patcher/buf_info_splice.py": "1c2b42261111c6bee904b3862744ee469512937ddbf73a2c08ca48ded6c6f2e8", + "python/sglang/srt/kv_canary/pool_patcher/buffer_alloc.py": "bdf7540a0877f38a50e48aa50c680b1382ec81d763415e3043097be27cd6e6df", + "python/sglang/srt/kv_canary/pool_patcher/utils.py": "b932bf4ae79a34ffa0296fd3f7155eab5008576e38f5f787fac30f11ce3c0f04", + "python/sglang/srt/kv_canary/radix_cache_walker.py": "0336c58e3f009d6eacfec49edabd431dffe556b6766a17e24cdec15e9d6834d4", + "python/sglang/srt/kv_canary/req_to_expected_token_ids_manager.py": "dd236499cf61f30cbe4c7d314ed023f0a69c3927dc259a41aa836be19818fecc", + "python/sglang/srt/kv_canary/runner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/runner/canary_manager.py": "5665f0be8884203de55a1481c0c7af7c05290942302671b2124eff20f4f00e50", + "python/sglang/srt/kv_canary/runner/enable_warner.py": "9a48cbfd97b5a094883b6e0b02772992d930e9986083e129ab94914825601d26", + "python/sglang/srt/kv_canary/runner/future_tensor.py": "3d1258cf36cf05d2b37ac6e864d9e0ed7234d0435876a54bcf63948ba3ac7369", + "python/sglang/srt/kv_canary/runner/health_checker.py": "d05fea43777d02c2d0d5b9f3c118a5cd0a6b853ac0e6278cf9a8d8c05a25c547", + "python/sglang/srt/kv_canary/runner/kernel_launcher.py": "6c9ebd784e03b0e6a043e9318a32df3fb99dc98c25ec2bfb959a9b3a80b79dfe", + "python/sglang/srt/kv_canary/runner/stats_logger.py": "c2d88687b3787f11533f3a0ef14c8a25a7364c96b01c4b1b24912246750acdd8", + "python/sglang/srt/kv_canary/runner/swa_divergence.py": "3a784d1f0ac1f2e1ecc6b403ee66388dfea02c291ada39c92384f2f22d258fe5", + "python/sglang/srt/kv_canary/runner/sweep.py": "af59c8347380be88809f7ff0bd988467a2ab290a20a761a5c623d7e0c45bc5ae", + "python/sglang/srt/kv_canary/runner/violation_manager.py": "c75633a08c50717d4a5854fb7160e6dc05ed41dc2f919bf51eadf24c9f47a8bf", + "python/sglang/srt/kv_canary/runner/violation_reporter.py": "f2b8c04bf46207a0bd87f5fe3f4859b35e2fd76e2f440a20809d0bf95e63d5de", + "python/sglang/srt/kv_canary/single_forward_manager/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/single_forward_manager/data.py": "79fdf8e6cb67568d44976d10c197c2b9e2687ac9fe7915fc382e14a4e83ecd45", + "python/sglang/srt/kv_canary/single_forward_manager/manager.py": "f70e97b30fa57069e56b8c93c771ac4861178a5ab894250e7aae14d87edcae46", + "python/sglang/srt/kv_canary/state.py": "ae3cb8dfebda81c613bc798861921f883391cd637c89bbf466be3d68c1f997e0", + "python/sglang/srt/kv_canary/sweep_plan_builder.py": "6dd007f700dbd11580a068a4a387dddb98d88c8853bba8bc56b9a2de829cf2a6", + "python/sglang/srt/kv_canary/token_oracle/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/token_oracle/install.py": "09fa6834e431be696baa7a0ce3bd1fabf443618d395117607ee84d657b2b1489", + "python/sglang/srt/kv_canary/token_oracle/oracle.py": "9ef15e40f81a4f788827a172e2e50105ab5dcd07f8593448c77b48ca09b900d2", + "python/sglang/srt/kv_canary/token_oracle/oracle_manager.py": "7e434aa530009bbfe7ee6baf038626591e51bc5a520e3911c0bf61e5e8660500", + "python/sglang/srt/kv_canary/token_oracle/sampler.py": "3fc753a2a89c9bbaeb4d6b0405a83fc705a53b62c2999daeeab3997c4a0fe4bb", + "python/sglang/srt/layers/activation.py": "231a49e1f2f3f2237415e77d85d36c159c2ea3424f0197100f469252164bab7e", + "python/sglang/srt/layers/amx_utils.py": "9c78243b97eda52b7771219c373b50a46c498fc2ddb86caae2dfc2f96b130c48", + "python/sglang/srt/layers/attention/aiter_backend.py": "5a08325b94695eb0426fcfe78f08639eb1a849060917c601d6831e780112dce9", + "python/sglang/srt/layers/attention/aiter_utils.py": "11028c3388212e570c192f999fb43de4c161e2fd5f72f99eacef91a02a530f25", + "python/sglang/srt/layers/attention/attention_registry.py": "b2700564bbbe536d81ee76775449bd12e835e7b02e94a23d9545aeedc52b095e", + "python/sglang/srt/layers/attention/base_attn_backend.py": "21ef3e25c65b6921434a88e625b72b1442709a411a89e04e7f4f8dcabc7531b4", + "python/sglang/srt/layers/attention/cutedsl_mla_backend.py": "f5d6a8c062b8c1a6c86549a077aac62b7452993bd6635c62d46012dce70bf41f", + "python/sglang/srt/layers/attention/cutlass_mla_backend.py": "c6c5048e67b3fdd127115227341623bab0cdb6dbfc54e5d89cfa455c508b63dd", + "python/sglang/srt/layers/attention/deepseek_v4_backend.py": "e2b38050e44768e9da10a801979b3b29d9ed80437b4e9c3b277b0d40e6305e85", + "python/sglang/srt/layers/attention/deepseek_v4_backend_hip_radix.py": "9f7ee5f88ca8a31e486797155a365fd6908461405024290a52882ddbe9d33083", + "python/sglang/srt/layers/attention/dsa/dsa_backend_mtp_precompute.py": "0c77157e78272940485f93b1058603b687fb218299e6b6f503df6fb0fb2ac730", + "python/sglang/srt/layers/attention/dsa/dsa_indexer.py": "3404c9b83452d73f156b742ae32e4085a17d0b166d4d5e45afbd31cfa499b686", + "python/sglang/srt/layers/attention/dsa/dsa_indexer_metadata.py": "0661937fa064fc2788b3e23d73bdb4767c344a2cd18d3a217eea74aa0b921881", + "python/sglang/srt/layers/attention/dsa/dsa_npu_indexer.py": "8dec4f5ccf57f1e25e2b673a987406cef71202515141a18e94c1a2c802413bf2", + "python/sglang/srt/layers/attention/dsa/dsa_prefill_cuda_graph.py": "a1e8af9d8e5e4d58bffdec9b7a8e163c2a89e21e5dd7b21cbc86dc479e55c45b", + "python/sglang/srt/layers/attention/dsa/dsa_topk_backend.py": "dc6ebb07bc3551ced77fe5700ea650c072f13a6e703401152e0962c754b62e9f", + "python/sglang/srt/layers/attention/dsa/paged_mqa_logits_backend.py": "211de1eaab2273cd9c84daca4a189b10450b3cedd8fcbdabfb02d0d51d166d33", + "python/sglang/srt/layers/attention/dsa/utils.py": "debec7e26cb978283ee73cdd0d98004a08f157f6e7e9e2f10a620f8f78d67d5a", + "python/sglang/srt/layers/attention/dsa_backend.py": "b58944c0951217301baca28b73e0222fb1b635040c475d550658b2538dd0d06b", + "python/sglang/srt/layers/attention/dsv4/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/attention/dsv4/compress_hip.py": "420eecb061bbbefea41c905b05e152d1894db72016499564b9fc1bc1df338746", + "python/sglang/srt/layers/attention/dsv4/compressor.py": "6eb018051441c42004512ebb0da27e4b5c4df7b01e037127c50b97a2a27303f1", + "python/sglang/srt/layers/attention/dsv4/compressor_v2.py": "b41377aabe59a03041e5ab46ded60bb4d7e77beac2b14d4acebde2299793db3f", + "python/sglang/srt/layers/attention/dsv4/indexer.py": "1718bad546998d9b54fa7bf97256ee36dd3f7a7008406d8870f1efc447ffc7f9", + "python/sglang/srt/layers/attention/dsv4/metadata.py": "c6aa330d5b5b0fa10e8f09de6c758453763d131cfb1787fa0b8f4f17d01beae8", + "python/sglang/srt/layers/attention/dsv4/sparse_prefill_utils.py": "babef988e67b28f37f8706f2e49a99af0bf9669ab0f8922d80bf565db9dc518d", + "python/sglang/srt/layers/attention/dual_chunk_flashattention_backend.py": "b1b6d9053e1dc6528f083f9c019d3b7d5e74b8d580ebd1349ec6942af95aca07", + "python/sglang/srt/layers/attention/flashattention_backend.py": "e29fc321d99239e3002351e93f3d918b593540fa69ef8097a4104ace7409fa9d", + "python/sglang/srt/layers/attention/flashinfer_backend.py": "3487eb51ab3106350a2dfaaaee5f00223d678fc9dc16267c2aca9e90500efb61", + "python/sglang/srt/layers/attention/flashinfer_mla_backend.py": "ec61e3e093e66a9e79ff6a866c0d81d8b4eaed9b3bad74e8e40e4f3491dd401e", + "python/sglang/srt/layers/attention/flashmla_backend.py": "4a6775bfe75163c69158c4058ce81f56f0c689969122059f9b0e41e22b707afd", + "python/sglang/srt/layers/attention/hip_flash_mla.py": "23f450adfcf65f8962973f0e966bbaa759e59de78e1471c334ccacbed50f43ef", + "python/sglang/srt/layers/attention/hpc_ops_backend.py": "a22f4bbcfc90969c7e8c5dcd3cf071daebbf97e8f1c78c16be7fa627951c517f", + "python/sglang/srt/layers/attention/hybrid_attn_backend.py": "7d52b731a8ba2a33a6fde6f82cfef026d6dea4e938e35c2791869a2994d81cc3", + "python/sglang/srt/layers/attention/hybrid_linear_attn_backend.py": "6815a76bdc1ab6d299cbfe6b7abc57e2f6328645d1d7a3ca3c47ac1f14269623", + "python/sglang/srt/layers/attention/index_topk_share.py": "8659afff39a7db8187a6ab101b501bbe65d2e45856d73117ada9ecb6e760c4d4", + "python/sglang/srt/layers/attention/intel_amx_backend.py": "9b9dc0e75a51c3941e0fa805abbb06ad940c5e7b3f3c48b9ffd653b3e4c3face", + "python/sglang/srt/layers/attention/linear/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/attention/linear/gdn_backend.py": "dff629b87777feed0411414d66c096725267b4f8c8433226e0dd36399d440e00", + "python/sglang/srt/layers/attention/linear/inkling_sconv_backend.py": "276f0fa8f6fa80aee897e30f55e8bfbcd5cde8bf589c19307d5d024b39213fdb", + "python/sglang/srt/layers/attention/linear/kda_backend.py": "a1a06b3f5e6c13aac4c43aaed2a53581f384896769175e52975b68119a467025", + "python/sglang/srt/layers/attention/linear/kernels/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/attention/linear/kernels/gdn_cutedsl.py": "282e33bd8c60a77d8687a9bd11d3e13dd75774442967e3a6097476086346901d", + "python/sglang/srt/layers/attention/linear/kernels/gdn_flashinfer.py": "abfe7172239d3477ec5a14d4f2ce0fca1ee6d6dfa958b9e5041c98fbf27f4942", + "python/sglang/srt/layers/attention/linear/kernels/gdn_triton.py": "c3dfaf1eb04c035df2c7374a6714aeaa66c8a49b6573f8f28b100b9e7e063c82", + "python/sglang/srt/layers/attention/linear/kernels/kda_cutedsl.py": "df11b5d8b44644602f3c0ee361e47ee856048185b318ac409250091b4bf490b5", + "python/sglang/srt/layers/attention/linear/kernels/kda_flashinfer.py": "3188204bf8dba01dd462525be0c0266e3b9d240d4f9a5cb0d4c51485b8dfc367", + "python/sglang/srt/layers/attention/linear/kernels/kda_flashkda.py": "efabe373997983415159a3763472f4a1b1b3cdeb752d375a2b6898e2263f5842", + "python/sglang/srt/layers/attention/linear/kernels/kda_helion.py": "e67d3d430992ab425fc5c55db04b2f413c0b82546ea1b1dc1e52aad8199ae292", + "python/sglang/srt/layers/attention/linear/kernels/kda_nvidia.py": "41976cf93d43e2e36da084ed9e138b37cc6a86e5683201fa02dea38b2090bee3", + "python/sglang/srt/layers/attention/linear/kernels/kda_ptx.py": "78bd59a4a5be7ff48d292ce43590b60e73384f5b0838107e11f6ed4f43b57a6a", + "python/sglang/srt/layers/attention/linear/kernels/kda_triton.py": "176b0caff60ce5c26cf97b0c5b45098896a4856f85d588ed7dccfc13848b9b07", + "python/sglang/srt/layers/attention/linear/kernels/kernel_backend.py": "09921e483c106beedb9d3349079e75767bec8d8a0cb2fa900afa9980ea94ca58", + "python/sglang/srt/layers/attention/linear/lightning_backend.py": "0a19f17b4f1276ee16f0802399ef87c5479f0efd2bb757a8a2e43352a4caf25e", + "python/sglang/srt/layers/attention/linear/linear_metadata.py": "281621826248a9650fad6ef1189c7f1857cf154e73e6e6fecec3e5f393e48daf", + "python/sglang/srt/layers/attention/linear/short_conv_backend.py": "c65a74cca0ff0000bb368116eb4c13ff5489c8f86ac414765b84e287964dbbd4", + "python/sglang/srt/layers/attention/linear/utils.py": "77fb6031e34489ac38848d7d4f5995f9a0f1c47c1d4ad777bd978a05a21c7978", + "python/sglang/srt/layers/attention/mamba/causal_conv1d.py": "fccf7b947ef601038d867434f5a774fa3f169c356ba80e71eb255fd5ef249ef4", + "python/sglang/srt/layers/attention/mamba/mamba.py": "81c8860fd634e83977eb1ba2388a370448d9f7226d159a1b7a437f74f1a79196", + "python/sglang/srt/layers/attention/mamba/mamba2_metadata.py": "b4e7187faf88cfaeaf3de16835bec2b78b635db97fdfb2b9abf58e889dd7fdf5", + "python/sglang/srt/layers/attention/mamba/mixer2_rms_norm_gated.py": "3e5bc6cb1d60ac6312e0a408877faff7df7c2e46d787dc2a626bfdc3a470ec9c", + "python/sglang/srt/layers/attention/merge_state.py": "024522ddc38f7e493b937bbf30a5ad7474befd3908053db301a3a32e07bf33cb", + "python/sglang/srt/layers/attention/minimax_sparse_backend.py": "a9741fd74c16e94b8f8f200cdd5dec8df45617cfb3851d0f70b7e518fe431184", + "python/sglang/srt/layers/attention/minimax_sparse_ops/minimax_sparse.py": "630dbf65874310a89b5c7be7493ed75a7ff5add39c526925ffe569df6d4011cd", + "python/sglang/srt/layers/attention/minimax_sparse_ops/msa.py": "b9f1264b195dd49267fe8931b2e201806abcf05e55b0ab33bb1811bb6eb8a9b5", + "python/sglang/srt/layers/attention/minimax_sparse_ops/naive/flash_with_topk_idx.py": "b7bade9994f045b3ce8c494b1d2aa764cf0f9826e1d1bfd83925de7a6d29ac82", + "python/sglang/srt/layers/attention/minimax_sparse_ops/naive/topk_sparse.py": "3f990aa3544ff631d523efa82faae1ca836d0c1156dc3028c73a71eef0753395", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_flash_with_topk_idx.py": "3da8218bb7768b23bb0b7d1c07114c9015ca92e41a8fa4ac85e507508040a0a9", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_fp8_attn_gemm.py": "aa63ce50c88b5dc1351ecd3c59902babb66ce2576b5532aee8e3ae464bdaca89", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_msa_fp8_parity.py": "77d413b73eaf8552541d4402523965d8d45d96bd8dd89aeac96f87f151ce39f1", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_sparse_gqa.py": "cbfe7e55e752ba6d0d9f4cd50b5b18b1e6b455e3c1b4a62a5c43165cf725f339", + "python/sglang/srt/layers/attention/nsa/__init__.py": "d495b896a7c369016e9c5a87f4d3b6bd5a9ff2b60447332ee3b691d5fe525758", + "python/sglang/srt/layers/attention/nsa/dequant_k_cache.py": "ec1360d017a0c03fcdf7ad7edeacc11f4373c67401ba451f8e51b9cc46691b96", + "python/sglang/srt/layers/attention/nsa/index_buf_accessor.py": "b1085dff188766111ed109f602d0544911af598d4cfda4d710404de04c8c34f7", + "python/sglang/srt/layers/attention/nsa/nsa_backend_mtp_precompute.py": "e74ca1e0b174c219f9aae462140f16d339903ead6e62988d6cd63ffce24d0547", + "python/sglang/srt/layers/attention/nsa/nsa_indexer.py": "db51e44afa68cff2be1220416999539e850d1347e2aba74e4882d8fbf81223af", + "python/sglang/srt/layers/attention/nsa/quant_k_cache.py": "b6b29464ad973cdc408cff9698262893a45bd967cc1f24d3349d78d45d797d15", + "python/sglang/srt/layers/attention/nsa/tilelang_kernel.py": "7a5b7eb629245d5cb699ef3becbf2595053d7406971aafdc7b72afc2deec84f4", + "python/sglang/srt/layers/attention/nsa/transform_index.py": "593131a485a3e9c39e07bd733d27bb905de16634118e5d562d09088df7e88bcb", + "python/sglang/srt/layers/attention/nsa/triton_kernel.py": "19133e5a120257e73bc2ecbe255b656d7efc743374b899df13c577aba814ee94", + "python/sglang/srt/layers/attention/nsa/utils.py": "1abd4021f8ba49eb793faa3984dfb41fa5f40a32479066d8e26af258fbee8358", + "python/sglang/srt/layers/attention/nsa_backend.py": "6cb122eb32ad5c07d42dfc2bfb2ae43cb3111befa32ae95d03b09fc732bc2de6", + "python/sglang/srt/layers/attention/qsa/__init__.py": "89d2d232717eba289190f9f6eb95b6984a4db3eb213cb709569d76ed6c56142d", + "python/sglang/srt/layers/attention/qsa/config.py": "71a34e48c672480472e2040cc99955f7b7878a14c4ffa61493f290bb61fd1ad8", + "python/sglang/srt/layers/attention/qsa/dsa_indexer.py": "46fed29d13f11e2fc12f7117999969ca8f3564cc1ff3afaff93da29513bbe41c", + "python/sglang/srt/layers/attention/qsa/glue.py": "cb8064f4fb56e76e9f04d03ac12be23b76ebcad1eb1662f91a97c7a3a0f4c2d8", + "python/sglang/srt/layers/attention/qsa/graph_metadata.py": "9dcb66dffb079ca775677c3294ff45c945461fd8893200fc5d6ed26cc9f6d5f6", + "python/sglang/srt/layers/attention/qsa/kernel.py": "5482e38d30bfaf1624ec0625b4896cbb395a1637f75c183c8ca723c9f6055ff8", + "python/sglang/srt/layers/attention/qsa/metadata.py": "c529169cb0e9887a8d52fdbaa6312963747cb48be0a8058445d4de4aedb8f391", + "python/sglang/srt/layers/attention/qsa/mqa.py": "af36d5c8f4fbda5b0e82b7f31046a95c9a709fcc57b3600c6473c49e87b7629f", + "python/sglang/srt/layers/attention/qsa/qsa_indexer.py": "bb57ce1e9abc4fbfcba2c9aaaf125b9e625983966497df57165b6d4c6461afe2", + "python/sglang/srt/layers/attention/qsa/sparse_attn.py": "c7052125569f3c0fa9a0a4d62d2f57433faec636ad82a1d99c3b39e267b7904c", + "python/sglang/srt/layers/attention/qwen_sparse_attn_backend.py": "12c4d4d34774e5592c3a3ba3956d19a280606007e0161598e4e108bb6caa479b", + "python/sglang/srt/layers/attention/tbo_backend.py": "c19db2433ca43a07b36c48de12a69e4fadd846a6b6e991d985a17f613606564f", + "python/sglang/srt/layers/attention/tokenspeed_mla_backend.py": "429c55fa3284e94002ff18a86b7389c1c0376c504d877df8ac48046bc4a9e031", + "python/sglang/srt/layers/attention/torch_flex_backend.py": "12876a0fbede05168a9e8f997385ec1b4f009783ce7bf9c98516f19476ad3480", + "python/sglang/srt/layers/attention/torch_native_backend.py": "5da07edadf56f4f4e4b8319ed48216b5a8ddb989224d3e95011b76800bf9926b", + "python/sglang/srt/layers/attention/triton_backend.py": "0ae50e5eb33ed9bd951fc11f7754932f0b1589b604ac9d2f86b2a80823b58871", + "python/sglang/srt/layers/attention/trtllm_mha_backend.py": "8790ae6905f9d4450f31a6d63299599bcdf65519b93582ff83468da1f09e5054", + "python/sglang/srt/layers/attention/trtllm_mla_backend.py": "a085dc46dd51e832da65a5a8a0d4339ee7c342bdaf7beec781ed7704bcf2133d", + "python/sglang/srt/layers/attention/unified_mem_hooks.py": "a28e90da52dc0c018eb463486abe61509e40460fe85617b3baecfb44a9fe3013", + "python/sglang/srt/layers/attention/verify_mask.py": "e1117a20ca18ab58fe2246a8a29a37fa722d29f797be4658ccf5bfcc1de6e822", + "python/sglang/srt/layers/attention/vision.py": "db8a8d1b81e6274bc71ec96730799031be9cbbda4d33d565ebcb7131e3d044e5", + "python/sglang/srt/layers/attention/vision_utils.py": "13f18a790d2a6c6b9c4b595fa21aad72e9a61ca69d040835d89e600e8d5b9c64", + "python/sglang/srt/layers/attention/wave_backend.py": "a8abae555ead59fe9ecc2ceee687f64d81b74cf068c7816a283b07da908ff23b", + "python/sglang/srt/layers/attention/wave_ops/decode_attention.py": "a093411b9edcc92831b6625ed4c484b1928e2103979c7d225407053ba0d45af6", + "python/sglang/srt/layers/attention/wave_ops/extend_attention.py": "2f2650408bc561f70870e6e0cbfb444cae49c512e0024398945f8a8467061280", + "python/sglang/srt/layers/attention/wave_ops/prefill_attention.py": "76864c1a71632a4ba6629817b204e0eace71fbb90964ea891f0a9e73b4b0c33a", + "python/sglang/srt/layers/attention/xpu_backend.py": "23dd825db34a51db6135992ac4aeabd916ede09b7fef3f8a3b418fe6cbd34a29", + "python/sglang/srt/layers/attn_residual.py": "bd88b41dce435afbd16c230c2365b6fd7f5f5b2669a5cc8fb8976373dc7e6213", + "python/sglang/srt/layers/aux_hidden_states.py": "a3e5218d5d3dd04703385fa8b9dc52ae753731185925d597b2c2a84f69a18fd2", + "python/sglang/srt/layers/clippable_linear.py": "d1d39d6260ec27aff5ca270e8971853f9eb63bddfbca4baad36ce6d9a739d44d", + "python/sglang/srt/layers/communicator.py": "7305647bba46a6cfac7b1eef10a0c4f4ca89e802cd4a1d045774e8e47db0481f", + "python/sglang/srt/layers/communicator_dsa_cp.py": "b1c011dce9ec8b7d2811d5a9e36aac1cf95cbcee064faa4e98b82e5c75c1b1ae", + "python/sglang/srt/layers/conv.py": "f29a48009e55941c23612d3cf3be2114772d56c052fba70f812b06fe6b61d03f", + "python/sglang/srt/layers/cp/__init__.py": "fef93024570eebcfb78444c297d309267fbc830ea9f6d5bd9838c63641bda1b2", + "python/sglang/srt/layers/cp/base.py": "81ac37624ecdbbfc8de587a51fff1c7274e1dc250c167a68c8f37f98d343dd91", + "python/sglang/srt/layers/cp/bcg.py": "cf2c17500ceac68af2dedf0faa841cd1c58d7f44f0441ca818149b95de201b9b", + "python/sglang/srt/layers/cp/cp_decode_attn_tp.py": "779c506f8c7a5e7f862d94808ab8a3b3ab74555cff86cc7201b787de19f538c0", + "python/sglang/srt/layers/cp/interleave.py": "58b03b4361bdb71cf8e85ee9f6f4d07b6c1d51abb52e01e0ce6e20ba1ea8a2d0", + "python/sglang/srt/layers/cp/padding.py": "9aea07f3de7ded66d7a53c78d6574db4e80eb12be7700cea3bad33edeef7220b", + "python/sglang/srt/layers/cp/utils.py": "7cf1c1d05c999fe570fe297f899a147ef20b118f052df49ec530de27d8facb25", + "python/sglang/srt/layers/cp/zigzag.py": "2dee99c67a48f36dba355566265350ed86b141bc2937b0163d8544ef9bd896d3", + "python/sglang/srt/layers/dcp/__init__.py": "78c69e70f2bf0f7423bd8d4a77127266066c08e674adc949f5b317e3e1bfd97c", + "python/sglang/srt/layers/dcp/comm.py": "26eb9e95396c41bc8cd9bdd403241d62c2983837f32f528d9b2387b7fd97869a", + "python/sglang/srt/layers/dcp/layout.py": "5b923260c3b187d8e44bdcfff62ddb02ac7c4b5f49eb71704cb31fab478fabe8", + "python/sglang/srt/layers/dcp/metadata.py": "4dd11b8579b6501aade57fbfb17f54e90af5bbea2ee9680b5e08bf7fb36b8b6a", + "python/sglang/srt/layers/dcp/planner.py": "44bb3013fccf1830673197ee423fa5df2f024a26f1fce5d51435115d1a27419d", + "python/sglang/srt/layers/deep_gemm_wrapper/__init__.py": "7ac24c77462e8faf2de9060ea66205ba258fd89d9dc53302e1b441347d1793a2", + "python/sglang/srt/layers/deep_gemm_wrapper/compile_utils.py": "c021900fe72b46c54fddb3697172e0f4262efcc946e0824cf23093b17027dc74", + "python/sglang/srt/layers/deep_gemm_wrapper/configurer.py": "5ffe5079bbd081d1d24379897f3a750d0ca2caf74b27533b1a00a038fe64cd55", + "python/sglang/srt/layers/deep_gemm_wrapper/entrypoint.py": "b0ddb397f969ec96d0e0b183bec6d6f03c1bce98a8e416edbe09400dec854bf7", + "python/sglang/srt/layers/dp_attention.py": "3b93b699766e9c285885c7e0caf3ffc9db437d70ea2accdaaac1c7ab1681adff", + "python/sglang/srt/layers/flashinfer_comm_fusion.py": "0f2421dd9272f37343d541335007c18383e352ecb2bfcce544cec9e094dad08a", + "python/sglang/srt/layers/hc_mix_triton.py": "da86f494b04236bd897ff43d282125cc54ea77b9fefa56bdc8d54643761265aa", + "python/sglang/srt/layers/hyperconnection.py": "8bdc97375d53e25d9ed819f295bd6002d9937625df30a51e76161705abc7c35d", + "python/sglang/srt/layers/int4fp8_utils.py": "3d3268e58de63a4c211846c32e65b58df0c2933105ab153c219157be3a15c5b4", + "python/sglang/srt/layers/k3_ar_fusion.py": "23a80dcf59440e272b8dec0af1dba482ea0d7a95b19e1891f33612cf113dba09", + "python/sglang/srt/layers/k3_gemm_ar.py": "50db68e017eeec976b54fb314eb85156f9a4d92bb779b1dc2c4abfab5eb205d4", + "python/sglang/srt/layers/k3_sp_collective.py": "44fcd8e0a34a2f180960749126641bdc18c3aba4ae1256d923c295bdd0f000a1", + "python/sglang/srt/layers/layernorm.py": "5f4732b11e072352ec9341ecd68af86567e2a33e75705461b98d93e914f346a6", + "python/sglang/srt/layers/linear.py": "a18935ab61c7340b30464ceaede64f4474551f07ac06a10bfd3c751f0a4d110f", + "python/sglang/srt/layers/logits_processor.py": "b8698de7d00f2d8cc868d8be5d76cedac5317aa93ce1d3d21731be367d1da527", + "python/sglang/srt/layers/logprob_processor.py": "9e0258d52dab060cd4c7065cd6bfa7e6dfe710c508e09b5351a4d5aefa3bac4d", + "python/sglang/srt/layers/logsumexp.py": "43cf9edc381dfe0fd7b86b71dc8ce2b94542fbf2dbbe4ba319d51d79327f0482", + "python/sglang/srt/layers/model_parallel.py": "ec233594a2e12e3de1fc84f863f15a6f5812fbf96b2a218d520cd0dde632b65b", + "python/sglang/srt/layers/modelopt_utils.py": "01b862c26bb554ea1278f256cad805c51c3feaa4ed376aea4fad433c36e8088c", + "python/sglang/srt/layers/moe/__init__.py": "7df9aea0d7c8d2af91641597051f203596cca3e9264a5a107b5a8c26043cfa1d", + "python/sglang/srt/layers/moe/cutlass_moe.py": "2a070a9e6a9f841830894e2c9bffe37d3c87547ec411a99effb5ece039bac2a7", + "python/sglang/srt/layers/moe/cutlass_moe_params.py": "3268018db84bb5dc1623e1b77fe66d2f2b972a1f639a65ae4523a016373e36c3", + "python/sglang/srt/layers/moe/cutlass_w4a8_moe.py": "6be270292282d2fddbb061b06891a726689495da01140a07186fbfc07f351245", + "python/sglang/srt/layers/moe/dwdp/__init__.py": "fda1aff0944af821a5b874b672b446c24a1481ede5b3a453fd4dafd8a08a46bc", + "python/sglang/srt/layers/moe/dwdp/dwdp_manager.py": "d5464b78f28a95b015fab09d932d93250a13a5f34bfcc2d09c55f093c6a74954", + "python/sglang/srt/layers/moe/dwdp/layout.py": "ddfb483885b76c13696bb918038238b368a9927ed96a5376efe899c3a4dc0601", + "python/sglang/srt/layers/moe/dwdp/page_pool.py": "bb8354fca363240be2b1ba76611929d854884fed49606220ae591ae7cea73a1f", + "python/sglang/srt/layers/moe/dwdp/transport.py": "91e17306782a07af849e56f1cfa3d3ffe40e31a8e39362877f66be07aae9aab4", + "python/sglang/srt/layers/moe/dwdp/weight_buffer.py": "59159a7462bde5e347c1b6185ffd119574b427ed20ce5d089efa07054164bbf5", + "python/sglang/srt/layers/moe/dwdp/weight_manager.py": "5e9894e21c179d23df878aa51d3abb5ed39cad4f7bb64c51a27adc139e3661fd", + "python/sglang/srt/layers/moe/ep_moe/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/moe/ep_moe/layer.py": "ff3480f06c3baee391190023a3040c39b970ae890d908c42a00f3c599d2e484a", + "python/sglang/srt/layers/moe/flashinfer_cutedsl_moe.py": "3a153a26287d4e30e82585a9bf1304070635bc0982adee701fc204048b2aebed", + "python/sglang/srt/layers/moe/flashinfer_trtllm_moe.py": "7f5a729870d540ab4f81599e1f59fbe72d8b95d03119bc46f37eb48068c6fa5b", + "python/sglang/srt/layers/moe/fused_moe_native.py": "abfafce66f9bc4565a7aab73a40394d9bc4e042bcf477d5f408553c94a27e498", + "python/sglang/srt/layers/moe/fused_moe_triton/__init__.py": "be2cc3fbe561df1d6eef6eaac65238eeecece81c00f85dc8b5cd1cb504c7d1fc", + "python/sglang/srt/layers/moe/fused_moe_triton/fused_marlin_moe.py": "fab293ee5aaa0d285d161c3bbf23606d2908fe3273eae5f32eb5b49db52f81e4", + "python/sglang/srt/layers/moe/fused_moe_triton/layer.py": "dcb2620e96f23e1004e1439914a807e74293d3c1080db929f9aa542e742e5f05", + "python/sglang/srt/layers/moe/fused_moe_triton/triton_kernels_moe.py": "9eb4b8507b0789db1cb198087a256db28cac913bce36785342428c137ec11882", + "python/sglang/srt/layers/moe/hash_topk.py": "46e637193155824260574ddb085eedb9981298cb1a050ebac62507e6e999f3d2", + "python/sglang/srt/layers/moe/kt_ep_wrapper.py": "639ee63f05ea9767ad267d6d86d9f1b9cecdbbc2970611271e2b771b7bdfdefb", + "python/sglang/srt/layers/moe/mega_moe.py": "fb299d42fae12c78c04cb1760806196f47933b74f0a552826967b77902b0d012", + "python/sglang/srt/layers/moe/mega_moe_sm90.py": "70e8782065a5958eff4a3bbd6986b2a02a8515aab34993d741f8a56658b31e8e", + "python/sglang/srt/layers/moe/moe_runner/__init__.py": "0dce0f1fa1dfcd00e32562fb8ae67ed2a87ca11bbb3ad9c7e88125ebbe696225", + "python/sglang/srt/layers/moe/moe_runner/aiter.py": "459671709b8b7a36ab246f0d0846450b6f6b607de4a17e34831da9e19ce64641", + "python/sglang/srt/layers/moe/moe_runner/ascend.py": "00782903e91d3d9bc17346e15ab950e416a29b609ceaec19b4743c6b5dbb9e51", + "python/sglang/srt/layers/moe/moe_runner/base.py": "66dc391ebd36cf524c058c7ada8bcf32e5fbc446faebf4f672ca6ddcd4f18bd3", + "python/sglang/srt/layers/moe/moe_runner/deep_gemm.py": "c46be8b94401e3ef2619da100688e193b4d352d2e5493e4d7697dd4a92fcf3d6", + "python/sglang/srt/layers/moe/moe_runner/flashinfer_cutedsl.py": "cca94d12d5a062e59582f42b5afa842b72ca1b2baf60367b5542d09f5606da53", + "python/sglang/srt/layers/moe/moe_runner/flashinfer_cutlass.py": "655f7170a7898d28a3c0f539e4f5a2b419509803cd34e32590fff04fb02cf1ad", + "python/sglang/srt/layers/moe/moe_runner/flashinfer_trtllm.py": "b7229908c6ac61f0d78fb82aa77a20077dcbeef72df67e19711d285d495044a8", + "python/sglang/srt/layers/moe/moe_runner/hpc_ops.py": "c138600761d1aefa039eb1048f94fcfe7e6ecc7e7df02f55390aee9ac569f16f", + "python/sglang/srt/layers/moe/moe_runner/humming.py": "57bd948627238de937ad0394f59e40a8b49e6eca91e62c74880df19e0ff847b6", + "python/sglang/srt/layers/moe/moe_runner/marlin.py": "e1db2b78559fd7ed482710f0b95104339ebcd41721a3cb85e17fbc63ab683734", + "python/sglang/srt/layers/moe/moe_runner/runner.py": "46eace8bba47c7f207a264f94b3970ce693657e6cb383f0afc0ea25fb54f2bc5", + "python/sglang/srt/layers/moe/moe_runner/triton.py": "f2d0957311876f2e1c405c5bf18fe105754a32700693a7b83551a075a0dcf475", + "python/sglang/srt/layers/moe/moe_runner/triton_kernels.py": "0f515ee1673e3d4f2e5586c891680ac33971c112b3a5a7f7b52ccabd25b4e84b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/__init__.py": "17001b79d53924601d242d37aa2ba0b144002f02a5b6f1a75e168d97e508829d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/README.md": "6e075121eaff9bfb859498a86bf46cc009b9f3f6a8cc8f0308f959e4bfcdd0ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_sm_100.json": "0d997c67fe7e4b741fbfebae8cc3b88c8f1a4363027409d09d695a77e3000b3e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_sm_90.json": "ccc12031249f4a84a4c534a09217e2846773edf1605c386e9d6dc1473d2768fc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_sm_95.json": "ccc12031249f4a84a4c534a09217e2846773edf1605c386e9d6dc1473d2768fc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_with_prefix_sm_100.json": "ca44d18f28dd39b40ff08052787ec4ea25c994dfe643640f4319aed2a3c0317e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_with_prefix_sm_90.json": "ed8bc5dc1c239ce71fcfc96234612f8efe91025718a4ca9aa0b5490f85a7c323", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_with_prefix_sm_95.json": "6d6dd15bc98773d1f2597c1b683c2a710fb52d092d6c5fb7bd273790217dc9bb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/minimax_m3_gfx950_mxfp8_compact_moe.json": "f08a7280b6fee5aa64b615b007fdd26b344a2958b22023206d0766801a8d68c3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=14336,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "88d1ac13665e5674049cde00f1427d26fd1dde16d1176309f680608eea794b39", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=14336,device_name=NVIDIA_A100-SXM4-80GB.json": "24937486bcb22ebe59bf77524bb0bc70f1610304d3e97c54567046319bd5e890", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=1792,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "a2e4726793c430f3f69e33dfb42361b3ed60d72eb0b9e58b9a123b1b54a35759", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json": "75de1a419d5a7d7684192dd9507df561cde6696853e0beb59b6d904f18ea066f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3072,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "f062d9cce5493697ce5d731068cb6f7294080b33c6de30cd011bc7e0fc475feb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3072,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json": "b3eeea043c7f277985bb4f4d935e1956c786797e463cd452b508e8851098b7a9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3072,device_name=NVIDIA_H100_80GB_HBM3.json": "ca9c6c1feeb6330d9377a23c93a2bc039d83f4e46c52dc1c053861cfe87b7f62", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3584,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "d99dbb68a75a038571aad20293e7ede527351ea452f3b98ddabcbb7178420fd8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json": "c9fdf76265a55528e3ca0d10e0e3005af73d823471bedb4cad005410e7cf9782", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "6563029583759a855150fd9fd2161a737f1d8bfa54819820ca5f5dd83e6b9e87", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json": "0bae50d8cbf52f1150fea0e7bf5d4867d9f097bb06668ef69d60df94cb6dbb88", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=144,N=512,device_name=NVIDIA_H100_80GB_HBM3.json": "a64e95642861d98d02b094b38ed5213a796d6b540b4d4116cb7dda290538ed76", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1024,device_name=NVIDIA_H100_80GB_HBM3.json": "1a6936e2173995521f42da926b9c0b39c58a79d30df1a6547bddc3061e89d406", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1024,device_name=NVIDIA_H200.json": "b98fd730fa26697317c4891347872d53f61bae2fe332fd95bc2715f9fe8efdbc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1344,device_name=NVIDIA_A100-SXM4-40GB.json": "a4208a91d533cee055b658f293b0042006de0dfd760d48a279768e0d95f39b91", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1344,device_name=NVIDIA_A100-SXM4-80GB.json": "b6b5f6f9ce0dea14d30facc5362e80d9b4f71648712a390cdab3e5fa8d4af6cb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "238779eae0fb13524c5c3f51031ab715e6dd3eab83b2734491568863d0ad9bdc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=14336,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "b2a90f8b86ad54f026c7f43b2ae4eab2f8cb388a6727370beb241122f1ac252f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=14336,device_name=NVIDIA_A100-SXM4-80GB.json": "d1e8e09c843f9b32612a34299d3f88d558fdfab3df1a54dc43cbb471781e914c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1792,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "954e1f8e78099a9cce69f8bedffab4be3da92df6505556a016764da08f7b7ad9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json": "8a551fefa4e66ed68bdd6d1b6ab6ba248044895fe23c8b36f548cb6c7fc662d7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=2048,device_name=NVIDIA_H100_80GB_HBM3.json": "e327b555a908233ac6513c4635bfc3339bf9f5d8cb82893c49e05e53f608e86a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=2688,device_name=NVIDIA_A100-SXM4-80GB.json": "1b83caa96c61d0c941860ed01ca8f49befbf7cfdcb97482ced525a7a0f8d2033", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "6ca5fd02f73137a93e8b745498749c859677ae3a184586f8881aa1088e0bdcc6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3072,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "39e25408f5410f5cfd092a28669cb7851c806ac8caa850106932dc58ae8f5a7a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3072,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json": "3a2117bf19b9b6671bac4b52216952ebbc7ee21f7a803837d4bdec3e34a19c4a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3200,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "7065632b1df8009444d8b198fc95b0a704b9801a83f7f73d4f7c5ed2950c1fd8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3584,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "72ec3d1ed7b3e3a1a43c1f133ed0838891a1192a407ea038f9498bcb7d961c5b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json": "168d609459df9d840ea8dbe4f0a6aed963fdd223bacd3677ea21bd32b95b3d4f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=6400,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "c4e423f72f4240544244167c1bd447330d373eb08dc9ba5c5d1539b0c13ce3e6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "d58b056b9203d234c7231386a64b7c55e0f3845f4ba720137d0af2fe29120d5c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json": "14656fb2fc36dc378314b8fb4cdaa6e34d9f02d89bd9c3c645947778f05e529e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json": "9249607f6a8b239090622249e5ef46c71da001f1b17323036297499c85cf57c1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=800,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "f1ed2d37f0c73f0be1fc7102547c7da0e17fe1659d6a1b78b3a36677f2be6815", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=160,N=192,device_name=NVIDIA_A800-SXM4-80GB.json": "7d1cca7d5148727c6abba0ef18940d96db854511b3f05f9e68bef76c8cc1ce8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=20,N=2048,device_name=NVIDIA_H100_80GB_HBM3.json": "cead71dcac19dd8bb3138d8e3cfb049574ff552f6c2b5df909d07546ca2d2d4e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=24,N=1024,device_name=NVIDIA_H100_80GB_HBM3.json": "9496c46bb56c05528bfe24681e7881fb69dc78cacf72d92ab632acccf9d7e299", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "46e5032bd5df817b3579911259047d6dae2dbbeac2446fd4098c23689e7af2c2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8.json": "c250a2f5aa18a7b65cd464e112eb6f5836ec7b490a9cd69080526c77f2fc6ded", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b4f6317a8ff150e92342b64c75ff6fe08685af0d1119a64d2c62c93ce86313f8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "316ecaccd6bb0dc2a6e77bb6261fa69dbf7703720279f8101e474a38d24c7dec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "d1a498ce9bff701025a5608fadf1a035309f69ed4a74a4274f9e84f1715097b0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_H20,block_shape=[128, 128].json": "2443978f8f29870a2e999581c0dabd4e9ab157022b6e77e8b7841f01dcef2c92", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "2eaa26fd53083ddb9265365075e2f65a5ff1debf6ae91988f5ba2326b630419e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "5e628568c85eabb34daecbd8089b5eba5d30f34f65fe5e3ad19883402f53a06b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e6ba3d3bc35ffbb301f0d182437415e6407693789259ed2b753cf60385bbd820", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e6ba3d3bc35ffbb301f0d182437415e6407693789259ed2b753cf60385bbd820", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "db7089bf775ed540d7dc476e329ca50fd000f2a2f99333128cb2b818332a96ba", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "20c4ca9cf463852a6d7fbb26224a6a98c8d230bf5243b23c0a991b477227cea9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "c89cc75fc9cd5a72b08fd33cdbcd5dc303e1387434dfd981a6f3601bba68cb74", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4780769f6bc6b78a4fa3a8d2e019a7c7c018b5c7c5f6a4091396c3ece8665c7b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=64,device_name=NVIDIA_A800-SXM4-80GB.json": "6385a99951a5184447a1ea10346910f860be32c12d31b96a9c056e0db01125dc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=64,device_name=NVIDIA_L20,dtype=int8_w8a8.json": "45491df5f5bd59b6a317f7c5233a69b04d6ac96191e5a442e02967f813ddbb6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=64,device_name=NVIDIA_L40S,dtype=int8_w8a8.json": "49cf712b5c2d454a88cd7a696eeb5cabe6367bd3340d9976386573cc1d1a42e2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "4c1b1caf5b96c2963416b290e58dc43bf420e88f7bbb87ffce39d646fa1e2ef1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_A100-SXM4-80GB.json": "e903cb859bab22a70c55dcb7c340ddee02d588ac6cc89441cfea9df1a8298ba4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_A800-SXM4-80GB.json": "baff91c133594f69f6eb874ba38796c54a41de0ed0a94c9fd8c1441a246fa2a4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "5db09120e9a236a54a87cf69fb4531befb2920d443035895f377fd979c8e4700", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H100_80GB_HBM3.json": "e2e4278c63d6a24b1caf18970c8bdec4e03c3a42b9be4a08ba59afbcc1481288", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "8b90178f6ea6588fb11283a72c26435d4cf3f239364630dc1ae6a24f541849b6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H200.json": "7c92a4e4b10cfcb4a7ab5c9cdde90ba807db516ccfa23400eb25f75e0485a3ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=2560,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "8895659c261334331be94d549d5e3a66e2fff0b7293affd715a61621e44578d0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=2560,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "29fbd2602306e3cbe745bdf977d58ec58c99ba523e441ad41975074315e2e219", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=2560,device_name=NVIDIA_H200.json": "eb4cae3a5bae93aabcf197b4b683c907c873301bc5ed95b2319a6b88c7507f78", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "0c0e0fac2bbf04d2d2596553c0e89c35f6f2a94356ec14d90b6772173f4355b5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H100_80GB_HBM3.json": "a6b8fe43175f4bd36ce5644fbda858fd3afb0b2aa569580d1cf4fcf524b9cf38", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "0148281cad4f98015e852366b1bc6e9e505dccce744399c5bdd9c6f4548e8cec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H200.json": "a42e5f76d105739695373a63fd1107873d503eb1af808f62402be5a1d0cfec9f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "c99ffa2a0c09bca3c66e5a5b1cf42f10c71473d17b1bd0349925c77e07f3b60a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_A100-SXM4-80GB.json": "a3138a143ae09b0d589a0c53b516b5ba87b7a74f729532eb923fe3393a8d8754", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_A800-SXM4-80GB.json": "6dfafbd2be8f98cf79c3bada69b40e68e3923e2c14d8e40239987e90a5c87a16", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_GeForce_RTX_4090,dtype=fp8_w8a8.json": "e20f650015099c1fa25705df60f61c234e5714f1b88d8f28d322542bb9123d93", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "4462eaac01af3c2159d2330f0422744eab27ad2756f846d469266eeb571618df", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H100_80GB_HBM3.json": "b231153d54e0500969e2cf2d64b192c9e3736d6eb34ed526d888a81f79d9b088", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "783dd8f6c3b01c572055d39fc9af0ac4f86f2f1fdbe3085f1169b877c6361d6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H200.json": "2887e9672752977d45384aaad0405fc53c96463d504c3c138e43c716334edff0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=AMD_Instinct_MI300X.json": "1e1dec7c1391e63dc7cfd3b6ca83b0e7a03c28061969ba964ebd6e5de9b8befb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=AMD_Instinct_MI325X.json": "1e1dec7c1391e63dc7cfd3b6ca83b0e7a03c28061969ba964ebd6e5de9b8befb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=AMD_Radeon_Graphics.json": "1e1dec7c1391e63dc7cfd3b6ca83b0e7a03c28061969ba964ebd6e5de9b8befb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "57fb200ed12d184b81b0655ad266982478611aa7b5344ee5fb57a4d9e77d58ff", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "2c3e19e4c451e48be2e1b601e61320ca6b6f985c95270aba8267a103b7f379c7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=NVIDIA_H200.json": "18b207e1e820fa913e3565395ea2ae242a115dc88737a19273735a1383da7988", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=AMD_Instinct_MI300X.json": "cdc36f5f25af79605e7ee093be222d7679050148b7a2edf43c7a6492dc287503", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=AMD_Instinct_MI325X.json": "cdc36f5f25af79605e7ee093be222d7679050148b7a2edf43c7a6492dc287503", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=AMD_Radeon_Graphics.json": "cdc36f5f25af79605e7ee093be222d7679050148b7a2edf43c7a6492dc287503", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_A100-SXM4-40GB.json": "01f7c3734ff9d4c2fc1e2037ef9ef36c3d744d925d52c50321822a3b8834c94c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json": "204601363b7d1c69f3a0e5525af2f40348d4aaaf76e900f4fc1bd5611e110356", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_H100_80GB_HBM3.json": "36cf58d766996c99c585c1b79f06faedb0eaaa2400a3db5d4c021ef0ad808f3e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "a1b36d1e5aacea5e8406a1a6d1ed130f6c11f53628415fcdf58ee89bce3b5899", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_H200.json": "8eec4961e59814778b6fef37fc80e0ac7129a1e484babb235c3e379931c174b1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_A100-SXM4-80GB.json": "1cec5698223689f1e659cd28af6cbc9c47a7f3a8c378b0e8bf5fadb8ccee871a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "72c1dece1d0719668dc2b6e51b3320704f7986a6ea8d64bc1c898b44962bfedb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H100_80GB_HBM3.json": "ff9c1e2c18a74020f3c95ef98472884fde58d1c7bde0a59fb76ff9042e8491b4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "e0ee1578ca6014daea5b25aa5a06207180200509ce9405efb76e824525cafac6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H200.json": "a9f8db5ea6e5f74d93ba2cb3ce8994cb6b0cbecf83b9df19a610d16395883c13", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=AMD_Instinct_MI300X.json": "667b25bd3e8796371a9d6c188c5f27b61c2aaff878b63c9bff010b05d7060f8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=AMD_Instinct_MI325X.json": "667b25bd3e8796371a9d6c188c5f27b61c2aaff878b63c9bff010b05d7060f8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=AMD_Radeon_Graphics.json": "667b25bd3e8796371a9d6c188c5f27b61c2aaff878b63c9bff010b05d7060f8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_A100-SXM4-40GB.json": "46ee3ad1982750fe14f0eb097f017c9fe008fa07dca25351dffab3a311ba0ed6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json": "2ba046acac3fa074c0b478ec66575c8e9f8150cd5d21e70a5ebad19fd3a9446b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_GeForce_RTX_4090,dtype=fp8_w8a8.json": "e10ffec884cc7e28ce32882e50cda7f7a72501187e0d416c4bee285bf6b72697", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "aaa16831a39bb8ef291567126fdab4c18b1d0b879208eec1fbfaee42147537d3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H100_80GB_HBM3.json": "fb99e42c8ba78c6d6084fa1412db76017110c3da068a294fecadd4bd0bfd0aa1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "0578d254676f80fffeef14ef6c738ee99ad759ed2a4978900a1c681c68162fba", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H200.json": "3e2d9ca0994996982a5e23d177bec1fde0a69a2eec09d06ea1218ad5103960ef", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_L40S.json": "a76aa54614edee8c1607c91e126a02acf669a37f48031b0a9d42c543b477f122", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json": "85d598a640567c6f64c1461ca3554d8f053f4bae42a1ab75bb37c4265df751f6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json": "85d598a640567c6f64c1461ca3554d8f053f4bae42a1ab75bb37c4265df751f6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8.json": "85d598a640567c6f64c1461ca3554d8f053f4bae42a1ab75bb37c4265df751f6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_A100-SXM4-80GB.json": "0f162ef2b7a064e485bbcba014603f41bc162b883cc70414645f5afe7358e02b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "a1bcdf13ff5782c6c535f0bd6e260e1f147e57f06073b3ca4fca996496a22497", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H100_80GB_HBM3.json": "ab02b2f2868cb1ddd0ad78106ccff1f7171f6221cafcebb5084c033cbe466e0a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "ad1f1bf8eb90df06ad6fc6f6cee365c4a0d2669ce501a826f676fe15d2a4b7bb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H200.json": "f06fd0a95fc386f67ac526af312a5e13aa9c5cf569b158c4b4969bc9dc9b2aa6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=AMD_Instinct_MI300X.json": "856e3cb7d27ba6d76d8a5e8c28c49f5d5f8743c11b6b748b3a049c36ec2c7928", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=AMD_Instinct_MI325X.json": "856e3cb7d27ba6d76d8a5e8c28c49f5d5f8743c11b6b748b3a049c36ec2c7928", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=AMD_Radeon_Graphics.json": "856e3cb7d27ba6d76d8a5e8c28c49f5d5f8743c11b6b748b3a049c36ec2c7928", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json": "0402675d36687b0c02b7324b50f274a18b802efeb8d0cbc3b8bb1e19cb1869ac", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "f938fb2264ba6450e87ffd154f2abb9159bc5c3f41e78443e8250e3d27f72638", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3.json": "b667b4c9d5b32317400592e4e2d53c1bf5f674951818664d910ccd19c99cbd47", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "dd841a9129942a1a70d4a3bb1e7fad11cfb2c83d5f123d35ffa2654989ebae52", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H200.json": "5b691afd4f29cf08f35fad8d106297477daeb9247fcdf1c3d578d761fe5b801b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json": "f91cd459220002c83a880fbc48f31aebc84fa41568532309b3774b3fb79d46ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json": "f91cd459220002c83a880fbc48f31aebc84fa41568532309b3774b3fb79d46ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8.json": "f91cd459220002c83a880fbc48f31aebc84fa41568532309b3774b3fb79d46ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "b18da758c3e1f65b089213c28e41cedb8e70a677c56eb1e6cdd7190d514f570c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "533e57f3455c34139ac6c87054d5048adb47936cea0781d009f4c9e133c6e5a3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_A800-SXM4-80GB.json": "4fefd3fa85b8aa98d3201686571ba4264b1113b620f26f47347809d97991dda2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_H100_80GB_HBM3.json": "237938d7a1db5d4feb61bf2c703f20008e1fb81944947974e8f337e3b41ad75c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_H20.json": "46057c0b81752ced3d874d58b2017f7aa5fa18da01b42eee94f7c945451b83f8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_H200.json": "9ec344b83364b34b552df41f226ef1c45c047a9b537d07286bd7c9cb4352f314", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H100_80GB_HBM3.json": "478801737b0c6394303ad706c0629d936024e14b146c17778c351e28a9343b55", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a9baa38ac278a0a99c633ba61cf464e54c8ecec762f09eb16acf365161cc7802", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H20.json": "bd2d834480cea96ca206f6c6e87ef8ea8c277e40f517c023d98674113f71965f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d67e57c99679b0a022f99d5db963a12d47ebea092f9cea6fc5f6ea213ea253fe", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H200.json": "c6a865ef8f22b7c195d8a5d7d178b18ad13fcb09ec2a4b2a2bc0062fbb40813f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=512,device_name=NVIDIA_H100_80GB_HBM3.json": "16c59b57843a03302d81e815b843410f3d9971226ca8d8b050855f41ba4fee14", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_A800-SXM4-80GB.json": "4f9ad724e658344b3fde113c837721f34d839f249b36222a767d2cd11949afc5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H100_80GB_HBM3.json": "f4be42f15712b2252be57af25c1d403b70e49e5010a30a7a0d4e92ece4b3100d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "22ebf20bc4cd84254099465f2d2a044ecc822ac99e8ca5ebb3fd33bb014b3c05", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H20.json": "d7436dbb66950f9bc62e89f1fa35b4a8dc3eb606567599b3306c7bbad0d57a78", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "a5d43546f5ef7560e7f18f3ef0c017def9fe4fec1bb6466f1d5f46659bcd8e77", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H200.json": "26b68cf8dbdb83957f4c991297a50f15864dd731c7a086ebda901c92c7a7a136", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=96,device_name=NVIDIA_H20.json": "26d7074653f3f3140402a27d11623ade862f7668d0146e954c7aadb7ce553920", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=129,N=352,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "2fc6d51dd3da07baf991c361a0478df9efc6167cfa39c05cf24db4e849e407b0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=160,N=320,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "65138dd97211459aef277b5b3ee43bfb41ea199fc590fa51377ca3d62b069a98", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=161,N=192,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "780d617f7b245c5ef21371f2dde0cc337b1b973c0fd877d35206be6223d79c96", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "b6d16e2f5aca9c4a52848b66946c8294e7e95302e2e5c65815a560a3b080c670", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "3dcdab8bea83072b257c3f0b809b5107d4035a323e2aa31e0397ed96d8b0cbc9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "baeb9af55ebed47dfc01230f43ad2ded43ad5742102d95810a5d77330436e52b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "7f43c0a3642bae37bb04f632a81db56b3f93872cb6cc286d0ed4df00591e9fe5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "0423be7148c01b5784f48ffd2e8892b47533f1d1106298e23f31ed4d75f22c5d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "ed89ad6972a7997f037589d427b59015aef18ebd98ba7f5621d40da027ff2b6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f2035a9a29fa3aa32243e2cc55ee32401a3d38d8a8882e25a1258f9ca712d572", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "dd9b7885b0b7c89c56bcfd13ecaf776003da50ff1f4353f55a4d021aab4181af", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3fc1a9551f1f8eb5fb3856c1045138cb8309e2e860a32515e0d6029b5aa15b19", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "e01d129b3450dbe3ec0497057bb9de33538a7d6a6c6e2638c7a73a08e40d32c4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "5f288e0ae7e102ee4108c1e85bdab880b49140419ddb66c99c9930d7932a1588", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "7f91d38bff5f5af227132269f2916069537a03dbf1bb7ffce3979264637d629a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=64,device_name=NVIDIA_A800-SXM4-80GB.json": "3e2c382cde9df1062b51a856b30dd750eb53303d68def1cfc00f78b06239e869", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=288,N=64,device_name=NVIDIA_A800-SXM4-80GB.json": "dd3f3fac5d8f1288e181333243c0ec71780909659d59f0cf8f8338df8cd6700e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3.json": "b667b4c9d5b32317400592e4e2d53c1bf5f674951818664d910ccd19c99cbd47", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_0/E=16,N=1024,device_name=NVIDIA_B200.json": "85ef3bddaa0ecbb29f160fae3284c557820fed89340e4ee6393b8b093ab06597", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=352,device_name=NVIDIA_RTX_6000_Ada_Generation,dtype=fp8_w8a8.json": "44c630aad07b85879a0b2b99d5f7959d18411a53788cc7263505f686a52a0659", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=384,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "2cdc755bf06c5997291e89a249c0916a9e3a755d3e17b4bfc371edb24a2a966f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a9ceea9c093705870fe66fde4fc20f0df9ef16b9e0fe4891092dfafd4cb5336a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=768,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "25f2d91d50bce19b075487612768c64fdaf666a186c41a88671e0746315ce27e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=768,device_name=NVIDIA_H20.json": "4f6b0d1d56422dbcae3baf197ae754cd0301b00433b36f9ea39dc8f84508b963", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "aea3d6a517daf6ced449af5c5321c054fe74598902a970c9cdf29986a93a187c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=320,device_name=NVIDIA_H20-3e.json": "716904a4daa7ca7d104bc1dc8168b0588d71aa1fd4f77fd2d64c8d79bebd68e7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=384,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "8c659f64d3f94f57a7f0a5f4ffde25aaa4ca4505c2fca92afe526bb58e2013c6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "9da2b0fb6a9bcb6c43ba96752e66ad7f6a3f0a86e476f152f15e8250e4562e92", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "396dd6d36f4e6e6e07a22bb165b6e34c3c13508199e10afdcc3b2e99873d9bb9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3f46edcf1e4aa2b0a7a94c58cdbb9b21f5217dabe36b6f1dfbba447625c8d138", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "7e8d5a902b86a2a706c1081f879ea1029820fb02d77e8f641c792c13fea6d45e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a07e1b0a48c17bd3e1bea7dda939750e79e1f791da3d3e375438b3ed58e43140", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "31e50b5d6c8defdae8b124c9a7740e0e613fc844070a470322f01537758e4816", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "573d60f98b5359cbf9ef7118691ecbce1265472a2768cb073d3d8c323b9127d9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=384,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "10d0d89c2d658cf3690d51dd9aa47b51b803593d483ffe7964843f39a7b7e262", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=384,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e5402cf19d66cb0f05fb9158d871d677958c4f68a2f57f9a6086247f716c03cb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=384,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "f78d595c9b62f7dfc651e8b29703d45aa60af1be78f31b8d223bf4a73f4a72a8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=385,N=128,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "ae017e2920145e623b406ae1314cb03d57de4f1cff8fcfc83f837ee9b91875a9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=385,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "eda6a88b4308db10b964991f9644d9007e2d6b04cf76652999c04e80e2272b1b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3.json": "6bd5c96745ee7544de6c074de60b95abedd74af65eb472118dab4ed7eff4c429", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "258d7cdf6b08b753085846687ca998a1d2cdcd537877b3553a2d26181b8a1293", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=1856,device_name=NVIDIA_L40S.json": "843c6b9bb214a1997d01747740eddda05098b2b4c7ddefbba71d94c8cf692680", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "f8c65a67847daf9464f1af4e11ad5e33f4ba20d95cb17ebc063e7fa4ce006b45", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=352,device_name=NVIDIA_RTX_5880_Ada_Generation,dtype=fp8_w8a8.json": "2fb69c50c0e661939e03eae211db35fabf56b2ad8a0562651bb5fbae29568df0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=384,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e896063788a6c3322b4001206e848ef77c16601ba0bb34e00637d379dab673f4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=928,device_name=NVIDIA_L40S.json": "6cc134108aa31e1522de15ccf3a4af402d03a89beaa88079fab1625548ebc84d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=129,N=352,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "0a53e8808366e40b278c3ab1e87cffac7ae69e709d50f89dfa3608748823671b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=129,N=352,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition,dtype=fp8_w8a8.json": "44c630aad07b85879a0b2b99d5f7959d18411a53788cc7263505f686a52a0659", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=129,N=704,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "5bc0b51ad3f82b8dd22bdd76f14e760c3e565a87ef3e5780244e2eb36423bb59", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=160,N=384,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "1d197aeebf7c2724576f64a45d418c54a01c44c6f1f4c22b245a7c3b54969e83", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=161,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "eda579fbd27b541c3a7a0909c82f86babc3904f4dc86c6eba27b351286db89d6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=161,N=384,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition,dtype=fp8_w8a8.json": "44c630aad07b85879a0b2b99d5f7959d18411a53788cc7263505f686a52a0659", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4fa902b42532b42c625bc24e2df105dd881d083f7f98a71c27ce48a93d1bf0b5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=256,device_name=NVIDIA_B200.json": "3642d5722e6ed8619eb856c2dddffa3e27014b7992b95efb2480824b353ff1c7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=256,device_name=NVIDIA_H800,dtype=fp8_w8a8,block_shape=[128, 128].json": "3375b539053a46028040bd84a188af00889db73d5cbe0a0aebfea7b4d7e7fe56", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=512,device_name=NVIDIA_B200.json": "b9c517c01b040e35f23045446034eb038e567d63937dda68d7d6d36f2bffbd97", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=512,device_name=NVIDIA_H20.json": "6d27be294c22553df233d8d0b979439b17bf2947edec5527e7339bcbc6e94a47", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "45b2584d17e33ffdfecad7e3e775bfc368c5a59f71c0c6aaa0a5b9da99203f77", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "85a3ac0b17e396eabc44828e2b5bc4d13bab121c7659a0759c7e0a75d8d198c6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "6815bbd1e8ee6c9ec9101a7d434c1a4c9e60fda243b5629dd9c93a56d3061a14", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=64,device_name=NVIDIA_A100-SXM4-80GB.json": "40493c6c4f8689e665b538afde283ffd270cf50ff82be73be54cc8b83ac698f0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=384,N=128,device_name=,dtype=int4_w4a16.json": "739e5a0ae85eaa88a123ca9f32ffe800300c7bc8adcc2e5d63f4eb7b98908159", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=384,N=128,device_name=,dtype=int4_w4a16_down.json": "739e5a0ae85eaa88a123ca9f32ffe800300c7bc8adcc2e5d63f4eb7b98908159", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=384,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "1449e3bafbe4cbe72f5b58aaf133eb7c638e1fccb8ace131e23958678b6a6c3b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H100_80GB_HBM3.json": "254ceaeaf273380570dd5397cc28c1a5a2e97f93b13d09a8da224f263ccc9baa", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H20-3e.json": "6ab4d7b0b91ae315a408444d05ac911ea7e1c2bb6a75dfd8872f92ce25554d96", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H200.json": "1d11895aacb5082ee8b9163a7bfb770bcdf608cd01225434668ea7a1fcc17fc9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H800,dtype=fp8_w8a8,block_shape=[128, 128].json": "d8f289e3e98bc55583826f3526d923469cf598a710ced19d991f3822d94c59f4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=256,device_name=NVIDIA_B200.json": "3dbb49d1d256600058923a0dffabefb124606c690dbc614d8d04f7f2a89dd7ee", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=256,device_name=NVIDIA_H20-3e.json": "de839016c6ce8de8c7ff341a31894a52d43a4a7c481f9fdfdd421a15f4a573c5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=256,device_name=NVIDIA_H200.json": "9a688d50d15a8e56128c55cbd03332912e88f83d4ff004177510697820110fed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=64,device_name=NVIDIA_H100_80GB_HBM3.json": "15e4402a415497788c94d041adbfd8a1ee0eb16caf49b56de7ec265c48cb6c54", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=64,device_name=NVIDIA_H200.json": "a619a1910373f0370b1cfa8de6d8e626a3a06d7d01850c7d70ff367e9fe3c884", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "d7cd2d02c8485903be9d7748a6ce5e59d4aeafd3b09b2bbcf4dd2d895aebef94", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8_down.json": "d7cd2d02c8485903be9d7748a6ce5e59d4aeafd3b09b2bbcf4dd2d895aebef94", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1344,device_name=NVIDIA_B200.json": "e148af672111c72e10ed900eb91dd7b03685283aaaa740057950934208d24954", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "65d860614936717d909f85778998708a4fd23bfb5976077d52fe4efc2c0cb020", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1856,device_name=NVIDIA_B200.json": "4436c2bfbc22853263ca73e1b9092952da06843df216bbdd827dc8ba37f7da1f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "21aabda50ed3348325e25327464f6a33ffb470415142c2a947b388fbd3b09809", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=232,device_name=NVIDIA_B200.json": "7fc486f6f8c7f14312bf3bbe898eec9241c503cfbcc92d7cbf68732775b36867", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=232,device_name=NVIDIA_H100_80GB_HBM3.json": "ccf4a3dd1c6354ffd4b3c4d30b33d7412677af7a851faf2e216fc61be21b6eb3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=2688,device_name=NVIDIA_B200.json": "b0fda1dc65b4fe6feaba18551749b13e7ce63e96658f18def48cc7e915a5bf04", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "bc7efd575e2ad3223f03fc7442899e976904e3cbbd206764a911392b693cbe0b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=352,device_name=NVIDIA_B200.json": "ffed937219bf96ea7012abc427d8baa0ac920653bfd6954e9f65be2e23bfbcb4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=352,device_name=NVIDIA_H100_80GB_HBM3.json": "23df74db06dc672a8c400b16b52a8f58002284ffed6d6b96a013d0e2089c78cd", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=464,device_name=NVIDIA_B200.json": "d2dc681e2eb9b7cd90de9452a13a46b0ead362e957837986dbdd83ca16f0d3de", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=464,device_name=NVIDIA_H100_80GB_HBM3.json": "1ab05dd5e86a8231f9aaea486aaabbb7c8cba1a75cebe65a7d40b66300684ffe", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=704,device_name=NVIDIA_B200.json": "7bac882743da5749cfb1c826897965f325f1b8a9a666a8b5b5a5e362aebcf552", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=704,device_name=NVIDIA_H100_80GB_HBM3.json": "e0f0cd1a8fdda9b6176b5a07aac0a7030d5992edbba43e111b0c4231bcd6d7a4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=928,device_name=NVIDIA_B200.json": "ddd675749dd4da25bdf7b776d7bd0a79ccc0a5fbe8f6c9754924456ed8ba8a2b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=928,device_name=NVIDIA_H100_80GB_HBM3.json": "952ee3f7049513b4053db9b4549d1e5d8bce3a50139d526bc63e27c7e42d7304", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=16,N=1856,device_name=NVIDIA_B200.json": "4e362b8e978e57401a3846b6a24fed65af3a3e5bc6ba4ec6d1cabb64a6028f69", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=16,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "dbc3beaa3f68bb26e6d568c8c0c40cf637b9f4066052dc9c23129b50f86e9128", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=16,N=2048,device_name=NVIDIA_B200.json": "529f2b3eea08222c5a79afec1b93caa3ed599292cdcf07ac3a864fa128234fd1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_B200,dtype=fp8_w8a8,per_channel_quant=True.json": "7d6f53d4b97bca14965a98778f99e3c553b5f188b63cda946dc63ea3c0746f0b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H20,dtype=fp8_w8a8,per_channel_quant=True.json": "da049f5fb6789cf130ef362e8e221caee4e090091603a8a064277f8c70e3c36c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,per_channel_quant=True.json": "a05f66743170059d7b2a78374bd7a30c416206fcdcf26ad64d12656bd082ffa3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "a997d5122122d8d286931d8c0ff1ec23c424ae6cd561b09fc60c5efd5d405b69", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H200.json": "e82d8f40230528c208e655ac861245cb1fc75829c79adff888e4a688f217378c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition,dtype=fp8_w8a8,per_channel_quant=True.json": "f6d9e73dfb6bd35dbaa4ace6030817a29848742245a38c788dcb2cc491f4fd90", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition.json": "29826c7e8507d4cec5c79bf818c146f4d84a2289854b9a439b067a2b6e319683", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=384,device_name=NVIDIA_B200,dtype=fp8_w8a8,per_channel_quant=True.json": "71e4389df4e54eb7e28d5318f7de6214a916bed38b316e48d4b5d2fed2b39169", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=384,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "75f32678bc5c80676a35c94acdf1895fa7d23cdd32ebe1713033d60e3e119e9b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "3e6ed775a6afd26bcd424c716eef360bf7df8663fb78377606652169497fe1b0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20,dtype=fp8_w8a8.json": "de039ac7bedca8bcb6af0b37434c7a3d6ae7ef574e3063befef30b53be1247ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20,dtype=fp8_w8a8_down.json": "de039ac7bedca8bcb6af0b37434c7a3d6ae7ef574e3063befef30b53be1247ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8.json": "2b46e9a118e2e2913c04370d0d2d5e5e583f943df98415eb131d64bc1c2bd45f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8_down.json": "2b46e9a118e2e2913c04370d0d2d5e5e583f943df98415eb131d64bc1c2bd45f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e.json": "6e1ddf115cce355e9e20a9f9ae8ec31f8730495ccbe464587464f8137590d37e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e_down.json": "6e1ddf115cce355e9e20a9f9ae8ec31f8730495ccbe464587464f8137590d37e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20.json": "aa020ec22d8750fd9460c2d772e6c026953c197aa8bffe5e75a7720a38680533", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20_down.json": "aa020ec22d8750fd9460c2d772e6c026953c197aa8bffe5e75a7720a38680533", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=20,N=1536,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "403477abd3f7102384febf551596d082185d717b88012a03c6daa8f72be179df", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=20,N=1536,device_name=NVIDIA_H200.json": "f43d515d1d7bf385c176900985b5179ea77cd644e0cb305396a581a2333f95c4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=1344,device_name=NVIDIA_B200.json": "a1ea86a173e803ecde95bf6a0582fda52cf6dcad7afca7dd17a1680ad15bd55d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "fc6d86a18730cde466839fca66b4f6235eef0b78197502b174a8d5e0caa4817a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a1fbe0eb240031ae9b933135053d210e03a38940e6e36d8bfa48d4c7c63660ad", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "211ebb031054e6b5612f2b9c58e97df23cad890e33441117aadd35dacd2421be", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "a1fbe0eb240031ae9b933135053d210e03a38940e6e36d8bfa48d4c7c63660ad", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "211ebb031054e6b5612f2b9c58e97df23cad890e33441117aadd35dacd2421be", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=2688,device_name=NVIDIA_B200.json": "cfab9577a4e218eb0a5213aaa24d47078b7cf64d44cccb1852408767b381c9d1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "057233d0d5f2a2cbfd3077292ddb65c19266bade5ad8e7b0beaa075afbaf0f40", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=384,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "215aeb8489333f5b7d1cc454217a55e9d6ea0ea25c6c6d11339639d29ab3b897", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "9ca68260b79e11471f9540baac49bf0899c078a2bf986dbc52fe386a431c4dc5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "791325ae16cb1e05de42308a5ba86148cca6d2a8abc23a03e013c3e90080098e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "53e8f44228725f4e53f1edf1ba60daf74d11a33adcfa8d0fe86ad0ef6c5a04c0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "791325ae16cb1e05de42308a5ba86148cca6d2a8abc23a03e013c3e90080098e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "53e8f44228725f4e53f1edf1ba60daf74d11a33adcfa8d0fe86ad0ef6c5a04c0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e.json": "780a5f0cc7bb8051dbc921e53cbe4b1db84be972b93c7760ef4e671386431451", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e_down.json": "65efd6589261943ef87a0b794d9daf2263fef611bb42937ae9a15acbb1577f1d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20.json": "780a5f0cc7bb8051dbc921e53cbe4b1db84be972b93c7760ef4e671386431451", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20_down.json": "65efd6589261943ef87a0b794d9daf2263fef611bb42937ae9a15acbb1577f1d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=672,device_name=NVIDIA_B200.json": "496faa17aadbf3c53d0f890cee9c8377f4a90646a3e5a8e7e0b27c5ecdb5a1bf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=672,device_name=NVIDIA_H100_80GB_HBM3.json": "4b8f9d863f0125d28f77502d51fe02881b7e485351a01fad3bd742dbee1fdfaa", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "19e6b3a96b5bbf1340cf05ae23ef384b8c6f5fe49457b4b7ff88115d2e42c831", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "4753bac1380c741d3c16956f90557f3529edc3b161a6f38c772dc223992daa6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "64adeda916e9750122b060e6669068c7a5a3ec8234bfe2499e49199a9b0a96a9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "464c6d9660521a06c6b4a90a8a30790ae109b99816875179953b915def013576", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "8c4f4083d952668a7ebdc284ab87b565e03700e63523a28a80b78940b688191e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "0a88a3611a9f18b95280fda9461e3a553c3b254c3db774fd7e337facd960b4ae", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "9a8a5a9c503f4ab7e4348e07a09483868740573668b42e0a17b01889ded4562d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "421c5282a574b7afb76f9dd6d55eb6ef9f302017ab4029a065b2943e79d1ef9c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "381e68ebed0c9bf130dd898750aeb8a40ef787d69aa5ad40ae15db37c89c3ae4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1792,device_name=NVIDIA_B200.json": "b046ed083381bacf17a9baf43ceb7171602f412d57c2ca7aa8204294af945199", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1792,device_name=NVIDIA_H100_80GB_HBM3.json": "80184412ca386f603dc6190cc66bf54cb1419e493eebb5044573c0ab66cb812c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1856,device_name=NVIDIA_B200.json": "d4ebcb1373a0020f6c8497e28e25db5ec66ee9fbb6cc94210217037a46762e1f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "e3a5191eec788aa853ea8716e3ab807324690ec80a1349a8bb14f15e5a400bc8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=224,device_name=NVIDIA_B200.json": "94083a6d2f7e7e95da305df0c0ed40ae532a702078bc8cc44f036d7b5193c4a3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=224,device_name=NVIDIA_H100_80GB_HBM3.json": "1aea06bae1b7b49f157e1b1e70a1abd43b3722fe57434d820583c8c5a131a2e5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=448,device_name=NVIDIA_B200.json": "7eea850ff3a2c35695b367f446a1cdfcb12a232216bd3a7ca6a361c63f927a95", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=448,device_name=NVIDIA_H100_80GB_HBM3.json": "c3abe23ca68c22649bca1a91f0e13d25d207359bb78439182db98ba034caf6d8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=896,device_name=NVIDIA_B200.json": "5f0f987dafd9459e72f8086c8ed60650143c3a75a37c05e8d502323664d4906e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=896,device_name=NVIDIA_H100_80GB_HBM3.json": "110d7f5b6310d37b8b8ceab952a76b286ebd735a6e572c6d43658b8ee3c19caa", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=928,device_name=NVIDIA_B200.json": "4c722ca4b35d04df58b5d07907fff8f2e361069cab61ce859767fadfe528bdb1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=928,device_name=NVIDIA_H100_80GB_HBM3.json": "370d52bc59d130081cec0a79ce8058639fbe0fca6caf5cd701df1d5ccfec5be2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "4166cc74a782dbd1074bcbf302838a5cc5254c1d291240c13a3764d09f8374ec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "c13ab178c2557ec886aaefd13b28a3bc7c5036d4fb065b69ef76e1786b2ae1b4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "4166cc74a782dbd1074bcbf302838a5cc5254c1d291240c13a3764d09f8374ec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "c13ab178c2557ec886aaefd13b28a3bc7c5036d4fb065b69ef76e1786b2ae1b4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=40,N=1536,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "bec7a6de5d1d3c266802102bd582f82c45a263342e0408e6d2cc8083de7addc2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=128,device_name=NVIDIA_B200.json": "9ca8dff039717269e7d81215e6e7305d35c93af84737895cd8b7993f679c38e0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "020b7a36328778ec8a245da1523e047c24d3f73b5a485282000166412cf0e745", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=128,device_name=NVIDIA_H200.json": "c8ef7ff493727b450bb8547648c60dd73c726aaa425b3825474fcb9b29abbbaf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=1344,device_name=NVIDIA_B200.json": "3cfb859c279cefafdaed984ae188eb558f43ad42a5fd2ad1ece4dc5ac66099a0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "de21a66a3636480cbb9add7c5bd9017797c2346bddab2b319a2acdd6753fb158", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=256,device_name=NVIDIA_B200.json": "6e70f307b4e1fa82c3cc573c1ad421c244d0578074139372705672e4309e66ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=256,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "d365e3fe134b5cf69ff234e6923d35e91201098e2ddc61a9ad0efbfcc8b50f2b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=256,device_name=NVIDIA_H200.json": "e7478e6689b965bc3fcd45e114881a6d88c9ef2c933b5501ec8eb6b82614e305", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=2688,device_name=NVIDIA_B200.json": "1b82e6baca090de90062682b4631b0e78633c31be690547bd43c925278920cae", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "0963e8cd396c736bc91c6bd29e3f7175d4812054377b17ea1b6f3c91d2538218", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=336,device_name=NVIDIA_B200.json": "90cc65e7f99a13029758d1678708bb235f6bb58f3dfd118b2191102b60d4084c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=336,device_name=NVIDIA_H100_80GB_HBM3.json": "ce9fbc962e0623c6e08c81a5b70e57b496a61b6bc953efadb235d53ce3064603", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=672,device_name=NVIDIA_B200.json": "a09f90d7e21dcaa0d87479c144565e12c39cc1ed2f339207320b75772b252185", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=672,device_name=NVIDIA_H100_80GB_HBM3.json": "1035ffd39b5c925146fba8c8c4300f6819f5cdc1ac3b939b74a148c3f7dcfc96", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1536,device_name=NVIDIA_B200.json": "a56b9885e11b11fe27eca5f7374b803416ab0ab7c45a5180e618574e68ca28be", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1536,device_name=NVIDIA_H100_80GB_HBM3.json": "3bfb9217dca5085b2478d6d163560c531206fed385639bf55f2f6652289c31cb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1856,device_name=NVIDIA_B200.json": "c03cd023342457d5e94de50bc854b5fa1cbb6645fae36901525520631be84bb7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "44cc31dc0e3dce2b1edeaae90b7346b7759c966600d38ca9184df658fc55ad64", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=192,device_name=NVIDIA_B200.json": "156c92cd714998c9efd2375cdb1665d644229387a4029d86e2783d42ff0e608c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=192,device_name=NVIDIA_H100_80GB_HBM3.json": "ff610d631377f1bfb5ac2ede4e38b8037ce9c5058076daa6acbfb14a057bfe0f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=2688,device_name=NVIDIA_B200.json": "93251d3ad9bda0cf1323c9081077cef8758d1eb443a5a8fba9c36a8387bd2992", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "5ad6440146e11c16f95a71c837c9277704a475f6c8185e2dd3a52eca4d93f977", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=384,device_name=NVIDIA_B200.json": "13163b688aa88ac589c53d74e39a1f2850ac4c9c1d25a7f557476b65b2d160a3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=384,device_name=NVIDIA_H100_80GB_HBM3.json": "21d1afde8079375ebf0f56327af3c494425f265ddbe7f89f8c47e739f2fab16e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=464,device_name=NVIDIA_B200.json": "0ccb8bc37bfc9d4788fdb68663f5d31ae133eacc14379a75878c9776ff7d3ce9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=464,device_name=NVIDIA_H100_80GB_HBM3.json": "4eed6ee67e88f74a1e35e7a0887f6fdef079d99d59779b2fd2d1de917e7e9918", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=768,device_name=NVIDIA_B200.json": "21ee026818f8e17533a823f1e0579c4abce9573a1ad1733318588a8edf2f7487", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=768,device_name=NVIDIA_H100_80GB_HBM3.json": "25843603641dd86f223e82b36fed94da68d7d2508a343f8d6467f28346bdcacc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=928,device_name=NVIDIA_B200.json": "0bf60f991a0c825878914f15be16be82539a61cbdd5c1be8f6dc57d31a8dd46a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=928,device_name=NVIDIA_H100_80GB_HBM3.json": "20feaa1dba0d5641c4fc23c861cc4b56e9287a9144e847e7934a690e3ba518fd", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=65,N=1536,device_name=NVIDIA_H100_80GB_HBM3.json": "5873ea5db4da7fa9109f33e00a436cf15c515f1c6c05a413362fd43024cd5d63", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=65,N=1536,device_name=NVIDIA_H100_80GB_HBM3_down.json": "5873ea5db4da7fa9109f33e00a436cf15c515f1c6c05a413362fd43024cd5d63", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=80,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "49a8912ee6f4d1ed31b74f6b8883feb7d78344f92cde98a6c37d61eba85dc3d3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=80,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "e3a3b851c9bb799fe6e02641cca8b43d9a462761e23afe0d42a144d4b263a07a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=384,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "ee12de31d61c4bd184789e235fa1778861f7428610c20c841abdf7a3361a3abc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=704,device_name=NVIDIA_H200.json": "b395443d24926c1f59d90ad0d3caa7989f9d16c5ffaedbaebab33db247d60e11", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=704,device_name=NVIDIA_H200_down.json": "b395443d24926c1f59d90ad0d3caa7989f9d16c5ffaedbaebab33db247d60e11", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=768,device_name=NVIDIA_GB10,dtype=fp8_w8a8.json": "b8e1c318bb84c878c3d8dbb9f726cfc13e3ce5abbe2c9776941d2e407de6e146", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=768,device_name=NVIDIA_H200.json": "26b68cf8dbdb83957f4c991297a50f15864dd731c7a086ebda901c92c7a7a136", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=129,N=384,device_name=NVIDIA_H200.json": "f9eb906bb7187c17d1f863e1cb10a499045957b31003eb92d74cfbeb72754451", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=16,N=1408,device_name=NVIDIA_H100_80GB_HBM3.json": "9a06fdb55915bfd138b536ce00ab32ea145ad02c9eda46f4377baaaf361d1831", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=256,N=512,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Server_Edition.json": "d12a7ad0d2bbe834d9a3e116232e565d84698356d758876a6b52f3d9f8f451dc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=256,N=512,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Server_Edition_down.json": "174955761db4a5b76646121ecd5ad3791bd13bf06644727d8c27b7577401dc56", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=1792,device_name=AMD_Instinct_MI325X.json": "9eeaee332cb79ee55b66897732933b6e6a9fa15933b69ebfbcb47432692392cf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=224,device_name=AMD_Instinct_MI325X.json": "202a5ef736257dbcab3f5cd64179ffb02428d09c90833731a6a5fc5a6f9346f4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=448,device_name=AMD_Instinct_MI325X.json": "3406b2127e82acfee4847af4451cb748e5c5e8592fc3cfaf16f8852027430533", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=768,device_name=NVIDIA_H100_80GB_HBM3.json": "e52f46c62bd30196e895f6a1fbe78b6c56ec03aa93f1adca1fbe66a736f66e28", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=896,device_name=AMD_Instinct_MI325X.json": "74baceb424aa18890bf1bfc4ba3643e2e31a4c27b2d4d7c0b72ddf4691a74df3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=512,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "162a768a5d0f37d9753d4f171f656c99af0cc6c16069b44b9c462bd930aa59a8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=512,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "dc118fb2c7742aaa0a08571a838bf552fd7fb2ceac8d382a3679afa535e257f8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=513,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f9e3579e163b27e886ecff73211044e3f56f6168019258f3c115efd519e5b0bf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=513,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "f09913c7aadf0aab089a2d4bc26dfaec9ec4bdbe2d497638914e700c858c51ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=1536,device_name=AMD_Instinct_MI325X.json": "7f7785d11e38b720edeeb2b33faf0594509974880f9afab91213dd2d3fd15d36", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=192,device_name=AMD_Instinct_MI325X.json": "458d6e7e4ed21f527345a0bd542d1c1506efb5f0e605a4f10439d27d487a4c59", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=384,device_name=AMD_Instinct_MI325X.json": "8a53e814d5c7bb9b8a5ad31bacd42d0379ea56258b588d8b1e01b49f22e00b71", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=768,device_name=AMD_Instinct_MI325X.json": "f7c00f1942e95888081de80941b6f11935eca620cf3177e9e43cb39d2860aa8a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=256,N=512,device_name=NVIDIA_H200.json": "29d2963611a6efd579bcad4096c5483509903fa1381ab1afe3fb9e8180a981c6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=256,N=512,device_name=NVIDIA_H200_down.json": "580ba806aee263268a95c250b7ffc47cf073cfa1f55c2f5b2434e0c42787b3a2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=512,N=160,device_name=NVIDIA_H200.json": "d2324a321541e510c2caf6ba09a190295bf8e5035031052f180300ef286a6b46", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=512,N=320,device_name=NVIDIA_H200.json": "6605724a9be662ffd476ec7c33614aac57e13d1c321166f7f11ed14518636d07", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=512,N=80,device_name=NVIDIA_H200.json": "4bfcd012ce58ded82f11cda93415597743bfe5b66ddd5d10cef34765125d32e2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/update_sconv_cache_sm_100.json": "9e93756af03b3ff1ba35b6fe64d09ee2b5f3cb9209ea0735593d152314b627c3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/update_sconv_cache_sm_90.json": "9eb4322b6584e78392e0108d2b1857978aa78d9f4e56159fa9ca7ef150182b9c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/update_sconv_cache_sm_95.json": "4fc9b82db8223ede1afbdcefdfd05e92ec8fe6de2afc66f101e81687eabf2896", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/fused_moe.py": "1858f4050d3465b3b1f7fce979713e6c8f56a14cf8298c99a105b5877dd6431e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/fused_moe_triton_config.py": "022c8aa47972dd975ebf7be9c6d04ac4c60604cf705cf80c9b38e45973193d09", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/moe_align_block_size.py": "3556aba5fc1142546f30d1f03034831e6893ee5ce05d868c29207485cb28df78", + "python/sglang/srt/layers/moe/route_quant_handoff.py": "9bb752e7763be1640ae03541c0ef064813786e6cfb98a712a42de12ce44d86aa", + "python/sglang/srt/layers/moe/token_dispatcher/__init__.py": "e79e4a67cffbd6af9d5fa53fd8055ef54c9d3dee54bd5e90aa0540f25cfaa161", + "python/sglang/srt/layers/moe/token_dispatcher/ascend_tp.py": "28e97cf60dc67a01444f97b66e9bcab6b99cbc35a29b3a3c9c93b601066bbd67", + "python/sglang/srt/layers/moe/token_dispatcher/base.py": "a77e88375ac36c3997a704fe909fc7c9b66e4f51605f6d86efec69f3c84b2fc3", + "python/sglang/srt/layers/moe/token_dispatcher/deepep.py": "201827c6ffb2289392b9e1b36908ca524009c864d07e19388603f435efd76d2d", + "python/sglang/srt/layers/moe/token_dispatcher/flashinfer.py": "e411261fa1fdd2a4129b2dcc709c2ce7836d7413c7350d65448e33b3b2e559cf", + "python/sglang/srt/layers/moe/token_dispatcher/flashinfer_utils.py": "d26bf7c4fc811d42e30373e4495cd3163540aa8071dadc3534b675e627793389", + "python/sglang/srt/layers/moe/token_dispatcher/mooncake.py": "a5c940dd61de9621b4a8fd027140e6852fbc2df2dd965852a51dc190d0055818", + "python/sglang/srt/layers/moe/token_dispatcher/moriep.py": "de295b0ee79257484d0e5e0a8e7632b996b801d2d5d31c2fe5b4b402db3fa571", + "python/sglang/srt/layers/moe/token_dispatcher/nixl.py": "c6208523e0a66977b77130b288db80b55d31f71ffc98fa4759886eebb2810113", + "python/sglang/srt/layers/moe/token_dispatcher/pplx.py": "052053b7ba7b3d0070585d7eb81bf20cb6ccb1480859fe00d65e779998207e16", + "python/sglang/srt/layers/moe/token_dispatcher/standard.py": "9de02768e3877163c0955edf49be7de72aa3870ac351ad1e586b1679b0e72ebb", + "python/sglang/srt/layers/moe/topk.py": "8cc479ccfc835899db587194a3b193806135666f4743722da81cf3eb9a413300", + "python/sglang/srt/layers/moe/utils.py": "4ff2fa9835b36b4614c224adf75bcfed1694c13f0954befd1c90bde2793cd931", + "python/sglang/srt/layers/moe/waterfill.py": "dc09471a2ec1fd7ca98e84b06972edad8106443ecd0699e00d1f51191b0e00c5", + "python/sglang/srt/layers/n_gram_embedding.py": "ec3736e033c17bd99d7f03b7dc10017eb629fdb3e720aa5df939890caefb6785", + "python/sglang/srt/layers/parameter.py": "fc780d233617c99f6cdbaf60708cb771e27adb2e051ec7e9934b5431a55104f4", + "python/sglang/srt/layers/pooler.py": "788da634ca0ede66fbd8496242749abf07bf496146c6d178bfbb985297bff8a0", + "python/sglang/srt/layers/quantization/__init__.py": "cb87075ccfa96a8153951af8abef029f6c2e38cf285bb3e5277ef245fe1782ae", + "python/sglang/srt/layers/quantization/auto_round.py": "79e0664c76d37a6d006e242db9c296a96a06adbca5d49b5764d9abd07d66feb3", + "python/sglang/srt/layers/quantization/awq/__init__.py": "5592695d532179e7a5f208e50b8db7a39d1c0ccaee0367b784de8ee7b0c9531a", + "python/sglang/srt/layers/quantization/awq/awq.py": "028b39a024d3f6ce1ff2050c405a37e961b6ad646c0a67c7ec838d551a3b9d93", + "python/sglang/srt/layers/quantization/awq/schemes/__init__.py": "1fe1a2332de5f2f7b889d3473e52d78cbd32888d93c6522544670c17c0b97e03", + "python/sglang/srt/layers/quantization/awq/schemes/awq_cpu.py": "a285cad90cfa5df3b6f48f162ca4c3426efe02125ee9218e934b40a280d8c00d", + "python/sglang/srt/layers/quantization/awq/schemes/awq_linear.py": "e9b8b3ad69a7fee1841178deee05e554f979160aa0172cd31e205a0241ff1b6c", + "python/sglang/srt/layers/quantization/awq/schemes/awq_marlin.py": "1ef9c44e1c4b9fbc4e8f370d30afcdc36525be7a0964a7e31dd3b454cfe4765f", + "python/sglang/srt/layers/quantization/awq/schemes/awq_moe.py": "b6635d40313094835fa29687e6069ee44cfe74139cbc377b496a89e4a393fe25", + "python/sglang/srt/layers/quantization/awq/schemes/awq_scheme.py": "f5c37bf94c578b3193986eb9c7e23706f7fc84363c0c7e5aa2a9e109212fdb42", + "python/sglang/srt/layers/quantization/base_config.py": "b4d42c8f20588578b9b77ac536bd3296db71addb2692be904d62e3171b478ce0", + "python/sglang/srt/layers/quantization/base_scheme.py": "8443e8f810e130b95de96a7bced3b0c4922af5210d495b2052b524c7e3c1d55d", + "python/sglang/srt/layers/quantization/bitsandbytes.py": "68dbffc49bea248296fc3066879f15cf4214eb3f1f4f1c17f0d8fc168c3be08c", + "python/sglang/srt/layers/quantization/blockwise_int8.py": "3515d6e4efee78da5a420cd5355cd8ae9a68d2f5dbc8fffb6af281e99d2f1817", + "python/sglang/srt/layers/quantization/compressed_tensors/README.md": "f3495660ccc4166716e64b89eb09b4e703395d4cc24d04d2439961ffb35cdeba", + "python/sglang/srt/layers/quantization/compressed_tensors/compressed_tensors.py": "cd39a1f943dbf0f1fc5e69a260457265cbf5a2aaafd90ea4babe7eb1cf617a0a", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/__init__.py": "1fcef63d3af982e6f4cedd461c4ac6d9e59b8390582460abb5fa2ced3f0e269d", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_scheme.py": "40dec04b729a39d3362390d90fac29ca52ab99a90019ac56fd80497188f70476", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a4_mxint4_moe.py": "12624a8cfd8d03fd04ab4a7ecae05039c86bd93ef27f9838430625dfa94a3063", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a4_nvfp4.py": "f5a6efd61a9bb8b6e6d791891eaae440d60b04417f04ae67ed015f35df61b646", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a4_nvfp4_moe.py": "83d3eaa9e7843f809e8193d981d9dc90f81bab97a36cd30a8969f51fe2783177", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a8_fp8_moe.py": "adafb1332d0317a062ce6ad798cfef138756ce2bfed23e92696acd93e021dd27", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a8_int8_moe.py": "91537ccb48e8a3734111a44b1144c12e25c2939557b8b9dfafa9419d0d5dbd97", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a16_fp8.py": "7714b0dd7621a2c8a542cdafadaf573ddf8fa60e4b2feb826ec831b0edbe565e", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_fp8.py": "c853c513b29883c16dde974fe6b2d6e8ed6c4ab442509fd8a8f0f27c6cc15a85", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_fp8_moe.py": "bd823c839720f334ef90d65448e3ca14b16a5e9a21669dbe17ea1e144a8ff6e5", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_int8.py": "32ef6b9196ca6dc04a82deabcb849a1d029f09fd3137ab32fbe6691f6e23b40e", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_int8_moe.py": "0765e6abd35b6587794cab960d35311ed5a8718c3faa856db186c200988e5eb9", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_wNa16.py": "a78990db02e703847316fa71f2b8891d034c6fbb6fcaafb104f5e1002a7f396c", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_wNa16_moe.py": "74f1c0a36bef17ec0065002fda0824de5b1152e956e6f60bbc95134edff6e0a5", + "python/sglang/srt/layers/quantization/compressed_tensors/utils.py": "6f43153656248fd7fa3782fbc30ab052aa13e368ecdbd6fb00fac6c5e122df6d", + "python/sglang/srt/layers/quantization/dequantization.py": "e1bc76891ebfb33fe12fde7e0913884025c26bc42d18e0aa0044b4246e3b9ffd", + "python/sglang/srt/layers/quantization/fp4_kv_cache_quant_method.py": "0eb5c710559f3bf5ba493d992043213dacb651398edddcbc3b71db8570dbc038", + "python/sglang/srt/layers/quantization/fp4_utils.py": "2ff0495eb47d8afb282406d7e5306c9c20b5edcb65316435c7f39c3fe064bb32", + "python/sglang/srt/layers/quantization/fp8.py": "be081d39b0ebd397fb89208acadba7103111e95e3925569f466240667ea6de7f", + "python/sglang/srt/layers/quantization/fp8_utils.py": "cb310162f67b6cd33da8547c84b48cf356ea999d04c9ed5434ab52eaa2358619", + "python/sglang/srt/layers/quantization/gguf.py": "9cca184242c56a05a15b336f12ef5547efd8c0c97c66cd1630b6f2f0cbf64598", + "python/sglang/srt/layers/quantization/gptq/__init__.py": "30b60b9992a44a9f1a062197640df17e602070ae7b1be56925dfa7fa1e8deff4", + "python/sglang/srt/layers/quantization/gptq/gptq.py": "38f1912027a9774e7bc55e0ec66fc260ad4d9e2653afb000612163bdc7eaaab6", + "python/sglang/srt/layers/quantization/gptq/schemes/__init__.py": "1bc2ea55491a7c61c8e4429007318dfe16b0c9fbfa6606010c02b2f2311dd64b", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_cpu.py": "58bd9993efadc3a8afafd60154ea64aff78eefb42fda16976679d86527b9cca2", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_linear.py": "c8a1197e80de020adac83206fd4d388d1af228cc9407b15bc56191e8fbd02da9", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_marlin.py": "0648295334c1df8e33c008801616a0127333a0a9cd282c1dfa1d95716ac7ba07", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_moe.py": "135e004f7613a59aa0765cbe3d779c9bb0c459f3a199b868358759e020aaeb5d", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_scheme.py": "72dd1818001dea7c4a02d45778aa1078499a587a448e9afab057159b2957c482", + "python/sglang/srt/layers/quantization/humming.py": "7095d6edc186e6c1a306171f3814202fd2863aafaa77797820dd3645d84bbfc7", + "python/sglang/srt/layers/quantization/humming_utils.py": "d87e5ae9e2f29eacf4ab7e5d33327fcadfe3c9922de9b00982a00188982a726d", + "python/sglang/srt/layers/quantization/int8_utils.py": "d8340e7412dfd35c4b75b72a472367c5dea1508ddfa126080061e374f76db70f", + "python/sglang/srt/layers/quantization/kv_cache.py": "4b5862ab5530b563678f49a332213ea2b83437088a797ec6b925a8bf9b3273f2", + "python/sglang/srt/layers/quantization/kvfp4_tensor.py": "19ca3c7d21df3bbcd7b6c56f3c829a37d29814a9f80fbbd73987d08fc1842c5f", + "python/sglang/srt/layers/quantization/marlin_utils.py": "1f0529ca2b24e2af804eaaf51fe72d76484cf5c7ff91a768612c5c9ddfba0bf3", + "python/sglang/srt/layers/quantization/marlin_utils_fp4.py": "09460a6468148e4fbb9fcf82e907b378c457d21e308cc0e9bb3d8807f1679839", + "python/sglang/srt/layers/quantization/marlin_utils_fp8.py": "a05db436551dc12843c65de63bf6a4c40a3fe1fdc461422472ba0d555beadb8f", + "python/sglang/srt/layers/quantization/mlx.py": "1ce4c98f6b93abc250d8c43f3aff659a6146a1ff1265fa73f5b50a19ed40e490", + "python/sglang/srt/layers/quantization/modelopt_quant.py": "b05ed81bef0443781c79c7a6daf05204b8d6c50903cd84dae87ef3303c93d311", + "python/sglang/srt/layers/quantization/modelslim/README.md": "280e04b9a9ae69653d62c19b401f41b239d473297651a3785804f34035a5e14b", + "python/sglang/srt/layers/quantization/modelslim/modelslim.py": "dfbadf0987f8ac866b2c393eb4454227a8fe960c500b1821ad26ecc602ac802b", + "python/sglang/srt/layers/quantization/modelslim/schemes/__init__.py": "65e55f50c5856e370756f68ce933615bed12e01bd65ab24df2ac201c6d71b19e", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp4.py": "13915c338ef514fbf65e167c67e236839ed9b22b575a19148afa51e7eae4bf56", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp4_w4a8.py": "39caaf6e606acedbdbb8753dd2b49ab553b9ae9009d48b0cafbb0b99a4d7238e", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp8.py": "8ead67d94feec4e7f52341ba43e89ddbd5c2917a61b45402a9f4bcd70ab52328", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp8_moe.py": "2111aa441fb8831d02a594172153b3dca66506914b5cee43e9e12352fd4be75c", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_scheme.py": "3c35094a703eb80d8ba4e44a436405850f0c876195fe19e53628ec9fa4ff2d12", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a4_int4.py": "964162624e548aa408e869b50609ba40453b4432153ff887f2c3fd4609460eef", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a4_int4_moe.py": "ccda8039be906206ac224be6854e038b9ea2bbe6f9039facb9cdae0a8c6e80ec", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a8_int8_moe.py": "cea0df9233d6456f892edfaf25bc3b298c2623c85c4aa2d91a59ccbb63a03df4", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a8_mxfp4_moe.py": "f47ccc6324eb90742c3771874b653d41981e1f2a6f4ad5cd147c0d06dbca5f53", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w8a8_int8.py": "c31dd5ff7c011d3a2cfb0edde466243ca8c5646f91f3916eb4a40c9ab7b8aaac", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w8a8_int8_moe.py": "257a44e9071827dd4b6e094b9cfe809bb332fc3a23044b6809c863cf09e30ef8", + "python/sglang/srt/layers/quantization/moe_wna16.py": "1ba087ae1d074d07a918dcbeaf84b2318d830f1c9b61a2a488fe2aa725bbf6d9", + "python/sglang/srt/layers/quantization/mxfp4.py": "822a8dbec3f93c69b3bb6e391f4bbc4f69482842fec2d6a97224752f446dcb43", + "python/sglang/srt/layers/quantization/mxfp4_flashinfer_cutlass_moe.py": "4c17a8ff539b18f5001b71ccbd8fc5486e1f4f0432f422c845d94f91d8d6ee18", + "python/sglang/srt/layers/quantization/mxfp4_flashinfer_trtllm_moe.py": "470a7fa83038e7084738a3eaa46adda01ff073b58fa16bc5c80e710935874ffa", + "python/sglang/srt/layers/quantization/mxfp4_humming_moe.py": "d91fd78e65b95e2dcef12e430144f8a28bd82d7a51530979049a923a4636ec0e", + "python/sglang/srt/layers/quantization/mxfp4_marlin_moe.py": "11c3247b6faf8f1659a4b9e9415e370aef3acd70e18fb77261a575f90633b546", + "python/sglang/srt/layers/quantization/mxfp4_tensor.py": "6c67825e520e8661591465a9fe521390844312019468ba5ac03bcccb57133a60", + "python/sglang/srt/layers/quantization/mxfp8_block_convert.py": "39205c32389e71ae684ef7fc44af364c73c0b664e955225f6e75055a3b29634f", + "python/sglang/srt/layers/quantization/npu_mxfp4.py": "dea73ffa5ff92b1006e54fa2e2c8a6b5124d63ecb7ab089c5c2050112d2779d9", + "python/sglang/srt/layers/quantization/npu_mxfp4_w4a4.py": "eec4fa7db564e0f084c85b740047bef1e5baaf63624a9b933ff969070b2aab22", + "python/sglang/srt/layers/quantization/nvfp4_online.py": "3e44022a73e05a2ade22a98b3f04b0bc9b23d9a376d82ede6e506385f1a4e12a", + "python/sglang/srt/layers/quantization/online_quantization.py": "410088a35d9364617f522ba8eaef5a6bd9a63446883ed6a70882715492e21e48", + "python/sglang/srt/layers/quantization/petit.py": "253972ff143348f81f4c045663755db93a392fca5ed615a2631f10d719bea795", + "python/sglang/srt/layers/quantization/petit_utils.py": "fa0cb8ccc86a368200d51d27efee42d1e7d5e788c7a2709480f0d45058c6b323", + "python/sglang/srt/layers/quantization/private_draft_head.py": "08e8232ca0a9bc93999bbd3f35f91e075a3bcf9da4e02889666060b5212ab2d1", + "python/sglang/srt/layers/quantization/quark/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/quantization/quark/quark.py": "e445e6b87594ae3243c66c32147bcf966726430812e4ec77439f9a5168a2d6fd", + "python/sglang/srt/layers/quantization/quark/schemes/__init__.py": "8593d4ee997ffc3cf14ba6768f093011046e70ceb2144c627e013eac23c8d35c", + "python/sglang/srt/layers/quantization/quark/schemes/quark_scheme.py": "4655c2f81fb7169c07393f11bd080717ab1a34fe9da32e1d0392acc706a9e77e", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w4a4_mxfp4.py": "8f27127604b8dd68bd6734b2cace74544e14a2ad87d8ca51a712ebd49bb219e7", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w4a4_mxfp4_moe.py": "23231b1e107c36536daa6fb3b946502cd9ac3d61cc6ac36d17d170840f054158", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w4a8_mxfp4_moe.py": "e8d7bccd09308cec3bc4ae1b0a3fea3d05b4ff09424fffe5e534b6a5a4151c79", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w8a8_fp8.py": "0354e9556833d264ad1ce5fe7952dc51c36b6b87b3566ac07e73b3dec39159c9", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w8a8_fp8_moe.py": "69f015cdb3501dbd0e96005a9b73aebf53ee8d2299eb9359533c3305c548f635", + "python/sglang/srt/layers/quantization/quark/utils.py": "38fd28f40a45c1cf982c8af772fccda30619720fbf9bb3614bc9d88fc2263a7f", + "python/sglang/srt/layers/quantization/quark/weights.py": "539cfe2dc4ead86a20f04ff4506214dd3987f000511a90633908e76e496e53e9", + "python/sglang/srt/layers/quantization/quark_int4fp8_moe.py": "12957b021fd9648b1102eac5aabb63cee34d23c16c8ed84fb979ad4918c7d5bf", + "python/sglang/srt/layers/quantization/rocm_mxfp4_utils.py": "678a585a5e84c4e5eadaa7d31e8ad6d7a8556c9f919381bc5abc67ff1f1ba071", + "python/sglang/srt/layers/quantization/unquant.py": "9103cc6d4e03e19134aa1ccc92a9692f825ea6833ed701e4a12175a328ee1cac", + "python/sglang/srt/layers/quantization/utils.py": "290d4567ca2a8207bb1a4edfe6bf4c5db1f2d3b1972dade03cbcd69959a7b31a", + "python/sglang/srt/layers/quantization/vision_mxfp8.py": "abd9b92edc32c923581723f3fda0348d04f478edd7169fcb2732645917b021eb", + "python/sglang/srt/layers/quantization/w4afp8.py": "d43150f16f07329efbeda64c704bbb731e6904e9dda559e865f5c44e757f191a", + "python/sglang/srt/layers/quantization/w8a8_fp8.py": "010290429b6d79e60a01fe6af62ce80a69fa6d5dc1c38165e448c04198b246c3", + "python/sglang/srt/layers/quantization/w8a8_int8.py": "f266f3cc9bd118cbd138336965afee76382c4e8728452ad226e96e41d6ab9d25", + "python/sglang/srt/layers/radix_attention.py": "9e51244758e1c0923fc03b08045039900fc8ca3138485a6d6c47926f0cd423d1", + "python/sglang/srt/layers/radix_linear_attention.py": "4af975b5e0ea2b17505920a43509372200fffc62eebed2e4b04346175710a179", + "python/sglang/srt/layers/rocm_linear_utils.py": "87ca6a653584c01bc264be38697ad93af3a52fdde023be1edb2c59043c8c04b0", + "python/sglang/srt/layers/rotary_embedding/__init__.py": "7329f3e0422fdae69421c4335cd49e9ccaa89b861d7f89123cd1f207aa511ed6", + "python/sglang/srt/layers/rotary_embedding/base.py": "dc4d4ddf9a0d2b90f2108e0b5888f27822a5c6adcd83d966d9f10f6581504028", + "python/sglang/srt/layers/rotary_embedding/factory.py": "33fcd7e8c52f626e800e8be8231166221a526a49ad99c2be73b2b1829993cd99", + "python/sglang/srt/layers/rotary_embedding/mrope.py": "6f952b96801f9cab29c170670a308d97eca832d39b69374f866e50318c904146", + "python/sglang/srt/layers/rotary_embedding/mrope_rope_index.py": "625502f5e3fe75baab237627242d3a112b23d6f0140b22fff25b34391bdbef10", + "python/sglang/srt/layers/rotary_embedding/rope_variant.py": "5711a778a965c7a84fcf6b2552c1c7a2efd6eb820ea3f48fd4597d01dd86f9ff", + "python/sglang/srt/layers/rotary_embedding/utils.py": "828a50285218e40c3429d2f4e75b1d051e3a89d831a7ab005e8c2609278aeddc", + "python/sglang/srt/layers/rotary_embedding/yarn.py": "105a507bd92816cf785e807c8582086d2c9201781d1b0329083695ccc9d09058", + "python/sglang/srt/layers/sampler.py": "d96221b3873f1ad9d83fa8d4457af70f3aacb2513112ed405172bf5aceccb064", + "python/sglang/srt/layers/sparse_pooler.py": "f6007c76e478f11f851ad03843b0f57c80d2bdb2a50fbd0ddfc4b72ef83bef7b", + "python/sglang/srt/layers/utils/__init__.py": "992a4f05906e3f06ea1c942941ea0f05c2de68f89c8b6ccc1e4bcefdfe0e8ea1", + "python/sglang/srt/layers/utils/common.py": "5d3b3d71926e31aa0495ca7453efaeefd4e59802619826b91276761074764f0b", + "python/sglang/srt/layers/utils/cp_utils.py": "ea620e6240bc17517517005c774685a2fbf9507138b93805058cbf532435b286", + "python/sglang/srt/layers/utils/multi_platform.py": "3ad3db2c47c7db560fa76ee642f6bf1fcb10086fe14f5ff8840b90ba692cc309", + "python/sglang/srt/layers/vocab_parallel_embedding.py": "c837114a550d4d5b337e3e14847eb0b72896c45a124b57f2364272e8cb4a0113", + "python/sglang/srt/layers/zero_copy_context.py": "85bcaba1ac6911cacf83051f5214f3e4dd1edb9d3c1f6809aa8f1e3ab3072468", + "python/sglang/srt/lora/backend/ascend_backend.py": "f09a695ec58dbd46d81b9224ff35769483d1df9c535dc40f694a969425002326", + "python/sglang/srt/lora/backend/base_backend.py": "ac0a8622709f58962ccc4c39aadc23008664ce7a9ff48176877405ebbd1c8327", + "python/sglang/srt/lora/backend/chunked_backend.py": "e78d5eebc9d8369627242986f10de4ae7e948f54f3f2ba323138f73ede198bef", + "python/sglang/srt/lora/backend/lmhead_mixing.py": "88fe73ff06b6e2736dd3eea92639f9af0614b6ccb3ad83f2a34c2f17ffc3d654", + "python/sglang/srt/lora/backend/lora_registry.py": "77111565e70ddb33ecb656bf3f787809d0a8a37d328f2f2ea49294d87a5b73cb", + "python/sglang/srt/lora/backend/torch_backend.py": "2f2be4da44af150a66e9164485e83f0b0b819ff5160729c03a4c04a409d89c7e", + "python/sglang/srt/lora/backend/triton_backend.py": "fcd1768977d780c7f0187234f514b5bc41a675aeb753876bc2c9709672eb150d", + "python/sglang/srt/lora/deepseek_mla_correction.py": "34e2a7579cecae5aa06c2f734ffaa6052e397d1b6f80a27aafd506ae90731390", + "python/sglang/srt/lora/eviction_policy.py": "ee3ab6705034aef0448c5612456685f3b039efbd07d307313fe78539d3f2d520", + "python/sglang/srt/lora/layers.py": "a1b456750dad3ffd06df417f949f14b196c6813a3991943073abe8ad307c6181", + "python/sglang/srt/lora/lora.py": "368221bec72a8c75e900e46b76fd80c6c15a1adf929b9e069684c159c89bacee", + "python/sglang/srt/lora/lora_config.py": "abd3e2644c0ba0739ac1ac5cd15b43764c1fd0a2106fe610e0c6c841059505c1", + "python/sglang/srt/lora/lora_drainer.py": "561d0531a91b9ede808ebb21fcd037248504d5398ce79b8767ba954cb024ef95", + "python/sglang/srt/lora/lora_manager.py": "bcac6adb2797a211e648f8bfa98e84d45b482da7178a4b72130e02eabcde668b", + "python/sglang/srt/lora/lora_moe_runner_marlin.py": "f901cdcb79a9d4fcfdeccc8ed38ea82b88fd3eb9459514c4fa89f4cf9c01e1c0", + "python/sglang/srt/lora/lora_moe_runners.py": "6fb25d71031e67e6f13f67a078c7994c4f72322c01964dfed01cd4ebe7f2aab2", + "python/sglang/srt/lora/lora_overlap_loader.py": "d567ebd9865f224a97eaaa70c4bb12f27017552a4d2fcced7d64e72c7966d12c", + "python/sglang/srt/lora/lora_registry.py": "14474232285bdf7b979a05f93a10dc3bc4d4fa76c4e76dd6ead76fb0f91be79a", + "python/sglang/srt/lora/marlin_lora_temp/__init__.py": "fa121557e964bf92c935e13df5e7cdcb6346b3c90410d217827a84d97d54d08d", + "python/sglang/srt/lora/marlin_lora_temp/activation.py": "86f69dcc43a73c61c686e5fc3639407f0f0ba51bbcb6c3dc02cd7680d04b838e", + "python/sglang/srt/lora/marlin_lora_temp/direct_decode.py": "30424b11fe03c66ae48fc41069aad58dc7910b6fd5009e125532d006f7b0539b", + "python/sglang/srt/lora/marlin_lora_temp/lora_layer.py": "6ec8f8152e9888ab02a2dfc98e3b951f1e54e1130a762d481a340f541d9ff9d7", + "python/sglang/srt/lora/marlin_lora_temp/moe_runner.py": "2477906ab0b07cea59b403e28353ed68fe7b02b93c20b3b1ddb546902faa9741", + "python/sglang/srt/lora/marlin_lora_temp/policy.py": "b3bfd0850023c3e7a41bba40ff665c0957ded62b539f59116101b7cc36eb35e2", + "python/sglang/srt/lora/marlin_lora_temp/sgl_backend.py": "cab7e5c17f46e227ebea5f3ff54e25a2ba639ff423cb7f937fc97e276eefc854", + "python/sglang/srt/lora/marlin_lora_temp/shared_outer.py": "93ac7082a4a3786460310ba4c8d580ae127a1a7b3e7d75c133f0fcad9f304cdf", + "python/sglang/srt/lora/mem_pool.py": "f955cdf2cb9fd8dc5c1f29f254bc69caf3517c0118c0935429379f04e7b9c733", + "python/sglang/srt/lora/torch_ops/__init__.py": "a54d8b9f1b57cf752893530d858cf5c0b36936b4e55aa3a7aa8bc97866889c48", + "python/sglang/srt/lora/torch_ops/graph_lora_ops.py": "390676cc38975095ba124d1932aa8c27dc2b4605e18c495c095ae852f4c96790", + "python/sglang/srt/lora/torch_ops/lora_ops.py": "fc6b43a3b721194441c6ad80561596a064a4c5863de5b62fc3e2fade48f866f1", + "python/sglang/srt/lora/trtllm_lora_temp/__init__.py": "cc7bbe1717c92d5b0c944b94e871bdd3348f6deb086b8116dcabc179279c7744", + "python/sglang/srt/lora/trtllm_lora_temp/attention.py": "e180238bc5512e41496a808fe7d9783231b4c1fffc9b556906b1c74821e16825", + "python/sglang/srt/lora/trtllm_lora_temp/deepseek_mla_correction.py": "020cbeb935ee95598a8953ef082f1e92f8fb506bb665f3559591311f812335df", + "python/sglang/srt/lora/trtllm_lora_temp/environ.py": "391391cb385d9472fd44314cbe09fd2e73eeab65dfb3b2bc8caf0fde8e71434b", + "python/sglang/srt/lora/trtllm_lora_temp/experimental_sgl_trtllm_moe.py": "57238892cd2a481bfa8f3cb74eb73d15bfdde0fc2ab80ed782ca6e0724979dc8", + "python/sglang/srt/lora/trtllm_lora_temp/inkling_dense.py": "d9b3b95ff24faa097ae5e108cd72388e291e989211f0c518ee3079631b09c28f", + "python/sglang/srt/lora/trtllm_lora_temp/lora_dispatch.py": "8a4b258d43eda0e978a018e1ae2f297d4702b4038749ac6486d167f1ee4a7636", + "python/sglang/srt/lora/trtllm_lora_temp/lora_layer.py": "ec8b9bb0f1d611051271c61080af3b1a6ffd4724f946c152537399c4eb1752b1", + "python/sglang/srt/lora/trtllm_lora_temp/merged_column.py": "e52017ebfba01df0fe37b01b1770438bb23548e450d663208673b01ae19971cb", + "python/sglang/srt/lora/trtllm_lora_temp/moe_overlap.py": "ecc556bd4aa274e2db97002e022c935c991f139892b9cebd377e9f11e171474d", + "python/sglang/srt/lora/trtllm_lora_temp/sgl_backend.py": "bf90ef8d9ce1a7382d2caf76d494b3810637800128e30ed7dbec0125957af20c", + "python/sglang/srt/lora/trtllm_lora_temp/sgl_fp8_moe.py": "fe39d65f7e4d56806762e9518d598e9095f3657249718349b8c058df6dc60948", + "python/sglang/srt/lora/trtllm_lora_temp/shared_add_overlap.py": "c2df0c884816c05a996487742005073d7e30dbca4689bbbf1adf0ed60b4cc7ac", + "python/sglang/srt/lora/trtllm_lora_temp/specialized_expand.py": "6246ad33cbd08b529b6299c05cac20b1e3939daa0d085228661296048b9e7cf6", + "python/sglang/srt/lora/utils.py": "6c2b94b92a45ebefcd2e3e4b5c8f9d2a7d5496ef8b98832a2d10667f61c505b1", + "python/sglang/srt/managers/async_dynamic_batch_tokenizer.py": "a52ed01045e146dbddcd915f3ea1c0d15775207bebf26777df84bbaabb709ff6", + "python/sglang/srt/managers/cache_controller.py": "3f323c0b08acb8b1de6f3ff8c08f1ed34d508afd186ae61d370f4e1087d89974", + "python/sglang/srt/managers/communicator.py": "8228691d693cc2877b23fc777866a6779c1ed8511dff0c64ad002d2c602e0552", + "python/sglang/srt/managers/configure_logging.py": "acfd1542b779fcfdc207ea5f94037f9275e5ecfcd7ca77e17b7a63d9d4dbbdfa", + "python/sglang/srt/managers/data_parallel_controller.py": "ba6bbee2be27a5cec6d1625a4ae8d131dc5bb19dd6c32d985e378116d085173e", + "python/sglang/srt/managers/detokenizer_manager.py": "d90f88443bbde167c516dd4b55cd978bb75dfda1766d7e83c4f16a3094d9954d", + "python/sglang/srt/managers/disagg_service.py": "b1b2a8cd4d9bd1c891fbc403c499859277d85f641508a6f75919d8997e88b67d", + "python/sglang/srt/managers/embed_types.py": "a82f4dec31163faf0982b1346290698b1a19aa648f7b6381d3b129d73046de75", + "python/sglang/srt/managers/hisparse_coordinator.py": "f40ff83c78647cee92d674df808681dd805e29aca0711e2a944231d10cddc8c8", + "python/sglang/srt/managers/io_struct.py": "cc022f58fe2468fb6231c1e65a41106cbc0d73fe1bd784d6f57df94a412564a9", + "python/sglang/srt/managers/load_snapshot.py": "cf691698fef36941b65ca73f79684e95466fb8da528115b381d0f310d3673c98", + "python/sglang/srt/managers/min_free_slots_delayer.py": "bb864fc17446d3ccedc208250ac0171a235a39870bc151139c411049772fbeef", + "python/sglang/srt/managers/mm_schedule.py": "0c25cae8193e85088be5e1c012268689d868d87a49c5d81fee624c5e8f7dcfe7", + "python/sglang/srt/managers/mm_utils.py": "a51e0de5ec1abe5b2d094b43df8e2cf962372d50ffeb775d915b3c385b45a871", + "python/sglang/srt/managers/multi_tokenizer_mixin.py": "d5ae16421e4be95b51ad7bda44604ad4759e1bd7fda716d52a5102f29c356e58", + "python/sglang/srt/managers/multimodal_processor.py": "d295ce69c2fa2c5eb6940a28609ed913fef980f64de6af30635292c250875f0f", + "python/sglang/srt/managers/overlap_utils.py": "7762a4e463a8052fdac22e76ba904cedb35fb2deabda687849724a354bc891aa", + "python/sglang/srt/managers/prefill_delayer.py": "ca1bb87ae714a3329776965e7a47b53f2bfe1d411beac627e2af50721c823d04", + "python/sglang/srt/managers/rust_server.py": "ee6ce020ce33911c5445e21c8daf074e864d2a04530ca3d037bcabd5da9b13f8", + "python/sglang/srt/managers/schedule_batch.py": "4965156c669a536b40250605794de9d9aa7582fde71d188ab2ecf22e766e755a", + "python/sglang/srt/managers/schedule_policy.py": "7fa154986e574cabdbc341875401a59a7a388f94c548f11bf3d2bd7badc131d4", + "python/sglang/srt/managers/scheduler.py": "8bc11f8bd2ddef96bf32adc1fe5b52c3929e23538cde1047914eb336f3994595", + "python/sglang/srt/managers/scheduler_components/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/managers/scheduler_components/batch_result_processor.py": "22bd0ccfb1acfa4374a977ac0f104cee55652e6c5449d7c272d6775718828f7c", + "python/sglang/srt/managers/scheduler_components/dp_attn.py": "30c6112257c01bb4499cb3112789ada3cb9256e99c14881016be024d8876fc9e", + "python/sglang/srt/managers/scheduler_components/flush_wrapper.py": "5adbcdccd5fd6de5760735126fb83f9f578ea6d2d77c14dad374213ae0f2a925", + "python/sglang/srt/managers/scheduler_components/idle_sleeper.py": "031821b3f74435835dd9d40007eff027eff912375eeefbc7724210150f505082", + "python/sglang/srt/managers/scheduler_components/invariant_checker.py": "2d3ad1f4bb760747f4a09a674015c7f8fbad4623150add58612660034e545d66", + "python/sglang/srt/managers/scheduler_components/ipc_channels.py": "ec73fc4546bb75991daf1abf5be1b4f0fc23770eebcdb704ea0973e51285699e", + "python/sglang/srt/managers/scheduler_components/kv_events_publisher.py": "600d51ae91978322fbc8d3cf8b8f136b7f6f9eb803819e90149ad69698dbcae7", + "python/sglang/srt/managers/scheduler_components/load_inquirer.py": "2d27be46e1cf70ed4164dd28ccc0b3a2be8967780a12a4e83b36f0a288ab2c1c", + "python/sglang/srt/managers/scheduler_components/logprob_result_processor.py": "e155923884c924cc6cc98fe9ee7800f093f0d8b755be27599902992cdab1725f", + "python/sglang/srt/managers/scheduler_components/memory_usage.py": "82844af91ffed25cf1468ce3ee9afa4bf7d170432d6e7a3242971bb886848e40", + "python/sglang/srt/managers/scheduler_components/metrics_reporter.py": "88ca2f1f7ed43b9f226393643a66c39e6146eea8ef5052ca617fde32cfd465a3", + "python/sglang/srt/managers/scheduler_components/new_token_ratio_tracker.py": "865da371d324f57117f0aaa45cb53f15ffa22a32a458c3ff1eeacdd95c3f16cd", + "python/sglang/srt/managers/scheduler_components/output_sender.py": "e1c4e17a45a69157a73396f2d46099cef2a48ec8a2c86ee652f460e58eef8611", + "python/sglang/srt/managers/scheduler_components/output_streamer.py": "4f069fbba82a77360fec29330edf5f6cf3740960984c5e1d01ef4e385c90ecaa", + "python/sglang/srt/managers/scheduler_components/pool_stats_observer.py": "a9cd71a9cd38c4178657c5ddd433cde55f4abde918bb512f2b61441f9b88089f", + "python/sglang/srt/managers/scheduler_components/profiler_manager.py": "b1fdbdf4f00caa3d2ec810f0e4245ef44dc1327ad3f9833a1aa2ad726a4443fa", + "python/sglang/srt/managers/scheduler_components/recv_skipper.py": "3468d334af6a624769a8888d36b2b477270d5faae9d8b3a28af38e4cf31bfef2", + "python/sglang/srt/managers/scheduler_components/request_receiver.py": "899ac13dc79cf41a7582357298a40a03fa4f7d931955ddbc89705301916b4d5e", + "python/sglang/srt/managers/scheduler_components/weight_updater.py": "70944138cb88d88feddf9f2474684bc8cf7739484efef367336efc0e2ed9411e", + "python/sglang/srt/managers/scheduler_input_blocker.py": "edfe07948d75b3871bae173997914397878aca66aba0b42ffb8e26eb7e97102d", + "python/sglang/srt/managers/scheduler_pp_mixin.py": "89027f3bf1e37a485b8f2c9a96b62b1ed87879efaced1e41071179ba76b025a5", + "python/sglang/srt/managers/tokenizer_control_mixin.py": "e7f1ccacd6c243e1b5630f8f04b2fa444a6cc5635a7e8c2036ab0663ecb23091", + "python/sglang/srt/managers/tokenizer_manager.py": "591d5bf0ae4ab5009b8dfa37bd4d496f62b40cf13ee19bf7c867804b8a263bc8", + "python/sglang/srt/managers/tokenizer_manager_score_mixin.py": "1afd43f14f2521bc03c7d7e5f6fb839c32a250314922245d2eb8100a11022419", + "python/sglang/srt/managers/tp_worker.py": "c39b0b3363a57612caf73c600c07f9e67e56ae3ad939048eba7e856002047e59", + "python/sglang/srt/managers/utils.py": "23967b5942bc893d843f39028bb6d091c678125bc4378fa09499804b26f3c7ea", + "python/sglang/srt/mem_cache/allocation.py": "5012c58e1ca32dd28c97917195c87d80927eed55d60eeccc67f436f822b42c24", + "python/sglang/srt/mem_cache/allocation_sizing.py": "093f09c8ae88dc4008589195b97ca6a200e22b470839447800adde6ec8ff5400", + "python/sglang/srt/mem_cache/allocator/__init__.py": "c89351f05411121d0aadcb565ee848d78dd91726a61533f58b43cb7eeae2bddb", + "python/sglang/srt/mem_cache/allocator/base.py": "8159576fea298f977deb1535da9f42b4386e9ece2d663a2258aa97210d5f79ce", + "python/sglang/srt/mem_cache/allocator/hisparse.py": "ec75a199e4da40fc03bfb59f28bc0a1c5bd41b036e2e1cb54b81b1a0f9944fc0", + "python/sglang/srt/mem_cache/allocator/mamba.py": "b3d4561b7f96aa55f615c491b3d5a8c8e72e156fd7e6cf639ee7f87cfd80674c", + "python/sglang/srt/mem_cache/allocator/paged.py": "e58478ecb416a3a3bad1faa07863fe084f17bd3b1feb0f59a26b72b500a5a429", + "python/sglang/srt/mem_cache/allocator/swa.py": "1791c173ec8bf42b7a2ba9d5cdd1dbdbfd0c01b7de98e3206af9a178a3cf928d", + "python/sglang/srt/mem_cache/allocator/token.py": "07372fc82e58c58ff9fa749aa6573b0b1c9d7eb59d5e8c779c3b198a4da4370e", + "python/sglang/srt/mem_cache/base_prefix_cache.py": "d61f7ec0793661731f6150cdbbbb861428740e5697675beb7bcc67766df68791", + "python/sglang/srt/mem_cache/base_swa_memory_pool.py": "d37f2318c1d1fff9a0d6b7c17439ffd7733fb5a697c93dbc2fa31ec40803e280", + "python/sglang/srt/mem_cache/cache_init_params.py": "68ee503d8d1a908c338e0bb7f0bbdf67fd239ccf7be9fcfb6c94fdcf1278fbc2", + "python/sglang/srt/mem_cache/chunk_cache.py": "4819830a78b66d94427e235d20883561cb2a965764407184452eeef56f38b549", + "python/sglang/srt/mem_cache/common.py": "8e822206137dd6bfdf1c67ef02b93505c5a024778aa284e9a1709721c958e276", + "python/sglang/srt/mem_cache/cpp_radix_tree/.clang-format": "dc2a6c4be9a0951daedae7d3ba0955f2062b4f05ae165d812d1e8d3706ef6c15", + "python/sglang/srt/mem_cache/cpp_radix_tree/common.h": "cf196b6f42e2930229fb757f0cfe9a22680424b878bfdbb06857a76e0adec4d4", + "python/sglang/srt/mem_cache/cpp_radix_tree/radix_tree.py": "b50669cfe1fa1f134041ef6662ab7a697f267c3672bbf7db25370234af8db353", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2.cpp": "4606cc83205e6fa0a00f53b4c241caade013d993144da5b263ae2ad050819704", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2.h": "443969b06253f7fa1e33d70b51ff4595a1f81f7d1a510726bf2e051c1edade02", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_binding.cpp": "b3c07ed96bbde446ee58c4688bb1c19053f9855e1ae0e15d2ccfe1088ac74204", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_debug.cpp": "922cd38f2a90d697f9cdba70a90fe7fc9dc300cc7ee52b14eb3cee8cb6024c95", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_impl.h": "9dd2617f47568d4f57d96faeb8eb5031c9a148e5720c648cfe21350330a5dec2", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_node.h": "eed6c36b2201eaa0e89339161a9227446e51911bf2328a067ac629d7ef3a8ffc", + "python/sglang/srt/mem_cache/cpp_utils/hash_binding.cpp": "f4ab69e2e99b2b11dd19588bed5011ce737bf9fdf639669925d4119e0aa24b2a", + "python/sglang/srt/mem_cache/cpp_utils/native_hash.py": "8ae66bf8147fd0daa518a1519028a5ce3504cdf5616341cb348a71b873251924", + "python/sglang/srt/mem_cache/deepseek_v4_compress_state.py": "9f993de84546782d529403974665e3882defed42bb0b0459f833403cbe816ce3", + "python/sglang/srt/mem_cache/deepseek_v4_memory_pool.py": "bf3a94483cf099111460611cdb83addbe740b970613177df4c803a50b3468451", + "python/sglang/srt/mem_cache/dsa_cache_layer_split.py": "432d2fd880163b5c8633dd4e5f6527c658b045890c9a6e90d40909bfc153102e", + "python/sglang/srt/mem_cache/embedding_cache_controller.py": "0fe05d298032b7dd375e95a3daf0241a4333739c72002f4de680a30d0ae78b9d", + "python/sglang/srt/mem_cache/embedding_store.py": "bc359008e336099772b44961e0dd34b5a3169d5c0467679aa09112c53bd3eb8c", + "python/sglang/srt/mem_cache/events.py": "02a73642033edf74ae881c32139d8afe7c38b650424661ed8868c0c8f6c42fcb", + "python/sglang/srt/mem_cache/evict_policy.py": "8e839aa19244b870db52577ed06c7e1b4c02302813d33cca1f2d49ff190b929f", + "python/sglang/srt/mem_cache/flush_cache.py": "19873198d5e1e21b0ca457cd3ae093a4a8a55bb82e6704ed020feeb1578cdc9d", + "python/sglang/srt/mem_cache/hicache_storage.py": "de92d6c7228f3c93d889e1c054f867235055f74663b2808c5456e53ff040be86", + "python/sglang/srt/mem_cache/hiradix_cache.py": "6defcfe6b90f8205078aa08a605ea560d708d81d5121445205408d39cbdc846a", + "python/sglang/srt/mem_cache/hisparse_memory_pool.py": "65b49da21e56f544d4fe8abcf1fe5a91d03f68ef6e5c1a06f3ab45817c362e65", + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py": "bc06826aeae69fa9702469d6a8606fba6efafe66433e402f9a8fd488dfdb1096", + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py": "a348509b43c64ee979d838dfd7c6ee3350b6617edb608ccb0f593f7af86e7140", + "python/sglang/srt/mem_cache/index_key_cache.py": "740533e40dfa061c2b3540d403caeb079ff5c1b135ff4df23b66eeac05f00f2f", + "python/sglang/srt/mem_cache/kv_cache_builder.py": "7eae73259a8c52559b1b7d95ea9600fa70155da6e3a1fa8c2ba094d02bf8c058", + "python/sglang/srt/mem_cache/kv_cache_configurator.py": "06ea5d33aead6b058d64665e0282ee7f5d89ccbb1c221b229b2610f570121099", + "python/sglang/srt/mem_cache/kv_cache_dtype.py": "c104b125ff723c584bfdcd368a2129a9980e10381de0470c22522d4a0ae55f1c", + "python/sglang/srt/mem_cache/kv_vmm_backing.py": "c34c50a50260abebad49ab1b9832b2ece22a5a56dc66f8083c2220306cf11cc3", + "python/sglang/srt/mem_cache/l2_transfer.py": "d78f93396f2798dac12dc42e977592f24326c3445f253c671fa64e84137193f0", + "python/sglang/srt/mem_cache/layout/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/mem_cache/layout/page_major.py": "0ac5254ffb984db066285ce9508091e9f24dd2619bed631d7b0e7f3841959b84", + "python/sglang/srt/mem_cache/mamba_checkpoint_pool.py": "00be6d6ca4bc058ce743f08e83037b4b4a6aa6f62795c95bd70c332d8117d318", + "python/sglang/srt/mem_cache/mamba_radix_cache.py": "c90dd4f835b273673b9e2289624023469719041b6499b779818f3e5f4da455cb", + "python/sglang/srt/mem_cache/mamba_slot_fused.py": "291c34436e1d82b97f82a8ec8afe8b7999692c9be677f30b1a98f306e8970522", + "python/sglang/srt/mem_cache/memory_pool.py": "ebcb705f37b6f78cfb730ea43c767538a4f63b719a14336f5bbac71d20ec3f7c", + "python/sglang/srt/mem_cache/memory_pool_host.py": "fd2b196b9bf39ae93f96afce6748ae2571c26308dbc150da452dd055f3b03125", + "python/sglang/srt/mem_cache/multi_ended_allocator.py": "30415f31c66043aefe60f92278f8f1fa16ef2b1980fc45baee70766a536b5d1c", + "python/sglang/srt/mem_cache/multimodal_cache.py": "f1415edeb4554534de2648e2ee1ffacde06236a7b0028f29f94b9b94a954b739", + "python/sglang/srt/mem_cache/ple_state_pool.py": "a99b71c6e3941c060e4126c212fa9a941545d4d6614af7131681dc9b696515e2", + "python/sglang/srt/mem_cache/pool_host/__init__.py": "991f35e8e919d7b9c7a9fbf9c418a1087102bcb22dabb764aaf95ca4af071b86", + "python/sglang/srt/mem_cache/pool_host/base.py": "3a04fb9805312de59422e262c966713116f866ca836ef8de440829930a45a809", + "python/sglang/srt/mem_cache/pool_host/common.py": "b98f0399385093044562ceece5e04868e4ee5867aa36b89f36d0c2177cda6e15", + "python/sglang/srt/mem_cache/pool_host/hisparse.py": "0f94fd23d74613556ac5dbca59d8399fd3c5f6cbfc8758775bedb5fb5b8f9e01", + "python/sglang/srt/mem_cache/pool_host/mha.py": "1ce14fb16a447e63575bae99aa2845604c5bd2a403e518bc448a73044fde2f9a", + "python/sglang/srt/mem_cache/pool_host/mla.py": "977fe584060f0ef377949fd9bf7e060241f4aa38758299d4a401db8f1c9bf9db", + "python/sglang/srt/mem_cache/pure_swa_radix_cache.py": "ad4d75c308d0767ade0c6113081772a5f4f9ea49ab0e675ed899bcbed7ffe53a", + "python/sglang/srt/mem_cache/qsa_kv_pool.py": "85e7687daee0af9506b4c0e8840ec5b4c870be6f6930a3c210cbd31bf1f84412", + "python/sglang/srt/mem_cache/radix_cache.py": "c3ddcce2da58c455ea949d3214d77a2afb841de96ae7e5bf77a2730ec9d6299f", + "python/sglang/srt/mem_cache/radix_cache_cpp.py": "28bb1289e1ec45f4974638eec78f6fe17b963ae1a7ff6316c175b7d679e38e12", + "python/sglang/srt/mem_cache/registry.py": "0e09618b4e88fddca91540ea8813eaa35507ccded56f4c287b5b4b26af5bc00e", + "python/sglang/srt/mem_cache/sparsity/__init__.py": "cb5b7692800a739f4c3aa99cc4215b7aa437337bae2d7ef63ab9c703253e751b", + "python/sglang/srt/mem_cache/sparsity/algorithms/__init__.py": "f2d8e139958b5165f52acce6bd3a3bb04352b0ca610d3008fdfa6d9f26857977", + "python/sglang/srt/mem_cache/sparsity/algorithms/base_algorithm.py": "a805e5e0a2cc0e54daa530a52f98dffe949a3acf08b413911865c342ae9aaf4b", + "python/sglang/srt/mem_cache/sparsity/algorithms/deepseek_dsa.py": "5b70e38087383704ce8ca09800ffb37d8a74d88e55470750a9a1c05f07d3803b", + "python/sglang/srt/mem_cache/sparsity/algorithms/quest_algorithm.py": "a3a57a8621e513f982b56c45b5bf294bd9943e72fb5c768354fcddf97f673780", + "python/sglang/srt/mem_cache/sparsity/backend/__init__.py": "26273f1622afcdf6ba6ca5d8b329d3d58e3ded32c01c4635938107d4dff1305f", + "python/sglang/srt/mem_cache/sparsity/backend/backend_adaptor.py": "507274b969655308c2b8700417a787616c4a8619f0a45a4effcafa6a2224e333", + "python/sglang/srt/mem_cache/sparsity/core/__init__.py": "374d1108ac4dc013d0ceb0ff8c72f0fd6e826dd88aaa94576317dfc15b89ac9e", + "python/sglang/srt/mem_cache/sparsity/core/sparse_coordinator.py": "84559fc9615580a1245494cc3bd889abd4f960ea2904ca5dbe4a8aa336499311", + "python/sglang/srt/mem_cache/sparsity/factory.py": "174760bd209f84a68ad4c6ace33faeda3f4ff1cc307b5fa8ac07c9cace4a1a64", + "python/sglang/srt/mem_cache/storage/__init__.py": "1c3cc715455e38796bcbb1e57cbe6d45de47500d3637de29f2ecc0fd56bc9e53", + "python/sglang/srt/mem_cache/storage/aibrix_kvcache/README.md": "419e5f2f02c3a0bb502247b4fe076a829e1232b32c2086cf9157b3fb366d3391", + "python/sglang/srt/mem_cache/storage/aibrix_kvcache/aibrix_kvcache_storage.py": "c9a9f64c8d81de9e6d35bf39db03579a560710454eea26d627466a4502562379", + "python/sglang/srt/mem_cache/storage/aibrix_kvcache/unit_test.py": "84c269f9c31d2ae308634046dace048fa0d8d74abb7081df98015573adae4f0b", + "python/sglang/srt/mem_cache/storage/backend_factory.py": "d0a64077ce4e1b27be7c831543efe9622a102da0ffc0850dd2c4c786c7774c4b", + "python/sglang/srt/mem_cache/storage/eic/README.md": "28b16c973377a35508835bbd728090fd44c481ea3f2c5d025fca2b0c4be38bf7", + "python/sglang/srt/mem_cache/storage/eic/eic_storage.py": "175a6fa0ad59dffe36717b8e3217fe20937a7aa179251aa35f67408d69227afd", + "python/sglang/srt/mem_cache/storage/eic/test_unit.py": "3df34fa4beb6e2ddb7b72560b664b9175a468ae58332b0b7f590fa65b90df36f", + "python/sglang/srt/mem_cache/storage/file/__init__.py": "211b5bf704f84f381c9d81b929507e05c9c4eb9955e1ae3f00a129e8a78ccc7d", + "python/sglang/srt/mem_cache/storage/file/lru_file_evictor.py": "9e590e144c1169d463102e9aa147432cf5fa9108f1f8936de1184903c79a1330", + "python/sglang/srt/mem_cache/storage/flexkv/README.md": "c16b85753ea2f6f6027fa027868a74c16ea311674df38837008e16c01f50e7bf", + "python/sglang/srt/mem_cache/storage/flexkv/__init__.py": "77b4c12ed0352f565f0a3caff7d82caa572975ffa9785626028743442ceae67b", + "python/sglang/srt/mem_cache/storage/flexkv/example_config_mp.yaml": "83d9734fe13ceeb9773850f679ba54f49ca36a313fe5c6a95691a6bda7fd9aae", + "python/sglang/srt/mem_cache/storage/flexkv/flexkv_comm.py": "a565bb687c22388a9d14dd13e3e93112d3e4a003825ad7358e296ec61320c89f", + "python/sglang/srt/mem_cache/storage/flexkv/flexkv_connector.py": "635e481bfcaef29a6037d482446bf425e327b33e4fd13804f1b400e48dc4e3a3", + "python/sglang/srt/mem_cache/storage/flexkv/flexkv_radix_cache.py": "0fc8bbd7859005f454b3ea73b8e41ddc53b621c1bde4fdd62adc910df8ff2314", + "python/sglang/srt/mem_cache/storage/flexkv/verify_outputs.py": "3d20a6b8847e85e4e2fa9a778a657213549900d24fa6b810b9ec65833f97c3b6", + "python/sglang/srt/mem_cache/storage/hf3fs/docs/README.md": "b9f28a67b99d882233597d65c7ba8e42784b2e87b5f7f168ea98187109fca62a", + "python/sglang/srt/mem_cache/storage/hf3fs/docs/deploy_sglang_3fs_multinode.md": "e9aab6a832ef9f4e47651a00dc1213b128d29189d5107e5f456db1fe508399cd", + "python/sglang/srt/mem_cache/storage/hf3fs/docs/setup_usrbio_client.md": "8506110b4ea9adeaff24e4f1f8e45b74c9d0404a5b0aa786f420085088fd1b2e", + "python/sglang/srt/mem_cache/storage/hf3fs/hf3fs_client.py": "df11b4755e499a76c827c901d7f964f2301eaac84e714eed5c44b6ee57726fc2", + "python/sglang/srt/mem_cache/storage/hf3fs/hf3fs_usrbio_client.py": "dcdc16ae6f9b1c3307afcbc6af17cbfd1a0cebe1e538b03ebfcf4755fc53c2b5", + "python/sglang/srt/mem_cache/storage/hf3fs/hf3fs_utils.cpp": "74360fb7198be8e161132bff1ae4e0ce44c3a418dc0f410af24a619e7ede6867", + "python/sglang/srt/mem_cache/storage/hf3fs/mini_3fs_metadata_server.py": "a7e00b06d02ef5ca801d064ac8d7547961cef81b49caa8dcccf6ae835eff678b", + "python/sglang/srt/mem_cache/storage/hf3fs/storage_hf3fs.py": "ed33f0ce269ababa2496498c22ddeccde48faebbd4f9c036bd09f510e5a03cdd", + "python/sglang/srt/mem_cache/storage/hf3fs/test_hf3fs_utils.py": "2fea7f6cadea4745d900917267722a4d9498ef7116975b45cee736b03ab7a4a6", + "python/sglang/srt/mem_cache/storage/lmcache/README.md": "8214e609b24428cc93e3a46ee8dd4e3af082eb6d188747f33b77a92dff43f123", + "python/sglang/srt/mem_cache/storage/lmcache/example_config_ip.yaml": "48de9bd2cf06ac6105305551b611e4ae9a2f36e21355866eaad98faac697e1c5", + "python/sglang/srt/mem_cache/storage/lmcache/example_config_mp.yaml": "882686e3a48242cea38a620cd0214f564efbf7d637312bf8a82ccbb652820ef1", + "python/sglang/srt/mem_cache/storage/lmcache/lmc_radix_cache.py": "e7a0c04e1e4deebff441569c9cd96f910620e82def99391266404e09813cb483", + "python/sglang/srt/mem_cache/storage/lmcache/unit_test.py": "e563e3777e705379b1856c36140f1b3ed2cee1b5714325b8bc9ab69b6b8479ea", + "python/sglang/srt/mem_cache/storage/mmap/__init__.py": "3d355914915afc1ebb316292a60ad0f55281c88e103505aa1d4d75e3be21073f", + "python/sglang/srt/mem_cache/storage/mmap/mmap_allocator.py": "68b043b8bf868846dd0990ff5cb98079a54c2d01283bd8152edff196c9954d69", + "python/sglang/srt/mem_cache/storage/mooncake_store/README.md": "e6e7f1adf5a56e9ca871bc6e750efcae5be4b540d66c5b70953e19cf625004ec", + "python/sglang/srt/mem_cache/storage/mooncake_store/mooncake_embedding_store.py": "7ec3ef1b2e98e2ea4b85e117ad8e8c705103fe2cea2b52096884ee219702dd30", + "python/sglang/srt/mem_cache/storage/mooncake_store/mooncake_store.py": "d8232dc281bdc849df1dee9dd77b8ff4582818b3d46b0106c79a6cbc3729d7e5", + "python/sglang/srt/mem_cache/storage/mooncake_store/test_mooncake_store.py": "16af85082ba8c65be637403fa1f94bbe2eaf9b9f9698eccd1180c407dec5ffbe", + "python/sglang/srt/mem_cache/storage/nixl/README.md": "56e0cec6167d1c6bd53f6b197a3a2417ac8bb48afba687bf79c0c12cddbdda75", + "python/sglang/srt/mem_cache/storage/nixl/hicache_nixl.py": "8d9109990e4bbb2fd0ad60dc676c4369fabbd946ab84cd32c6a093af5125797f", + "python/sglang/srt/mem_cache/storage/nixl/nixl.config.toml.sample": "65efaf63789842d6412aa78d508232ad7a62a14face2c7049da86d523b87beea", + "python/sglang/srt/mem_cache/storage/nixl/nixl_cleaner.py": "16bbefafaefa793d201d71656ed415fded5c2e465476e011cce7058041bafedf", + "python/sglang/srt/mem_cache/storage/nixl/nixl_registry.py": "aee7d343b1e91d8f13d769b0de1ea66fcb0536f0400415e60407898fc7550dfc", + "python/sglang/srt/mem_cache/storage/nixl/nixl_routing.py": "5c40bfcc8814cea19137574be69ce31a6554c4ca795ab4ea49156c8e55375c7a", + "python/sglang/srt/mem_cache/storage/nixl/nixl_utils.py": "6ea9a6f58601709d93a65a71c52c204b3d25e28198d0d37feb7a67c80ba67c57", + "python/sglang/srt/mem_cache/storage/shm/__init__.py": "b84dde8fa936064b55e4ff467296e0c6fba9ca8a0574e60320f1d7b0d16b20d1", + "python/sglang/srt/mem_cache/storage/shm/hicache_shm.py": "32f9658b5027b0d282950440a0d2da59ac78f3d995edf46b191142581e58474f", + "python/sglang/srt/mem_cache/storage/simm/README.md": "eb549638b8a964a378c36a8de6850bedd49afe7361b409e7c6b7d1a8aaf3ff08", + "python/sglang/srt/mem_cache/storage/simm/hicache_simm.py": "e0fc56ebbc248ee4ee8c2c3b02b8679e06c34b84b72ae3442aa6ec8ad996c825", + "python/sglang/srt/mem_cache/storage/simm/test_simm.py": "4dd5ef674785cecb33e0a7de504259b9db496d59de2923d491b1dbee5db4f297", + "python/sglang/srt/mem_cache/storage/umbp/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/mem_cache/storage/umbp/umbp_host_allocator.py": "f4b31ed2d77a6679494aa95b112844c7934ea7531490ccd552dff6edb911a987", + "python/sglang/srt/mem_cache/storage/umbp/umbp_store.py": "a05076928164521278786f5ff5d83b49926dcdd1c36d186548a29908d5f8027c", + "python/sglang/srt/mem_cache/swa_memory_pool.py": "be524192527287453eb09ffce1d2b1e457a454bc18a6029e4c80dc3174a531a9", + "python/sglang/srt/mem_cache/swa_radix_cache.py": "ce38277491908c28457a39a53a90485e3ca8c56c6d579f0ff9b598d54c38b76b", + "python/sglang/srt/mem_cache/unified_cache/__init__.py": "dfe2244f37bf6c26b2b8473d6c0317fa4996ec16a1e98afb8dabd1ed93c90efc", + "python/sglang/srt/mem_cache/unified_cache/cache_action.py": "6e1ff116fbcbc77954e12bfbb8d525e9d60d26aa2b95d54f19920c3f15f9ed52", + "python/sglang/srt/mem_cache/unified_cache/component_type.py": "7d369ff5f0c9b84c0f0f73910357e7929b4bda6fc1287f987522a83f8c893376", + "python/sglang/srt/mem_cache/unified_cache/components/README.md": "28ae5e66cc56368593cad72793b70ab61e5798d586300e9e1922b5be2e9ca586", + "python/sglang/srt/mem_cache/unified_cache/components/__init__.py": "bde842f9c2d5054e000281d301ecfa1e934bef65628a77fdb6c20172c0f0995c", + "python/sglang/srt/mem_cache/unified_cache/components/full_component.py": "edf7ff730f81db8d2d322d54329f74953175cba5745ed55ab6e5d24115706d66", + "python/sglang/srt/mem_cache/unified_cache/components/mamba_component.py": "9bfcb7a20af48c2fce8cb63537db54cb4231456d9c04896370e290611e0ba799", + "python/sglang/srt/mem_cache/unified_cache/components/swa_component.py": "2db0eeaf673cf690460f9c859fdc35eecbcf3ddb9396b21c7a7502f8925d6b52", + "python/sglang/srt/mem_cache/unified_cache/components/tree_component.py": "e79eab56f3803fa81181cfa4d6a42d7aeba95b5d89a1420195c4003483bbad0e", + "python/sglang/srt/mem_cache/unified_cache/session_ref_tracker.py": "21353af6b20585132b65e3952dc5ce3f2450780db1fd8d0d809e184d3fb37007", + "python/sglang/srt/mem_cache/unified_cache/tree_core_registry.py": "d767fcdc2c2d7ec40f541be897a4036d55fae7a40c629217cf72ddacf1bb7359", + "python/sglang/srt/mem_cache/unified_cache/unified_tree_core.py": "2b66bd6c8105c12d8b57b5d6c1abd3a87136bfaf0524fd9606c7746c81327aed", + "python/sglang/srt/mem_cache/unified_cache/unified_tree_core_interface.py": "cbffb202a3a4bc2e91b184c19551ff1a310eaebdf70fb8fe93e52c5ac8c3f9a5", + "python/sglang/srt/mem_cache/unified_memory_pool.py": "143f40588c2b88929dfc5017281373413827026ee79e6870b703b0b999946348", + "python/sglang/srt/mem_cache/unified_radix_cache.py": "6e29ffa01adb96c9d400331850fe60b054cd83c980f033d36552e369a5d5c6ce", + "python/sglang/srt/mem_cache/utils.py": "9310f130db27f7277ad0295a02f82809f3798c4e6ba0ea828990a76809f7068b", + "python/sglang/srt/model_executor/cpu_graph_runner.py": "253c23bf2abe2642763e7942a973e4456c49733253c45b47e54c936fec1100a7", + "python/sglang/srt/model_executor/cuda_graph_buffer_registry.py": "28fbde4e1e9f2824928b29283690fed9e7f38cac435d416f355fb92d8ea346fd", + "python/sglang/srt/model_executor/cuda_graph_config.py": "a131496f543eb354e91ca818b0f3863918da51aadae8e8a6fba087edd30cec76", + "python/sglang/srt/model_executor/forward_batch_deepseek_mha_mixin.py": "4d46d49221749cff5289c262d8acd6e2f5f3d44db1a1d7ffabbeb32fd9e6f05a", + "python/sglang/srt/model_executor/forward_batch_info.py": "c5465206368475dd2c1887de893679fa171793ee00eddaca8ce6acadc9237627", + "python/sglang/srt/model_executor/forward_context.py": "63900e43eaf683bcc50991e56dac6d194566b9fcef2ed452ff8e5818e503d2d0", + "python/sglang/srt/model_executor/graph_memory_usage.py": "e98c9a6d7c4af6eff1302e0a592cd1724098b043cbd47cdb0c25780d3058ae9b", + "python/sglang/srt/model_executor/graph_shared_output.py": "aa7b7bfbf903584089ba64f8756a541343edea0c8fcce5f6d49e608e7c0159f1", + "python/sglang/srt/model_executor/hook_manager.py": "899bea28f874cb7a44b7d10fcff50814b6f99221e31fe4aabd073227f3c24073", + "python/sglang/srt/model_executor/input_buffers.py": "5167fe0294d63ee7dcb4f8c5bf9bf4430c838666c7b00f670c8c57a50d9e14e3", + "python/sglang/srt/model_executor/mindspore_runner.py": "a2d5affc4c2d97069a93f17b215a870d1b32ab75479e47adfa73797b666e0bc0", + "python/sglang/srt/model_executor/model_runner.py": "d93a427b8ba77128ba0752adb990a1d69a489e3249c189ee9bca67583ace2069", + "python/sglang/srt/model_executor/model_runner_components/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/model_executor/model_runner_components/attention_backend_setup.py": "bf01b845e22471e19941168dad276e8f429ca302e7cd59ec4c0463defc5bbda0", + "python/sglang/srt/model_executor/model_runner_components/cuda_graph_setup.py": "ca36d4b440ea7a67f42cfc1c253a292f5dd039041ea24cc6d9177ce58aed3205", + "python/sglang/srt/model_executor/model_runner_components/kv_pool_runtime.py": "ab82c8793c90f0fcdbfdbe4a9edaa28bc760c304c4a76cd6b03a96f20263d061", + "python/sglang/srt/model_executor/model_runner_components/layer_setup.py": "235c9ecd3a707645fd3aeeb54602c4233d23cf23a216e16ed8ef7cd6be2f4e4c", + "python/sglang/srt/model_executor/model_runner_components/load_model_utils.py": "c864d5fa51311a9653a609bf23a70f21d2d6ea5c1556c5287adbdbb1b3c4ad4f", + "python/sglang/srt/model_executor/model_runner_components/misc_utils.py": "673bf8a3feb784c9054c9865d2c3441f34039e43d84548928c2b4b7022f57112", + "python/sglang/srt/model_executor/model_runner_components/moe_ep_setup.py": "5776252dc6787df809c41e2c2b2130b153c76bee773ac814d673be782d6b2d0a", + "python/sglang/srt/model_executor/model_runner_components/ngram_embedding_manager.py": "050718d06087e1586d220654fd91916c4dd1b0494a2312baab768bc2c3e9d797", + "python/sglang/srt/model_executor/model_runner_components/remote_instance_weight_transporter.py": "092536c27b0f72216170708dfd3ab6edea2e057f9e4a5bfdaa8fdaa17606684e", + "python/sglang/srt/model_executor/model_runner_components/spec_aux_hidden_state.py": "db31c1d76466c6f99e5acdf9483a2a6beb4e6d8a6d96a07c17646257a61a7e9f", + "python/sglang/srt/model_executor/model_runner_components/startup_weight_load.py": "cd502780948edcffc33027a4b324a37da14630468b1c5ed0cd22bf4515bc4efb", + "python/sglang/srt/model_executor/model_runner_components/weight_exporter.py": "de472de90137203bcd00585e400a9200b62f2b78385ed9296fc0d00ced9e4487", + "python/sglang/srt/model_executor/model_runner_components/weight_updater.py": "564f42a67afa1d0f37a0049b8ba6d444808bc9b3ecd536d071feab125358df81", + "python/sglang/srt/model_executor/pool_configurator.py": "2bbd8233d29e1e748b4600f902a9911db1de4a14d727f30d6dd3fdf4083624ef", + "python/sglang/srt/model_executor/runner/__init__.py": "97fa36fe04f0627ea70570f30b63e84dd8eb5945b8043d087cc81f7e4ff949c6", + "python/sglang/srt/model_executor/runner/base_cuda_graph_runner.py": "2f64791e0a5056a248126e306b4a003b510ecec66d42bcf62e52f7801ba23ac9", + "python/sglang/srt/model_executor/runner/base_runner.py": "7703c46be36a5e5c04b6a0d99117b58cc007e578c61effcbe968ef8cac90adc3", + "python/sglang/srt/model_executor/runner/decode_cuda_graph_runner.py": "96a92a7c60a8ec81c606721ec7d5cf7588173a55505e58f7f231757a056029df", + "python/sglang/srt/model_executor/runner/eager_runner.py": "40168d097921768244166dabd3506e9f136ef7dec1455e7cef927978c790c351", + "python/sglang/srt/model_executor/runner/flashinfer_autotune.py": "a719df49227f1c16725ee08b3653ce533a231f202f026eb0abf6654b2230a5c4", + "python/sglang/srt/model_executor/runner/prefill_cuda_graph_runner.py": "d0a020ec366e536f80357c749a9653cca00202da0019f890d4a205e783e6e875", + "python/sglang/srt/model_executor/runner/shape_key.py": "11f5b0c097aa4041c9b52f83422760394b039eda9633862035ba09cd7b5c3bf5", + "python/sglang/srt/model_executor/runner_backend/__init__.py": "0ca105fd3561122d1dfe030672f9ac094ef000aafcd3109f565ce78d8e1b05b8", + "python/sglang/srt/model_executor/runner_backend/base_cuda_graph_backend.py": "57fcbc83c10b8e83dd60cd3da1cb7e2a58b19ee0a390d80ae921ed24bcac4ecc", + "python/sglang/srt/model_executor/runner_backend/breakable_cuda_graph_backend.py": "e64520232bb15bba64aaa98bf89fdd34d25b13e1ae1190caeb25b98ddc4e6f0d", + "python/sglang/srt/model_executor/runner_backend/cuda_graph_dedup_mixin.py": "9038ca91df07fd957ee910ba6ce8af10da36608da01331591a391bdc8e2c535c", + "python/sglang/srt/model_executor/runner_backend/full_cuda_graph_backend.py": "f765293a501591ffa5a108cc73ea3efed8c90fc4a947021602a15d4248ee5c12", + "python/sglang/srt/model_executor/runner_backend/tc_piecewise_cuda_graph_backend.py": "66414526bedeed4b085d691410507b7c3428b965d93e5ca4108ad004d6704ef9", + "python/sglang/srt/model_executor/runner_backend/utils.py": "c0deb930798f6fd63e4a7955a850c0b6f866868502da1f45269f63b796c1c124", + "python/sglang/srt/model_executor/runner_backend_utils/__init__.py": "7b7119efcfd59dad25698a73771656856e533c0e393b073fd3ad0afd38f34279", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/__init__.py": "7cc27ba46d122dfe8f37ff11f02223e4fb2cc5577165a5d6d4dabd7b023488c7", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/breakable_cuda_graph.py": "730d8c0963bf7752e0aa3094f76046424ee836cd1067cb9d8e4cdefcced5c50a", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/context.py": "f7cf9d819d872d4c0d3c0201ba9853939e4509ac8309445ba9f75aefa6525729", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/cuda_utils.py": "808b8f470974294317589f4dd914d0eb7e3087d1e81bb4465f19f3dc0ac86b31", + "python/sglang/srt/model_executor/runner_backend_utils/tc_piecewise_cuda_graph/__init__.py": "364c2cdfabfc7c1e746f87aced897c54f10790fd5a05c4f9100d342ab6db85a6", + "python/sglang/srt/model_executor/runner_backend_utils/tc_piecewise_cuda_graph/context_manager.py": "1f51ba025ea2130b9c13483dabd1e505edd75bae61f9a05d22bb8273ae238d95", + "python/sglang/srt/model_executor/runner_utils/__init__.py": "e4d428f53b42efe3a95446bacf1ee7d7828e66179d1368020e67ee70e723bcee", + "python/sglang/srt/model_executor/runner_utils/buffers.py": "b330f13a2f7bfaefe69c4fe39024fa64357ad963113700389180d7821e29e3dc", + "python/sglang/srt/model_executor/runner_utils/capture_mode.py": "539b4f62039a17c5e5e0a0637757d04de3cfda83a5ed37f611c2d5be2e4795db", + "python/sglang/srt/model_executor/runner_utils/deepep_adapter.py": "d97ecae40b3ce131994459af95ab425cec058e74d78b54ee7ed405d11a57c1f4", + "python/sglang/srt/model_executor/runner_utils/pool.py": "f271c959b63c5925e0784f3232dc7babce2b2dd9eee525a18b58fd60886eea54", + "python/sglang/srt/model_executor/runner_utils/shared_read_event.py": "4dc2cbdb575719dd7b604977116272ceb4f95c356f48047123deac2773faae83", + "python/sglang/srt/model_loader/__init__.py": "8cfa1f43a634864baf70c664ad8bc911a9da50a1cf84a7942f5187bef477ce00", + "python/sglang/srt/model_loader/auto_loader.py": "4401654e17fd8c9a65bc15bac7f4786d7fb37eb95fffb9f747339ab57ff5b173", + "python/sglang/srt/model_loader/ci_weight_validation.py": "73c825b8435845663dc600a456de9e7c416626ce37c7c85331eec77a87b77881", + "python/sglang/srt/model_loader/gguf_name_maps.py": "281feaa82e79d805d58ba68ed6dbe6287db3515300ab3cbdd8e397cd44bdcdb9", + "python/sglang/srt/model_loader/loader.py": "5746f08e47e8a21e173a0df6036a9c1d58d0ffee5d392ef5361deb7d77d0a539", + "python/sglang/srt/model_loader/remote_instance_weight_loader_utils.py": "6e4743a6715a7a24bd854144b9d9383fd6479da8ca39991845f4e96d5a5c6b2a", + "python/sglang/srt/model_loader/utils.py": "7151f2b4092d14cb13a68ec645f386e024f4919eb22dc52fe72052da01419834", + "python/sglang/srt/model_loader/weight_utils.py": "1759d4feb63dc1e41f509f16c4d46d2f00a175fec6f5efda1fb5a7501394588a", + "python/sglang/srt/models/afmoe.py": "51416d24e54e8686c2a15a08ad211dd62fa281b5a9ffaf7c32461d44ba69771d", + "python/sglang/srt/models/apertus.py": "5f3f741d622c74475de0a2788a364728d933ac98e72fb3b061e643e702bed800", + "python/sglang/srt/models/arcee.py": "00d5599d470e993a6b3308dc0ba9231c386d45cbff60d51d65957c0f51e1007f", + "python/sglang/srt/models/baichuan.py": "3a8ea172c648f8e472012dd7c6a68e02b4df34bbf0d2d36527aa35c6542b0e00", + "python/sglang/srt/models/bailing_moe.py": "c5052c1d24a805a78623d89f32d164a50db75167b177333b682814b3473c3599", + "python/sglang/srt/models/bailing_moe_linear.py": "366d86420d3811c7a6b084c7b4280b2d994e3b2f058df4918a83a452bb66acfe", + "python/sglang/srt/models/bailing_moe_nextn.py": "d33076e60f6801ea42e5e6f2ca3a97e449bf20b2ed3d8ae930726aa2490d31ba", + "python/sglang/srt/models/bert.py": "23b157b2a5d90c24c7ced6a67909120d1d0759fe5b9d518c15bb29ee7e4240aa", + "python/sglang/srt/models/chatglm.py": "76f9c49d9b4cba67d244841774449485a8c98201402508fc9cbd2d7efc07d302", + "python/sglang/srt/models/clip.py": "0b3851d2381bc2cedda81d985f18875414f9ccd6844958ddd556b8fadc1cf2e9", + "python/sglang/srt/models/cohere2_moe.py": "bba44f58ef1ec55e1004d8ddbf99950eae69806f3a061c102a45fcd428fcffa0", + "python/sglang/srt/models/cohere2_vision.py": "4350018aa1c8f8dee60024ff48756ec7b88a1d906b35263308b666772d7ea346", + "python/sglang/srt/models/commandr.py": "a80d35171cbd8f87dfe2a1832440c311c340ce06ac8c66324a29afb1c915cf2e", + "python/sglang/srt/models/dbrx.py": "9f0d6d344cd10eb4f810d042137ffa067b547f86a1a82f9c4882b959f62d7814", + "python/sglang/srt/models/deepseek.py": "7f1e7743b734acc16f821d166301015120bd6e64242464d326d5c3a38883c830", + "python/sglang/srt/models/deepseek_common/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/models/deepseek_common/amd/__init__.py": "91337352ff5bde7bb2d74116c6beabf628948ab03fe055604376861e3486bb19", + "python/sglang/srt/models/deepseek_common/amd/deepseek_v4_fused_mhc.py": "83d2a21a47f867c8816c6e60aac17e435f0b212946838d280dcad99f670af91c", + "python/sglang/srt/models/deepseek_common/attention_backend_handler.py": "0d379aed9bac29ccea54361ffd22ffbd4853c9008f70a8d75b06b6a6ebd8a2de", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/__init__.py": "4907531368605837fb09f3579dd648ce6a27cbbbd2177ac69629a1f6705dbd37", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_methods.py": "4d66f9a7098eb22e1a94ba16ceb2865e18df578de9e9878cb3b314dcaa3d2e1c", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mha.py": "9ecd6362edf7dcbd6f9e49842450bb45295bc8efb605ade27082a8d7bd8807e0", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mha_rocm.py": "398271bf5d75636eb721987b3c73387be7ce17349bd20533a1fd259e0d35b15e", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla.py": "d54137d7bba213cbfc39365fbe41492a4cb26ac479236c77fd7bda55c7c4bc42", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla_fused_rope_cpu.py": "c6c3965d5d76a6a80ffca6dfd40229df38ce92ed8aae946eb2bd356c50cef268", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla_fused_rope_rocm.py": "9a7cd4113aa4c830aa4403ecf240fe13eecfcb84bca4100a762b571d07d70145", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla_rocm.py": "9ed9a0fd2262c22935879c919540dc96d3965bb0ef59d18e7460747ea8e52629", + "python/sglang/srt/models/deepseek_common/deepseek_weight_loader.py": "04a7e150912e7035c9ec538822367c4d9160235a4e23d94a2e526d1c6a4f9f19", + "python/sglang/srt/models/deepseek_common/utils.py": "7e9b06cce0501c1de11afc261e446c1d4edcd5f43b06c7f273ddf633c6893f3e", + "python/sglang/srt/models/deepseek_janus_pro.py": "c22190f341e785675a3c9d1b62441467f4da4bb7a4bf9095759c9e6e8d427deb", + "python/sglang/srt/models/deepseek_nextn.py": "462c7595ac80361c5988bfdda4a63a3cde0236983d2afcef11241216a210986c", + "python/sglang/srt/models/deepseek_ocr.py": "7f11abd028f5d48f178120e69c5dcb936f17fa48699c9eaf482be1771d186797", + "python/sglang/srt/models/deepseek_v2.py": "1ba2ffe6bf7537d0fcef6945f44b239883125a8bc382e86fa57885c135bed21f", + "python/sglang/srt/models/deepseek_v4.py": "304cdce90a9638804731c36a6f4f61f56c7d81f2e530f7bedd67bc5eb632e75b", + "python/sglang/srt/models/deepseek_v4_dspark.py": "0a7221f4405ae49b88983c97eaf97e073823871180d9080e6f7215a1206ef16a", + "python/sglang/srt/models/deepseek_v4_nextn.py": "d3139cd8f1dce2b2100f5eaeda71bb826abf4b5fc9dc20170147f6727bd24d30", + "python/sglang/srt/models/deepseek_vl2.py": "f2ec27c761892722ea7003e4f16f66b84786866551f77de4debb3961b4702a7a", + "python/sglang/srt/models/dflash.py": "b4c867543d80845bb621cb9bf93a0f9d8b09a6753f2a4d32e5e36d2122babc30", + "python/sglang/srt/models/dots_ocr.py": "b16905b043635f96ff09e70b0aa5e37a9b2bea2cb209b3539a365b45fa01e1e9", + "python/sglang/srt/models/dots_vlm.py": "13e74814ce7ae20cf2d37855cd429e3227b2d40269d301985f41ce1888d0da7f", + "python/sglang/srt/models/dots_vlm_vit.py": "03dfa21a2955d6d00148f97c40c9a840ca9613e33261b88911497954cc608f74", + "python/sglang/srt/models/dspark.py": "194759ffba28cc1e1d7d8ba28cb2f0134ec9f935eae34392bca2178c748b19ce", + "python/sglang/srt/models/ernie4.py": "2cbf4d45eb9ab1bc6b11ddac224de50697374bc8fcc21b711b1c73adb9e5604e", + "python/sglang/srt/models/ernie45_moe_vl.py": "0b0047ca789e1d763afaceb687bd1129eebdb0be26436e142ade22254adefc8d", + "python/sglang/srt/models/ernie45_vl.py": "cc7804e3875b65c7f541eb2676565616158fd019c8a6fcc6635119ae57dc93a1", + "python/sglang/srt/models/ernie4_eagle.py": "fcc548df82ad5df32cbe847406951d47800265931226e68853f4d97c17a16b77", + "python/sglang/srt/models/exaone.py": "a38b7b4bc8e2e2ec25108bfde1414f33fd585b06772aa376a10974799bf5bce0", + "python/sglang/srt/models/exaone4.py": "8d46719fc5bab2348a96c5d4b5ca481776c23e81421404c870a620633043d1d4", + "python/sglang/srt/models/exaone_moe.py": "d29647bf5a6756dd087a5b28a23704a461b10900588f0321bcf88fbca228e2d0", + "python/sglang/srt/models/exaone_moe_mtp.py": "71ae12725a3c92a14a679002cfc8c091de0f578dfbc2d263376e443c1502f544", + "python/sglang/srt/models/falcon_h1.py": "2feed2e456a7ed86f8d6827994df3514e5c94244dd675ef99b4f91c58cd63812", + "python/sglang/srt/models/gemma.py": "0fb42f0965d7b846b9e1b04cb63f76404bf77b9fd9db91c76c08cb940e37ece5", + "python/sglang/srt/models/gemma2.py": "aeef5821188e4b01c3e7d3569851ac9609de210d7988d7bc560a3d9c9b0202c3", + "python/sglang/srt/models/gemma2_reward.py": "2b89ab5090aa9c7832763ac38084c58095d1f5584b23c5acef29cf5287194ab8", + "python/sglang/srt/models/gemma3_causal.py": "e68b3840ebef0b986ab96653ee2bc4395192f330ddd2a95f0ad1e420912166a4", + "python/sglang/srt/models/gemma3_mm.py": "f35141ba77b106706574e8ba3f905e54e8210e5a7d7fbdcd1d2991d036a36e71", + "python/sglang/srt/models/gemma3n_audio.py": "8ac80a7e30395227986b0c54ea679d2f6b2c5e5cd83ea01b6a00c19cb71e982d", + "python/sglang/srt/models/gemma3n_causal.py": "833ca64d4d4571a6612d6cbd63c7260ddc1207691e8f0d835a58a9b6c017e079", + "python/sglang/srt/models/gemma3n_mm.py": "c5b0965ccf240ae0d6216bd4796a12a85d0f16920f5c658a5fefb1363137331c", + "python/sglang/srt/models/gemma4_audio.py": "08a394f05e3b87593346cc68f2c7c6fca5edd527a9564f2e25fbd0117dafb8c1", + "python/sglang/srt/models/gemma4_causal.py": "62a9e720bb0b339005bb96ff12a128c476936b9ec2764e529bbed7e3df4a6f5c", + "python/sglang/srt/models/gemma4_mm.py": "4e58c60a573f140afe9bf51d8023d909aac48ca906dca40bace4b37394f137d3", + "python/sglang/srt/models/gemma4_mtp.py": "3c2025089f6c62738770a45bbf64df5bc615c2f378cdb1753f4febc055aff138", + "python/sglang/srt/models/gemma4_unified.py": "d5498b253f35e83ab0aaf219a2c2bf2f42c6bbd3f95ffce02760e78b2e38a4e9", + "python/sglang/srt/models/gemma4_vision.py": "66eaaa3968f9ec8339890dc105174e74db21c6efeab5ca31650c368db97a445a", + "python/sglang/srt/models/glm4.py": "ca559ff25961b5c87e017d76a8169c48a3ac6e6e59ada6ee8f2d5699ba5ba6c8", + "python/sglang/srt/models/glm4_moe.py": "da66fe6314fa84e7401900cf7e7a05d7dced72b39477595c3a67fda735e24256", + "python/sglang/srt/models/glm4_moe_lite.py": "cfcee7654fd72dbd192fcd1b8a1728fb318059caa41c679e3457abf50a7e1031", + "python/sglang/srt/models/glm4_moe_lite_nextn.py": "165b7fd2a6b15fdb338707846dea4aa4f4a380f87eff358a4463c8598fff1f2a", + "python/sglang/srt/models/glm4_moe_nextn.py": "6c6b01239f596f2c3ff7cff2836b498d2c7e5d891ef4d387eb9d2d74e46dab91", + "python/sglang/srt/models/glm4v.py": "92ea7274deab155e77bdc8acaff13b422ef46038aadb46aaa59c0783aa1e526e", + "python/sglang/srt/models/glm4v_moe.py": "b510ecd4d1aa164699e1306861e993a9b07bf126f98944bd618e9c158754d5bc", + "python/sglang/srt/models/glm_image_vl.py": "7d994d2b83a9cd46151bf525dae23525d4b1ab6636b57d62933348242c2d40cd", + "python/sglang/srt/models/glm_ocr.py": "1f0af6af0d24a3d8e36ca50e93e52ec8f2d45f8b6e2db7634bd551301deed8d0", + "python/sglang/srt/models/glm_ocr_nextn.py": "f4495df9b3a3cbeef4948d563c832f378b302113d714dc14892feadde8b9a7e2", + "python/sglang/srt/models/glmasr.py": "36bba050ca1b985944c46ee662f3045f6cc2c76bbb7168033900de75baf48ed1", + "python/sglang/srt/models/gpt2.py": "acc560106bdb0f4bf7666a6500bfe04871cc7cc330ff9f984343825a048ae429", + "python/sglang/srt/models/gpt_bigcode.py": "d93a118f5a053b4f5a916a38ac277e8ecffa810497fc36f38104586f381b405d", + "python/sglang/srt/models/gpt_j.py": "ea6573f8f959be3ad3e6b429955cbc2c8e60957af456b439ddb2fb53b1121536", + "python/sglang/srt/models/gpt_oss.py": "e345802d5b8696e58cf3022083110dd8d1fda18290cf7fdc13274605fc3e3dcc", + "python/sglang/srt/models/granite.py": "2157d2628813e0d91877b54ba9cbce90067b77cd56ddf6b00b634e94b1f7738d", + "python/sglang/srt/models/granitemoe.py": "f1a465f47fa472801ba0c8cefb9227254ea6309273e5ba6394054d329ad03910", + "python/sglang/srt/models/granitemoehybrid.py": "63e020e0d734db583a5dd19fa70c7bad6a1ea4800a92a7fb0ec8084edebbe44f", + "python/sglang/srt/models/grok.py": "63b87b5e58545c7bc474f9f1793917afb18cf33b9618946a0f7631acc52cc481", + "python/sglang/srt/models/hrm_text.py": "d71689264ede55ce8ba847ac63ce6cb43b671734d267a0b67b08d60b62a1a88f", + "python/sglang/srt/models/hunyuan.py": "137de560974b24bd2c8705d82a13f4a2357d2b86fd16c389c8f07d1cb5639749", + "python/sglang/srt/models/hunyuan_v3.py": "bcf21fe22dafbf739b009eb3ea0c996251c08c69b07d5a61284e735ae6d184ff", + "python/sglang/srt/models/hunyuan_v3_nextn.py": "1389dc50cc287248b03adcbe4e2c394d5c81cec5191e3c047a1b3f2156dbfed7", + "python/sglang/srt/models/idefics2.py": "b2794f629f7faeb43d25050ea3d7dc0a1aad0da55134217973ac6c6bfc2869e2", + "python/sglang/srt/models/inkling.py": "bb54c701428d58967690bb016b170a237cb018f28bc1b2941dda61a6c33ffbfd", + "python/sglang/srt/models/inkling_common/__init__.py": "b96821456ca126fc0ba0c2d6d026664714dcaea47fea7add939d80d74f401d94", + "python/sglang/srt/models/inkling_common/attn.py": "2152a03ccd0c0535e65385c6961e968981eb8af9966fa8189a724a3016635a92", + "python/sglang/srt/models/inkling_common/dense_mlp.py": "632432bc4dba4d2e9d7593777aee00af746b2da448d0d0e7e30b424c11b30f59", + "python/sglang/srt/models/inkling_common/hmlp.py": "377c5ac0d2fd579897dfe8e059e60052ffdf08095e02d5c8ab90c8c1fa288474", + "python/sglang/srt/models/inkling_common/kernels/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/models/inkling_common/kernels/comm.py": "f2e1224fe7f1eeb1c576c4592ce55d875a8681e26efdfea54b504b41667bddec", + "python/sglang/srt/models/inkling_common/kernels/sconv.py": "7e9862ea08df10fea5772f51bad0708424b996409c5447ac3872f539e6414b4c", + "python/sglang/srt/models/inkling_common/lora.py": "706df5c637c5b092c246d0bf95605604c33329880f292c061441c4c9ed788c69", + "python/sglang/srt/models/inkling_common/moe.py": "4bf39c7662ac4337ce81c5136ce288be18e532290400fd27de5fc0ea4384ea92", + "python/sglang/srt/models/inkling_common/norm.py": "2f386379b4ec8680cfa438202885a5c31de9e0d9287c2a5fa10e2f1874f2d39e", + "python/sglang/srt/models/inkling_common/quantization/__init__.py": "20764ebd292899f5c31c5747ae7289174126807570f84482ebdf44a01ebf5329", + "python/sglang/srt/models/inkling_common/quantization/config.py": "ffd7c1bda9e756ec6056b61a5b6d853a2bde682cd6ac39b9fe8b0b3ceba21613", + "python/sglang/srt/models/inkling_common/quantization/quant.py": "9fac6d421bdfd85086e390c45f22794f79bc23934387be094206df26ff8a00b0", + "python/sglang/srt/models/inkling_common/sconv.py": "39f7e78b8b9b476de003a902ebfc7acd98cae625901d94d23b24d383238dce06", + "python/sglang/srt/models/inkling_common/util.py": "6258d774bb930aad9f93c7fa91475e808d1a427fe3d6044e1fbc2fe8867a25cd", + "python/sglang/srt/models/internlm2.py": "e9a1b60b9ec93b02cebb60b2a8db90ec75a5ba07aac92ef48d0b418f03a59bc3", + "python/sglang/srt/models/internlm2_reward.py": "c229f6bcf851c72696b5d637f04ce8dc865ae49f8436fe9558c2b57d2aa7364a", + "python/sglang/srt/models/interns1.py": "f36a7f8af20b4dc127f3138fc951b573d693fa16ab3af96dbcca267a63583dec", + "python/sglang/srt/models/interns1pro.py": "f8e196bb3eae4df08312c58ac124587f2195732bef28851aff0d3e7b1b31d3e4", + "python/sglang/srt/models/interns2_mobius.py": "b6b1684fd7d6e5110d4a6bd297f0703d83629ccbc9f1d330f2363e864d7f310d", + "python/sglang/srt/models/interns2preview.py": "f19744e2c4c18d2919100423b8bfdc0546c80512a293b2e49a2a727272e067b7", + "python/sglang/srt/models/internvl.py": "b318a9e40618e85114a472494c3e9410d2ad9ad7074ad1cfb89fbd48483d86f1", + "python/sglang/srt/models/iquest_loopcoder.py": "a9276f23629feb434f0e12a81709c7d9bd903b228b84e68c2c6706373713b91b", + "python/sglang/srt/models/jet_nemotron.py": "38ebd2df37393986c1d816f316634412cb2a7a0d4bb52b0acc068b012e3c8b92", + "python/sglang/srt/models/jet_vlm.py": "2b406a23b6a742e0e0912b330191d7795dc52fc9ee8828abcf774a029e624d02", + "python/sglang/srt/models/kimi_k25.py": "cf64ca2bab9c828aaedae7a86ce018947d32138377fd2f2a5b9a2e4ea7769503", + "python/sglang/srt/models/kimi_k25_eagle3.py": "4717e7ced2536b879ffecbafd8597ad55a78707cda79cffa27ebc11a9aa25f1d", + "python/sglang/srt/models/kimi_k3.py": "d8dfc58e73246577d9eb6aef5488ee4c205ca40b88bd9af849ccfffb59146f04", + "python/sglang/srt/models/kimi_k3_vl.py": "2924c38f652a6ebff2ef79c49f2f336ba18723ea4b854d3ac14d95292988acdb", + "python/sglang/srt/models/kimi_linear.py": "40274c2c8e6fe095c0b3edea28ced13083a26dcdf45b7b0eb06e5788686a8209", + "python/sglang/srt/models/kimi_vl.py": "8b6d662dfccf19543ff8223a862bd1eaeed80f073001c27f20c655130ee9c713", + "python/sglang/srt/models/kimi_vl_moonvit.py": "e417162c4e61613bd76994ee9fe0af1a58eebaa44ec14b6d6b85bf778ae6dec4", + "python/sglang/srt/models/laguna.py": "085ddabc569bdc797394f9dbc83e16d1e8db309b50295517f5ee03b974de6d01", + "python/sglang/srt/models/lfm2.py": "1ed88642d9370b69be11d219e86caeae80aaac035062a70fd2d148a2ecb14f92", + "python/sglang/srt/models/lfm2_moe.py": "7a3eb60fa52f32f07cea305e233bc0514a940a9a7444daa42252b4be06596f3d", + "python/sglang/srt/models/lfm2_vl.py": "256facc230ca3455a651a2feb94302a9b25cfb66316f041f87ae5d5fb306db77", + "python/sglang/srt/models/lightonocr.py": "88b3e3f81a099bb19d280f078c9ba303e1ca85e1f5fa078424d516d29fe39577", + "python/sglang/srt/models/llada2.py": "89306a43224bb9a51749fe7738be7356f40d9858a5f11037a45ec0239b02eee6", + "python/sglang/srt/models/llama.py": "1f70c2745c24658a55c2b17a7629a9c728e41f2fb2734801ba12becda55d932f", + "python/sglang/srt/models/llama4.py": "e372b3afea00078bb75e1b0d6d3c3472a740db63c54e84b9511549fc5d47da0e", + "python/sglang/srt/models/llama_classification.py": "055235ecdd405590a3e883eb3279012f5ae52b6889b842e489794a3f713e67bb", + "python/sglang/srt/models/llama_eagle.py": "03a48b74e97bd7f43582fc4b11d06f3423f384538c4845c86df1c6804fbde6f8", + "python/sglang/srt/models/llama_eagle3.py": "16ab0259f7823174688e0461827aecdc51edeb7693eb720c9a0f7cab3bdcc8cb", + "python/sglang/srt/models/llama_embedding.py": "ceafbf94dbb7e5504573b79e9a26a6d3376418813c7f3ae093939661f8ab6670", + "python/sglang/srt/models/llama_reward.py": "87625f811511a8aea3e11e05a12e4490edced7703ac3126a015db48a0098039b", + "python/sglang/srt/models/llava.py": "49ffe4b8e6dab21185e6dfd5e632bfab9f02b8ffdccb3e3ef94e95aaf7a021c3", + "python/sglang/srt/models/llavavid.py": "cd78585da7006df12425fb2a5d1fc5a6998e13ed1a4e2ff4c51efd1e3c45fd76", + "python/sglang/srt/models/locate_anything.py": "e5ad5a36e85f417e38ec297ac091dee0ef54fe9495c7cd5c9d1ab920b277b8fc", + "python/sglang/srt/models/longcat_flash.py": "db2b42f23b3461a6d0a0be1c52a05550c3bf5ae93ea45165c91d4248d40e01cf", + "python/sglang/srt/models/longcat_flash_nextn.py": "b2dab60290fbba8c612e2f0712fcab802f98aee18d585665ca4697a60439a636", + "python/sglang/srt/models/mellum.py": "ec83a2403979372196e8ba805d0bc4d3a60a05f39ebf4918fc25fd2c710cdaed", + "python/sglang/srt/models/midashenglm.py": "41feec5b1cd1c902f518dfbfe829d072a46046b945c2a8cd2ed00d388c17e14b", + "python/sglang/srt/models/mimo.py": "4dd89f957b5ea3f1cb1fb43561feb10c039747336b3a92d1e248d55ccb9e96d3", + "python/sglang/srt/models/mimo_audio.py": "2530a986a818f518d258ef1353c5b436eac05a5eaa43dcd9f0097060afd33114", + "python/sglang/srt/models/mimo_mtp.py": "da82aeb473817dfea5828b65cc4c9724c9ba80aae0fc6397b11c7450cbba2a94", + "python/sglang/srt/models/mimo_v2.py": "f7a413a456e6567155b91ad479fa6ec42420f66b7dadd5449d0d45613a50a7c1", + "python/sglang/srt/models/mimo_v2_asr.py": "6527276c32b62e75af54d95f6132b600f8e0e62a4afe45c3a263fbf72ab68ca2", + "python/sglang/srt/models/mimo_v2_nextn.py": "d5ee45e7db07f2e527a2d03ea013fb8cd2a54495b330f51f0c9fb81c127df061", + "python/sglang/srt/models/mimo_vl.py": "0b365aafabc003b0a8bfc7617542e1ae7cbbc1ab2b32a13763c05fc69606f6d8", + "python/sglang/srt/models/mindspore.py": "e05c612e4f467779caf96267f2e7e07146b04fe1bc81e578758bd92911346c87", + "python/sglang/srt/models/minicpm.py": "10288c7ac6d8e762aa7fd71fd9d186d1daa804a836161242718c27b23471a6bd", + "python/sglang/srt/models/minicpm3.py": "4f0519477f7cc9aa708a040c184b6544a21c6c5a142ae3b3767ec61d6853df55", + "python/sglang/srt/models/minicpmo.py": "c47dfac0dde4b64672db7b015d4e0891686e70924259e0c4a86e68139ef56314", + "python/sglang/srt/models/minicpmv.py": "cf93d077bffac4401d7d8de57f728dabb1197537da615143777092249a23bdef", + "python/sglang/srt/models/minicpmv_vit.py": "bf539b30ce1fb139bf70c43ef0fe6bd4d96dc7104fc0004cdfd313a394f008e6", + "python/sglang/srt/models/minimax_m2.py": "dd593d37b88bce083f55a94055d4eb24a4585cf0f93f4e761749529b764e3446", + "python/sglang/srt/models/minimax_m3.py": "2cef3ef046f7e1a2786cf5874bdb2ceab83e99d2ce70b421af0ea2d3094e29d5", + "python/sglang/srt/models/minimax_m3_vl.py": "e472fabc0e06683de377debf71940c16929e1fe2e1b7e6ea74a172e14f109a3b", + "python/sglang/srt/models/minimax_vl_common.py": "3f141f6fb07081d11d7255adbcd11d5feb506cd291315501a8f1653b8de40be3", + "python/sglang/srt/models/ministral3.py": "93a77d7707c5415d24704ef83e15d6a080bbe39796715b105288ce8fcc63cbdd", + "python/sglang/srt/models/mistral.py": "21a2df76c3cb114833f521a64e8dac53986036e1eb4bdd5b65759a5100904cea", + "python/sglang/srt/models/mistral_eagle.py": "c286d3f3946dfa08537cefc3f1979ce1fc6ac4469ec6aa7eb2bcc62a67782aa4", + "python/sglang/srt/models/mistral_large_3.py": "787c57a6499ebf68e3661135e3f14350ee808eacff9e7a339fe5bcd73492e09e", + "python/sglang/srt/models/mistral_large_3_eagle.py": "172bca42aeb3f1f1399de0de9d45bb8046d64f319c407cd48eea9f91e10ac056", + "python/sglang/srt/models/mixtral.py": "96da18082e741b197a428089558b2c9454edc59bf4c8e3786ea476c7c0c04346", + "python/sglang/srt/models/mixtral_quant.py": "cd8cd32e82be078d4dc7609a7f5483180dd859a3698c5451185066c428c51f1d", + "python/sglang/srt/models/mllama.py": "3da05e06e5479fb909cd3f890063bda3dff10a4bc621da8563d842c959f09184", + "python/sglang/srt/models/mllama4.py": "a532260b2312fc894f8b7029e44e9351cbfb64a5a519a429ab98ef0a1d997c63", + "python/sglang/srt/models/moss_vl.py": "28308ce12e14186c7c49a6c3a30e420d56d85ba26f9e3672f3b31dfd7d238712", + "python/sglang/srt/models/muse_glimmer.py": "eebf558cf180de061283def5662a2b2489f6e6330f4e812e5ea47b3a183d708c", + "python/sglang/srt/models/nano_nemotron_vl.py": "8518784a2c5b2475fc125daece17864de13fc443e00923cb8ddbc227b090b1e6", + "python/sglang/srt/models/nemotron_h.py": "0510c47bac841d1da1ec3b2e7e3ff9a54dddaafa393a7a08dae9efc3c5be910b", + "python/sglang/srt/models/nemotron_h_mtp.py": "32392f28eb09ff30786bac289cc3c37aa7614455438a2bc62f78325140d96dd5", + "python/sglang/srt/models/nemotron_h_utils.py": "a7ddbf52ee14533da3a06e9f63f3bdcee2726007af615fdd22aba88143c3b510", + "python/sglang/srt/models/nemotron_nas.py": "875028f2d773fb1f7904894a2437e060238fb6e1e49723b72698da89f02d43bf", + "python/sglang/srt/models/nvila.py": "667265c922eff8080a13a5bc52aadc71754a1353588a91243721bd9e40235559", + "python/sglang/srt/models/nvila_lite.py": "1331c607d087580f1d6772a057d912b71e5dd84eceb9df2e4f41c36b804c0252", + "python/sglang/srt/models/olmo.py": "bccc66bc7985745d36ab09a7f6c0e66548687cb789fd0cdbad9547a1076d05f8", + "python/sglang/srt/models/olmo2.py": "543220ce3ac3767d8d039e44165005703cf273bb5b05436c04bd5f75aa2e50db", + "python/sglang/srt/models/olmoe.py": "0369a0f057bb8905727ecd38368e7153664f9f40bb67081734ca6deec236f521", + "python/sglang/srt/models/opt.py": "276fdc26df083a110a5b368c129731f313a641a77b8d917f928a88d5ff10d1b2", + "python/sglang/srt/models/orion.py": "60d9f622dcfb5c89346b86c2fe00e978d71b6e36b7746480c5eced5db2bf93a3", + "python/sglang/srt/models/packed_ple.py": "32a733d445fae43d5fadc85106c6a3617248e1d0be4e8b101607aef197bff6c0", + "python/sglang/srt/models/paddleocr_vl.py": "60fdb8e506dca8afe50567782baee879806d5cda0b44cb0033c5f574d99f83bf", + "python/sglang/srt/models/parakeet.py": "afa477ab4dc5fe1e82855066664db54f8fed8602ce9e7bc744c83ded57d80ab5", + "python/sglang/srt/models/persimmon.py": "a270b4ae43f763a41304c37b90af3fc651134b03af6e5feb8f24c5b9068cb8b5", + "python/sglang/srt/models/phi.py": "382592c42616624252577c2e4f75d610db2da0a446f9f1f9a76fab24505094c1", + "python/sglang/srt/models/phi3_small.py": "e2a701bdadc1747b89294cb646f2a3f080133372362ec2fdbee1b611fd9f2e02", + "python/sglang/srt/models/phi4mm.py": "f5ad75724add38c0488c6c1e73a4968393e99aa19bfa3a88cd22d6b5dcd093d4", + "python/sglang/srt/models/phi4mm_audio.py": "d0285e930a18b9d0276d8d3e272370cff8a7ccc97133c16650ba91f66c243e14", + "python/sglang/srt/models/phi4mm_utils.py": "6d6dee9f8c774870ef4a400e1d01053b6f3a14674e3de2a10692423a63650bd1", + "python/sglang/srt/models/phimoe.py": "603aa98fd79c0167db1cafb9b2c80e27375ac340325c34b721d03b3378e39b0f", + "python/sglang/srt/models/pixtral.py": "744492a3d65174ae2f0341c3542afd55c870f67b158e83c7b49fe1bb8f1a4dbb", + "python/sglang/srt/models/points_v15_chat.py": "1d5fc64602d371eb4a8740766a026bcb4d8dfdab5c588e4d3e38d010b6ab5069", + "python/sglang/srt/models/qwen.py": "7f783026bd35b5095cbc31436aa2c6775c4584c2d367e73076d864b467c0a70c", + "python/sglang/srt/models/qwen2.py": "41741eb780a3f75bc3ae4f43cc09d538b15752b1d5da34b5a96d8bca36970fdc", + "python/sglang/srt/models/qwen2_5_vl.py": "6949ad69c74dadb1d9e29cd794d13a1019ef3f1342cbd9d2946f53e6b0b19327", + "python/sglang/srt/models/qwen2_audio.py": "36fd4a320987a53035bd94c9bdc49bacf664aee884f139ed43bbd9c5215be55f", + "python/sglang/srt/models/qwen2_classification.py": "b45ecd8c713792662fcf8d6df0810a59e6fda40011fc35f82ea0678b6da7976b", + "python/sglang/srt/models/qwen2_eagle.py": "8c7f437f93e991dc33e04333a77eabd945cecf5fc6e039e64c5e188ef04add71", + "python/sglang/srt/models/qwen2_moe.py": "20467a642243f2160f34381c31468b85c60c33316e4a33b38c07be3ac53424df", + "python/sglang/srt/models/qwen2_rm.py": "e81ec356c191ea45d5db5a1eb3bbc72c29bd9599c70ed3011aa1027c70f15579", + "python/sglang/srt/models/qwen2_vl.py": "ed6c3b2039b1e8bf2e43aaf9d7dd59be224fd6022e20ff84223caaf8c0d9bd4d", + "python/sglang/srt/models/qwen3.py": "39c7c9c6b0107f12ac76cd2b6b54a0694c8540c1bb9588a380e05fcd3ee93e6b", + "python/sglang/srt/models/qwen3_5.py": "f7e52f647d8e3dd8c980ae170569585ee118c782df055b21b1e93bbc28b1f9e8", + "python/sglang/srt/models/qwen3_5_mtp.py": "f5e2440a6b16c65ea7768b38441283750692890300c39266025786f33d48f796", + "python/sglang/srt/models/qwen3_5_text.py": "b5e41ae9d90a3b0cef80a644335da66d385403bc5bd64eeb1d391a148bd3a8fc", + "python/sglang/srt/models/qwen3_asr.py": "f3b30fda98ac587f87ae4c2f414dc56ca2246867598e9c6ba3ea8a3db6076777", + "python/sglang/srt/models/qwen3_classification.py": "8eeb04172601531add9cc72c5a2ef7c5f370c443b3407fafd9af188e687aaf66", + "python/sglang/srt/models/qwen3_embedding.py": "863f53ed09e8d28e657212d9379191f9ce684c736a98f4a6d4d1b593c5cdb598", + "python/sglang/srt/models/qwen3_moe.py": "7c559324111dfdc6927e97d13e31d5ff7b23bf7efa4d4fa33d636c026212bb05", + "python/sglang/srt/models/qwen3_moe_mtp.py": "e795243b8af8bd75af56022af0be83d7b1be537d1a5659e372a34030e2339ebf", + "python/sglang/srt/models/qwen3_next.py": "a489dbe53eb6f5ad24f8b0dc04b65f1ef8a14cb4172f37de1a3df759a1f047e6", + "python/sglang/srt/models/qwen3_next_mtp.py": "143c6b62eeb23e1f2f79cb9c856540dfb40ae7f49a2695aa4698f3460cc34d8c", + "python/sglang/srt/models/qwen3_omni_moe.py": "ccb9850c1353f145ff31856b9307e9064f59024c2a7eee0a70338e986ab99a80", + "python/sglang/srt/models/qwen3_rm.py": "07a12c16cdab6a97ed7896aee9dfbfe746591816aece1ab4181ed1d5891a1166", + "python/sglang/srt/models/qwen3_vl.py": "f08159602498687df548797edc45849f84540c2a3d57bc3e1120665ccdb280cf", + "python/sglang/srt/models/qwen3_vl_moe.py": "48adc25f100392919f446ebd7e662b0d7fe7d13f85daa3b01cb694b79dd6e4c8", + "python/sglang/srt/models/qwen4_exp.py": "311375b089b05091bb1a99d95eeec238a03268381f491854322abf40e3f3328e", + "python/sglang/srt/models/qwen4_exp_mtp.py": "7597cbf46993768cee865c888fdb0ad3560f123ead707700d785f7ae0d28497c", + "python/sglang/srt/models/radio.py": "3e603a16807d9fb511e8ea463366cb685224dc0a7bd71c1bc2f8879db69e116a", + "python/sglang/srt/models/registry.py": "3c5b4e87c5943147c28cb5b68e187cdf8f8f9d880c42f1f6941fce99fe757e41", + "python/sglang/srt/models/roberta.py": "87994b2a22c88c1c5810581439159759d5ba6c9f2c90ac8558d9c4a9525706de", + "python/sglang/srt/models/sarashina2_vision.py": "b6f1f865bf94f6981caf19bfed4bab9e6af95dea34c57716607bae7080ec7a4b", + "python/sglang/srt/models/sarvam_moe.py": "d06ad53aa9283b7d2763eb9d5905f3ba7c26a0c2ea1e8ad9fb3cd7f6dd8eb267", + "python/sglang/srt/models/sdar.py": "fbec6b8ed653758a76aa75986c243267f0d7a6637a80508a7b94c0a9f963c72d", + "python/sglang/srt/models/sdar_moe.py": "07776e14b56972900c31921cc22c0e964a7c9a9af39dedb038920556ca8c45dc", + "python/sglang/srt/models/siglip.py": "722bac4d6dbe18f224a0931f5076c84aa41067adcd8211bed455f1b31d7976db", + "python/sglang/srt/models/siglip2.py": "bc81904cf0a746fc15932e73298bb6401ead827a2399924ee754013f68507c95", + "python/sglang/srt/models/solar.py": "b2ba46c5d1931bf11aeff6c31390934602be133a2defe7381ed6f69b0dd1fcca", + "python/sglang/srt/models/stablelm.py": "3b13b359144c799b2a2947906dcb199552783f91f5117d4a0ae6640060f04fdd", + "python/sglang/srt/models/starcoder2.py": "2fcaef42743aefd14ff44b8cf2ca7357aa4a69ea23e9ec9b2deb9b934ab5c461", + "python/sglang/srt/models/step3_vl.py": "a7b918d8cc89d0c1347d5553bd15738dcd0d7c79b726c2f4ecaa073bc5d486b4", + "python/sglang/srt/models/step3_vl_10b.py": "9654f28e13bb8fdafd157e603608fe4212f48c028b026cd08ccd6b90b8d22428", + "python/sglang/srt/models/step3p5.py": "dd201e0fe8eb0e833a325d37e3853eb25711ae78a8fccc71dd5a3089f5acf69c", + "python/sglang/srt/models/step3p5_mtp.py": "59403c590c52c69376f6b3b7997686f1bf60b24983cdaf8fb1cc0439f745094e", + "python/sglang/srt/models/step3p7.py": "814dff8fec4ed5e310ccfd3300a543d63f7620a6a084eed05126bd0c6cd99b42", + "python/sglang/srt/models/teleflm.py": "d5d2af97bc09d103cc8891a6c19863651a8247b2929f293db6e5bba2f953c2a5", + "python/sglang/srt/models/torch_native_llama.py": "5cb5a798c87fc2c546bb04fe9cffb0695dfe6b20ea22ab05d5340feede692248", + "python/sglang/srt/models/transformers.py": "cd06ceac5b96a81630770bf41cfd2244ca4384d6028fdc482fc0c81aa7abf3b5", + "python/sglang/srt/models/unlimited_ocr.py": "dc4605bf016db9a619353e7ae21a798571b9c565ab5652e20495ab66b1ca3e34", + "python/sglang/srt/models/utils.py": "7a05f7b446086ea6427b562b895355c1dd5b0b2b2563467d8daf11bcbfa979d1", + "python/sglang/srt/models/voxtral.py": "5a81bd2c2219aa791ac5d5a4a78c1969e9c678a3fec3282dc21fe526e026e4e3", + "python/sglang/srt/models/whisper.py": "3ca327482f0e6be78408da1b64a59018cce4f62741e713c38ddec0057232288d", + "python/sglang/srt/models/xverse.py": "f675d37ed6d32e7da68f35f6a59232082f03e173ddddd8b2942c7f06049de619", + "python/sglang/srt/models/xverse_moe.py": "f26cddaac7b663cd2b1605d1575e8f4ff0413b1ac3a1a68f460e39604f40806f", + "python/sglang/srt/models/yivl.py": "f329de6db7907d07267d44c261186801c580df2bb9022128f4a958716b0a42f5", + "python/sglang/srt/models/zaya.py": "e9aa7f2a13597df88c098267fed0fec664b4e4fb20de0d7520c785a3e4107f54", + "python/sglang/srt/multimodal/__init__.py": "1eccef4346506ea01312ea8f8cf5a37307704a53acccdca0e8c3e94c5f7e29ef", + "python/sglang/srt/multimodal/audio_from_video.py": "caaad30b5339ea5508a5a0a1ac688520b24a1d989f106a04d66d2b5cbfaebe77", + "python/sglang/srt/multimodal/cache/__init__.py": "c55ee6dd5cf2a2417cb9f8e1382fb3e6073f219398d495596e1b001970cda16f", + "python/sglang/srt/multimodal/cache/identity.py": "575e0c59c4c53f39e13e39d161a2378f5eb9e6f0c1843d7ef65c291e0c98aa8d", + "python/sglang/srt/multimodal/cache/preprocess_cache.py": "01b12a7b21c61539a3b5f62eb358e8278c8ecb5547d0f0cbe855c2290870d227", + "python/sglang/srt/multimodal/customized_mm_processor_utils.py": "288a2c31f8de0e69212ebbdf4814802959a877e4070f0a830e57a2916a7fd78c", + "python/sglang/srt/multimodal/encoder_preprocessing.py": "16ce42db23c82c43725633f58e9d462613f0b619409442ecc0ea1bd635eb7c3b", + "python/sglang/srt/multimodal/evs/README.md": "2639aff4833d067f6e109e383f9a63667cc5c118ae6eecd2cd0b5be6539b1b0e", + "python/sglang/srt/multimodal/evs/__init__.py": "d0a4e395f23d868ff513c20f7f5b76591a5232c461346cd1300c0b75130d1503", + "python/sglang/srt/multimodal/evs/evs_core.py": "a96d74c0d6d08b2d54301a2744037a9a2600c2ca0a199d32e2e69e6cd5094d18", + "python/sglang/srt/multimodal/evs/evs_module.py": "0ebd652748903794048e397310edc797779d60066dab18715146c34397632b35", + "python/sglang/srt/multimodal/evs/evs_processor.py": "aa39f0bdadc56b0bd8f20ea8a4a8408a05895ee6a4c82386025d45486622aa25", + "python/sglang/srt/multimodal/inkling/__init__.py": "2fbef5e7488f2f44f7db231f3de174a37af46d8d5d1585ac81e80052f94a8666", + "python/sglang/srt/multimodal/inkling/feature_extraction.py": "d1f14c50d2a0dddbeb2249c00b6fc1c118b05f65477a9000608d24b36939cd2e", + "python/sglang/srt/multimodal/inkling/image_processing.py": "bf11425a3eda1180ef585c0fd0b6461063c608ebe93540bac3a73273872af6bf", + "python/sglang/srt/multimodal/inkling/image_processing_rust.py": "ee81a8133042cf06d7e08b5d97bb55a3c84d7a2cf213b9a22cada27537e0b7dd", + "python/sglang/srt/multimodal/inkling/processing_inkling.py": "578be654ffe3f2ede5628e9254ed9484e028ada0294d5a9c8f692472cb66b01c", + "python/sglang/srt/multimodal/internvl_utils.py": "06fcd349896e1a3c1fd12ea0ee26801bd265e91602ff47c1c496ce226d479da5", + "python/sglang/srt/multimodal/internvl_vit_cuda_graph_runner.py": "45e7717c3e6356019761b528944e009debbbe88842364b98c74c18a26062a1e9", + "python/sglang/srt/multimodal/kimi_k3_image_processing.py": "5a87501834fd8b5189a11d8d2a6497de2a12baa47bba7775e5c3dd8bc3e2f9ca", + "python/sglang/srt/multimodal/kimi_k3_vit_cuda_graph_runner.py": "18d27ee23b87e2a06ffa1dfbfa46611a3ad414861f2d982e58d49287d4b2eb8d", + "python/sglang/srt/multimodal/media_artifacts/__init__.py": "37158f4df86b84d22c9582b631436603ccbdf94947fd8f86435588c70cb1346e", + "python/sglang/srt/multimodal/media_artifacts/base.py": "d07984b72280a6153a7e2ded8b4e392eec760485f75594fd17154bab1329d080", + "python/sglang/srt/multimodal/media_artifacts/kimi_k3.py": "196e633c6a437cc0bcf15bd4ee86316e5d0932a78d66453f7b920df494324187", + "python/sglang/srt/multimodal/mm_utils.py": "2cab2ecac1f3fcbb08377556d9480facdcc3c910f607fa3771eb6e3c6377102a", + "python/sglang/srt/multimodal/processors/base_processor.py": "1e5052235b0b76840949a597e2f2816e5dc296cbff45cdc218fdd9a3dfbdca9f", + "python/sglang/srt/multimodal/processors/clip.py": "9290a6464e0e36f48a868c6ea058cc85212b311edaad7b0ff0ba6aea59411a54", + "python/sglang/srt/multimodal/processors/cohere2_vision.py": "fe3863384d7e07e1bab7c78aadd927214013f28ceb288a2747b7acd77b35a6a3", + "python/sglang/srt/multimodal/processors/deepseek_ocr.py": "8acaac872069693f27de4dc84cab401673cc9276933acc1c106cffdd7960a358", + "python/sglang/srt/multimodal/processors/deepseek_vl_v2.py": "be8670c2929978d6f6c004fa46bcfb8f454dc2cd54124472289a9822ab6757a3", + "python/sglang/srt/multimodal/processors/dots_vlm.py": "faf20b27d660c150a785e861791b5047ffb232c2f977f871a75186234724632f", + "python/sglang/srt/multimodal/processors/ernie45_vl.py": "45086c502a488dc4ba3a3db9ba106d231dbd09a2cb31df902d5ce8a5d6620bbb", + "python/sglang/srt/multimodal/processors/executor.py": "b69d19801ea61a36f6359e3e4f5464d9eaa1de825368a2c1aaa36005098f63b2", + "python/sglang/srt/multimodal/processors/gemma3.py": "1c1bd5774eb7bb741013a1efa8eb994d2d8cd7c51382d87a6168e78e61ce1a1c", + "python/sglang/srt/multimodal/processors/gemma3n.py": "005baf0e4d790266376a59115a5512f8d6feb44c2feeaa403ceca62cef3e0852", + "python/sglang/srt/multimodal/processors/gemma4.py": "a3d8b0db8b7f34fcd0c42839b9c7d3ff38f439d702898542ff5c80c12a57cbed", + "python/sglang/srt/multimodal/processors/gemma4_unified.py": "0a4364a71bbacba534b89a390f41b1e3d07fd5096f57d2d192767d24e81cf4b4", + "python/sglang/srt/multimodal/processors/glm4v.py": "8b4198d2ec3de68e009db6d228d29064aacb8c782ade406225ce4f7f48f3e922", + "python/sglang/srt/multimodal/processors/glm_image.py": "fea5e9f805a25a77250bfebf2b5b0dde8458cfc986cb5ac39656fe4b72f751e4", + "python/sglang/srt/multimodal/processors/glmasr.py": "e08396780d66db0e8ce826b52f82d4f44029901c7d2ebb6bb19bad7ae4d4f8c2", + "python/sglang/srt/multimodal/processors/inkling.py": "d23c1d67fbd643d5be2390c2a1340a1d21bb64d3c3624b061ef8f01fda041fd2", + "python/sglang/srt/multimodal/processors/interns1pro.py": "018ff87350f60de410e7516a5e4b5895cdfab3547c2c6341a3f60070b76bf117", + "python/sglang/srt/multimodal/processors/internvl.py": "d28fd661ea772c46e9a735b2da3ee2363acddaa16bae989af3b821e066604cbd", + "python/sglang/srt/multimodal/processors/janus_pro.py": "427ac76c5f98fe58d1fce72b91b7ea63fd46a4ec7dcf4fc5c49e96bb643375cd", + "python/sglang/srt/multimodal/processors/kimi_common.py": "671ac50154f5e46bb32b2af758481bd3dba6fdaf8768510e35b2b1472cba4abc", + "python/sglang/srt/multimodal/processors/kimi_k25.py": "80b1805dcd7311f376922b01543e3dac45aa95050332cf21d08aa38e00fa777b", + "python/sglang/srt/multimodal/processors/kimi_k3.py": "94a6352f64cb68db103e750c57652b57b44c5d1cf2ea6e54c9f925c7d604b461", + "python/sglang/srt/multimodal/processors/kimi_vl.py": "1c61a58362af452cfff36347ff20c043c315f8bb3e0696255a87e1824c237766", + "python/sglang/srt/multimodal/processors/lfm2_vl.py": "dbc8bc147d77162b79daf4d0e722fe8e0bb3b208517a82439fbfcfc0232aea87", + "python/sglang/srt/multimodal/processors/lightonocr.py": "d0ef1de2d85ff3e6b982aa333dc8f3c7859853e4b13aafde972a0aeaf06882d3", + "python/sglang/srt/multimodal/processors/llava.py": "a1f37f13d7867077eeae165f6a4e3c7ee1b8b146fda871d857bcb3e517a7e541", + "python/sglang/srt/multimodal/processors/locate_anything.py": "4e721b8f8ccceef8be8aefe067568a988cd2a5efe7625975c8ce97aa3cbf8a39", + "python/sglang/srt/multimodal/processors/midashenglm.py": "80c4f6a6404a15816d43a177cf9abab6a864b61df01a2f91af7649b97f366a03", + "python/sglang/srt/multimodal/processors/mimo_audio.py": "2c2c5249581bd1a8d61c428f5612312eb7764e3eb8925f9af12a94c4d332eb9d", + "python/sglang/srt/multimodal/processors/mimo_v2.py": "6fa9682bae6abfb488cf4054b73c76f7d8274e0a3c363c88b79b17548a9524c1", + "python/sglang/srt/multimodal/processors/mimo_v2_asr.py": "927de6b375b1d0c8bf219eeacff1e90611e2811dd52643bc78ccda66b519e694", + "python/sglang/srt/multimodal/processors/minicpm.py": "e3214d38661e8eca56ddbe1e8716f4df2ea3505102d1e7c50f955dcd9bebc7ee", + "python/sglang/srt/multimodal/processors/minicpmv4_6.py": "cc482bbf6f04f75df155c8be405cea46f6fd0cd180f2337f5f282b7d5556d64c", + "python/sglang/srt/multimodal/processors/minimax_m3_vl.py": "60f3ec8ac933e4b71b32e29d181b5877efc3f1ea40bba241aa89479ad55baf5e", + "python/sglang/srt/multimodal/processors/mlama.py": "81ff37009499cc6bfbb3c2cf0ba5509ae15793df2ca4eb36e8183d31dff1936d", + "python/sglang/srt/multimodal/processors/mllama4.py": "4e80dbbe14923a3c35a6283da2224b7bac2f347a8066a899b7feae00c621b90d", + "python/sglang/srt/multimodal/processors/moss_vl.py": "f8f23bbd42433e03ff09cded52a91854ac6a12d753ee26febb4074f56360e717", + "python/sglang/srt/multimodal/processors/muse_glimmer.py": "81b4333f5a2eed02b0f2d08e13271d26601136c2d8fed87c706a9f50e6f2c183", + "python/sglang/srt/multimodal/processors/nano_nemotron_vl.py": "8d45178821fde4e89a3c806d7a51eb0d892f030266b76b9fb88f66d5c44faad3", + "python/sglang/srt/multimodal/processors/nvila.py": "3c547888a565af32a07930baf58d1011743daa42fcdd51aac93fc935279db9e4", + "python/sglang/srt/multimodal/processors/paddleocr_vlm.py": "247c86f9477bf3f1ec508420f6e83db94eeeef43e9382d77094b854782921d0b", + "python/sglang/srt/multimodal/processors/phi4mm.py": "21ff671e86b65be4dfbc773fcc361155489994fc9b6d5dbcd4d879c19cdaab70", + "python/sglang/srt/multimodal/processors/pixtral.py": "f243baa66854711bd4a31362948f04d2870356ee0fd8c3ef03a053c8f8222443", + "python/sglang/srt/multimodal/processors/points_v15_chat.py": "d52953daf4f65f65ecc9456b90b9d096268f7eed1410b95d3f5ca47e160734bd", + "python/sglang/srt/multimodal/processors/qwen3_asr.py": "c7417cf0d8630965cdf2205f7a3d9640dd46fee3973a4f232110dc23c5b25db8", + "python/sglang/srt/multimodal/processors/qwen_audio.py": "4eebd82bf5a87ca604944f666905a0d22a4ac04875d7c9c57cd066833d2006b9", + "python/sglang/srt/multimodal/processors/qwen_vl.py": "7b4dc28f8aef74f8a8a26516d639b0abf4ae91ce5c5f1c863edf996868283035", + "python/sglang/srt/multimodal/processors/sarashina2_vision.py": "592770bfec1a2896be592e83e4d811a35b2bfe9ae419c91902231bb9dd374246", + "python/sglang/srt/multimodal/processors/step3_vl.py": "57f60588ace2767af58024d2fe6c3bf2502abc951570922b27651ac8207381a1", + "python/sglang/srt/multimodal/processors/transformers_auto.py": "843de5bd0abfabf30baa126613890bfdb3d383933e082ddf1d9a792b42a10bc6", + "python/sglang/srt/multimodal/processors/unlimited_ocr.py": "b612e75e69d269b0d4b75625180d89171cc9455e58d3ab9e066e77fa8c175519", + "python/sglang/srt/multimodal/processors/voxtral.py": "cc3d1f6a27a05fbd9724b02bfb89c42e3906e1fb5d663a1125c71ba4f24e8b29", + "python/sglang/srt/multimodal/processors/whisper.py": "6983b089e81e3bd685b8db376e5a4fb061ed26fc73fb4294fea55db834feb445", + "python/sglang/srt/multimodal/transport/__init__.py": "f5c373399f116778c70f2da906f7685469fd13099b83e5208025f81aa3808dbb", + "python/sglang/srt/multimodal/transport/cuda_ipc.py": "03bc109511d08628ab15ef13f78967dd463d1784d45ba98e088f5b7a5b97cb95", + "python/sglang/srt/multimodal/transport/memory_pool.py": "69cc93717a553d4e0201d3ca086c27d58ecd28236e320b6db234901bdd765852", + "python/sglang/srt/multimodal/vit_cuda_graph_runner.py": "27d0131857e172992afadec1672888bb7d4b48befc3e6c10c4bbf38ed0f37d33", + "python/sglang/srt/multiplex/multiplexing_mixin.py": "a4b50c50a4c0b7b5cae39e9f5f0a6f36e6fe57ae6bc68e4518bcf1fd0ed0d51e", + "python/sglang/srt/multiplex/pdmux_context.py": "b4e6ff1aa10a19f9cdd285088424b9388574fd291edfd466e155cbaa8e876b9e", + "python/sglang/srt/observability/cpu_monitor.py": "61ee5b561c432abe4e3a86dd0a09715c82d79dbab7781e0568615bf34d65aec1", + "python/sglang/srt/observability/forward_pass_metrics.py": "197783e4f501a3651a0bfe376eda29f35cd4a7bf18b6e7b9eebf094ff285f5da", + "python/sglang/srt/observability/func_timer.py": "5bac9017a6dbc69468d3a9706bb91e5901d1a1b788e8b2ab2d836f8a8fccd179", + "python/sglang/srt/observability/label_transform.py": "3be373d06e95723d5a31486c3866fc32467bf25f0bba59d86f35c685770e05e5", + "python/sglang/srt/observability/metrics_collector.py": "9b2469b149e58d6e427dfafe82af073e61e04c825ff7d2b5dec138fd77b5c134", + "python/sglang/srt/observability/mooncake_trace.py": "1538cab22cf2573f93e1559132746508377aa8832029f9ba9fda7a565fe39385", + "python/sglang/srt/observability/ray_wrappers.py": "c04b308075ebe1637cdd514181a4e0da96e7c5b602f5a62e41d6612f570a2864", + "python/sglang/srt/observability/req_time_stats.py": "3a32af2aafbb95366a12aa6b01fa8d0c1b973f0188019ea623c69c7d285ed46f", + "python/sglang/srt/observability/request_metrics_exporter.py": "7ca23d47a1ba8ca0eed97f15354ffdd1a10cc93341588b78cc3dd74d07dc61fa", + "python/sglang/srt/observability/startup_func_log_and_timer.py": "3d1560dd9d9de4604c1627d95d1f9587319c9fd9e629392a114e3554929999a2", + "python/sglang/srt/observability/startup_time.py": "930118e13fd1ceeaf4dd78a31533eff4a474bf63bd5e53a7958933431d49e87a", + "python/sglang/srt/observability/trace.py": "c28d12b5dcfb88bfa488886c78740e6bef39047c146684a916f2889b4b859796", + "python/sglang/srt/observability/trace_async.py": "1208ed781ed1b00c9bdadd382fc99999ecd35d69131a23d3b71af406947893c3", + "python/sglang/srt/observability/utils.py": "797ed7c3ab8785bc0d8b783bbdd70420a3363a9fb473e7a6642583fb8ea16680", + "python/sglang/srt/parser/code_completion_parser.py": "22b62a8c0ead66e61f16dcdb10e1887cd3168c67318337e1e09d30f893f27457", + "python/sglang/srt/parser/conversation.py": "21b48ce77bc36f84ae30685686f53d7acfbc97a1dd5e4176da5f505665229df5", + "python/sglang/srt/parser/harmony_parser.py": "630786e1acd69b98e6cd819a00711749a391a6059cb4fa5219093f8e9e47f821", + "python/sglang/srt/parser/inkling_renderer.py": "257424c8f88a90e281b5db0427ffff3bf32aedb6f1ee4efef55d2a26abaacfa9", + "python/sglang/srt/parser/inkling_tokenizer.py": "8c3a9f8d0c05434a44902155da14bc1bd54ce22837fb7b7bc3848f2da3067120", + "python/sglang/srt/parser/jinja_template_utils.py": "27759425d3b5856095de117e1c431645d4e61e548cec3517be8f237cf0de65be", + "python/sglang/srt/parser/reasoning_parser.py": "42e798ba0ce6db8db876c576f45e40787194b15251829f2879f311e5f9427ce2", + "python/sglang/srt/parser/template_detection.py": "b81f86f61ea56619bca67ad1c37d9dc84f5a6369f36e3365f0ac135b064e9a86", + "python/sglang/srt/parser/template_manager.py": "2c7de852332f68d9ca5e535f42633372aa86e5bd69406ec8a102f43b17855b32", + "python/sglang/srt/platforms/__init__.py": "2430f325fb54aa6a1265c64149e01929140e841f450f52536b344fa1c51a7ffe", + "python/sglang/srt/platforms/cpu.py": "3e3282b95d4d817bde3a4194f2189b15b6ff4523e92c1c64e14d4fb24631d84e", + "python/sglang/srt/platforms/cuda.py": "fa43e9386319d9f410cc9a9eae4af804df949eaa1d6bcde98b184f7912e32845", + "python/sglang/srt/platforms/device_mixin.py": "1956853a6cb6ff390d525d6b4e13141d7fb04360f1257ba858744fb911b64238", + "python/sglang/srt/platforms/interface.py": "9612ea0d8a40bddc7b4f36c6965352b5d76e051638b07f2551a4f703f8681a33", + "python/sglang/srt/platforms/rocm.py": "36dd7d7330e72c2dad9666c1cef97cfd92eb38545e537184cec598b5a7b90831", + "python/sglang/srt/platforms/xpu.py": "dabb92273bc96592db184ee5e3a11094b228b293b71f8b99739d6ee4d357f636", + "python/sglang/srt/plugins/__init__.py": "3a975a73f1a7887e68c81ea7a2530250597ac8ae978efc0b0f70f038a99a3164", + "python/sglang/srt/plugins/hook_registry.py": "fe214acac324cb2f019aa1dffe1ddcb6e4691862fdd1b6a0ad5033d8167e31e9", + "python/sglang/srt/ray/__init__.py": "36fc3f0c2bb9d10de55553dc6c8e67fa2ca3e3ee4984998b1201750581b4666d", + "python/sglang/srt/ray/data_parallel_controller.py": "c510f5d6bef02376d2e6f9069f25d4c6bb704235a04f073e5206ca356bc3f301", + "python/sglang/srt/ray/engine.py": "d324c2fdfb693b3f2e5628e874ad734e20ba8bd5c5b2c8555376c7c6b9c42eda", + "python/sglang/srt/ray/http_server.py": "616b9eadc53220fc2afef31af5de5891f83f3a11ad557f210a402a3153933b95", + "python/sglang/srt/ray/scheduler_actor.py": "14c1e413098f3d808c21e81082fca3fc5f2cf210c0a2c71d6eaa801eca73c4c8", + "python/sglang/srt/runtime_context.py": "f2ddc424afdf1d3710958c553586954fc3e4399919c4473c442a865c0252545d", + "python/sglang/srt/rust_extensions/__init__.py": "0add2045c132d39d0ef7eebb016156c708223ddee6f2eb6fe514f762e8237606", + "python/sglang/srt/rust_extensions/_grpc.cpython-312-x86_64-linux-gnu.so": "1f444161d000dc5c33629181d6ce0cb0993cf4471147501e8d84d78f94c2bfbe", + "python/sglang/srt/rust_extensions/_multimodal.cpython-312-x86_64-linux-gnu.so": "db9e82757193be696867d27e1549ed072f032d3b582028b135316f0d9363d4a6", + "python/sglang/srt/rust_extensions/_server.cpython-312-x86_64-linux-gnu.so": "d7d796f29c6336a69f3e7b544f2fb02583d66350a167a9c19e610c71b374dce0", + "python/sglang/srt/rust_extensions/loader.py": "0a6408b69ba1f9107eb92f207d3949672480c5fc80ce7e7c90c0752bfed0a642", + "python/sglang/srt/sampling/custom_logit_processor.py": "e0e0ab65e2ded8975a9d161a52c92cb61f2a8a02a6af485b37912cad1171e23d", + "python/sglang/srt/sampling/penaltylib/__init__.py": "75ad2cf0aabb156ec1aecffdeb906058f2fbf5669d258fefc420e50a27b0c7ba", + "python/sglang/srt/sampling/penaltylib/frequency_penalty.py": "1f17d9124d963bdc428016f856a1715743b3d803cf55de2e8fad41550e5d8a61", + "python/sglang/srt/sampling/penaltylib/min_new_tokens.py": "96e372550b022ba0bbba853f3c95966e2f0d3b7b799ac0f4082df58198befe97", + "python/sglang/srt/sampling/penaltylib/orchestrator.py": "829be20bdfad1d6f92c9eb830f320602a92203ebbf692c7d92a325bfdc0dd2a9", + "python/sglang/srt/sampling/penaltylib/presence_penalty.py": "f9f5d234903c1084b49905521b8e0ce9cc35a22d1c3e4c047c0cb4d189c291d7", + "python/sglang/srt/sampling/penaltylib/repetition_penalty.py": "4f5948005615eacae25ae3f606699d1322e376a3bd4d2f54dc422be6a73bf157", + "python/sglang/srt/sampling/sampling_batch_info.py": "05f88297e6ca48aa187d0585dcd212c89b2918f61e1020879cd4537bc9768889", + "python/sglang/srt/sampling/sampling_params.py": "9437125033cd7abe001689cef162ba558454fb455f577e7b36b4eaa4d3f95c24", + "python/sglang/srt/server_args.py": "557d26f31c473e0cd382efce9ed2bfe8702b5ad0adc750da1250df13bb3231ef", + "python/sglang/srt/server_args_config_parser.py": "3966b1206230239aa81def9fd0008d0eab68e5ce11b7bc39f369f5570287a1e6", + "python/sglang/srt/session/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/session/session_controller.py": "ceb4398ecf4fb24c10d8256797aca06db1c353dfa2acd9577e46f01ea1093ccb", + "python/sglang/srt/session/streaming_session.py": "1243ecf5ef521d9a9e9d9bea1bddd519400826a3fe16e5073cd3cb95f5acadb3", + "python/sglang/srt/speculative/adaptive_runtime_state.py": "d4e0b6bb5a3f83f6b6eaf298e08424816ef463b5f0a7a0406fa066cfd3122496", + "python/sglang/srt/speculative/adaptive_spec_params.py": "ccf74d364972786f4debc95f8da1315313b904f5ae9389c4ed1570642dcf4de7", + "python/sglang/srt/speculative/base_spec_worker.py": "214eb3b4e19ca39438d010066cc21b15c083b656a75a5322a7b0c9ef7dc87745", + "python/sglang/srt/speculative/cpp_ngram/.clang-format": "1df5c7d8812e21f15b1bebf09f61e40fcd3887678496a4f8005e9742bd55730d", + "python/sglang/srt/speculative/cpp_ngram/external_corpus.py": "1de174578c7791bec10666f1ed8df525f1f95125f25bc0a78e81e5e54dd229d2", + "python/sglang/srt/speculative/cpp_ngram/ngram_corpus.py": "bb3fef5b318f74bb8bde9eb8917ea01c222739c017bd2509bf2ecb7621cff605", + "python/sglang/srt/speculative/decoupled_spec_io.py": "e4e0951b45d720538c26784b9dd05817f0a9e76d748cecb3efdf9a6d1acbdff5", + "python/sglang/srt/speculative/dflash_info.py": "8b11954327d01955478d97cf36c514f39ca9457d37941a2be561d03a27391a1a", + "python/sglang/srt/speculative/dflash_info_v2.py": "2cc95adae184717c208e9c7f42ae5a08e81c9d4b94c907a020d5cc249c05b1fc", + "python/sglang/srt/speculative/dflash_utils.py": "a508ee114d939aa235e405e21d8b40bf3112f4534c1e3c34f7e591fbd5ed5f04", + "python/sglang/srt/speculative/dflash_worker_v2.py": "99a606e7b5e16747237a7278ef8af74317ddd28a7d08a6030fc1e34ac9e2e575", + "python/sglang/srt/speculative/draft_utils.py": "0f9981d20765169518c5031d92de81830ebfbed8256a1ad82c7f8edfb6bc7284", + "python/sglang/srt/speculative/draft_worker_common.py": "72256f9cf886248e1414339b8288340ebfdb86ab458afc13b439a42ba2dffdba", + "python/sglang/srt/speculative/dspark_components/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/speculative/dspark_components/dspark_block_accept_estimator.py": "cb475d64d5d10329ba4aca51a64ab9ff925e17dd573ca42d13be139f3be2004c", + "python/sglang/srt/speculative/dspark_components/dspark_config.py": "a4aa2d41bd4144024afadbc720ed712f24ec34b6b95732bd5e43abe3f0d8ea7c", + "python/sglang/srt/speculative/dspark_components/dspark_draft.py": "0c3dd5e26135d59f2eb9a94aa92d80da51ece28d95d9f80b2c6e9b2171a70200", + "python/sglang/srt/speculative/dspark_components/dspark_draft_sampler.py": "d00aa4a01c85b2f09b30582ddf94c3447cf3e213be3cc979d73c52ad9d5cdd32", + "python/sglang/srt/speculative/dspark_components/dspark_kv_inject.py": "74a8ea9e90211b45fa24ad5a0d28c116839a87c59644de42e3636b6e665dae95", + "python/sglang/srt/speculative/dspark_components/dspark_observability.py": "19d885307d7eb8c5c686a4e568f8a4817f8aa7128ea7e0febf6032c35517833d", + "python/sglang/srt/speculative/dspark_components/dspark_planner.py": "2986adb17dccd7ff35c0374b10ca9c3ec5829d77711d30cd364d3371e4e64443", + "python/sglang/srt/speculative/dspark_components/dspark_sps.py": "c87a7f72ad1299cbb9bb337e0ffc3bb34de2c02624e423c717c41fc41c73ee08", + "python/sglang/srt/speculative/dspark_components/dspark_sts.py": "49b0ebd5fdee14dcbb527b24d6d682d8c9e27de769e87552cbed1bc7942bd06a", + "python/sglang/srt/speculative/dspark_components/dspark_verify.py": "9f98e504eea440ab12e0f81b8301d3489992311dc65981018fc6dedabe9f604b", + "python/sglang/srt/speculative/dspark_components/dspark_worker_v2.py": "f2aceff3a360d25f55df5b87ec77d503b3aacad2bd479235a2ffd15e2fdf3425", + "python/sglang/srt/speculative/dspark_disaggregation.py": "b93b797dd537696f957fdb8fcc2ab66435d184906871beb0ce8fb2a71f31f840", + "python/sglang/srt/speculative/eagle_disaggregation.py": "8b035325c40b2c6a430df2824f6b2f4e181ba6f1556922c59c7e4ee4b47b18c4", + "python/sglang/srt/speculative/eagle_draft_cuda_graph_runner.py": "9cafd331bebca55e67d4156d3da698fe0e728e22d48fea57b2cf1babcb9e6376", + "python/sglang/srt/speculative/eagle_draft_extend_cuda_graph_runner.py": "437d3d7090ae8f5fa0f84dbb61de071b64afa65fd088be8844e542aca3649dbe", + "python/sglang/srt/speculative/eagle_info.py": "a4f2f663db7e26dcbdf4b8b08788492f04d7c6f26546a7abadfce739b9854638", + "python/sglang/srt/speculative/eagle_utils.py": "87e9dc749e94f5899140457393389397840a2258978c021fd3ac490e9da4c053", + "python/sglang/srt/speculative/eagle_worker_common.py": "7d5bc17da41ad34230dfd76da34024496983eae5453f8b1c650a9f5f924e4934", + "python/sglang/srt/speculative/eagle_worker_v2.py": "9a66d31868385646b9fb9f78053730f55d2e885e72382a8c8dc6db9f07709271", + "python/sglang/srt/speculative/external_corpus_manager.py": "6ba215fd34397ab487aa7331ae8fb157a7a084b83fe6554eddf9468a302a5287", + "python/sglang/srt/speculative/frozen_kv_mtp_cuda_graph_runner.py": "bf74eac380ab19726f34c0d568dd6aa61ad5535da759390de3f05906e8acd01c", + "python/sglang/srt/speculative/frozen_kv_mtp_info.py": "5e5b944d39a2eac1836c9bf835c5fb588ba729d1af5a77fcea52d5367f8c267c", + "python/sglang/srt/speculative/frozen_kv_mtp_utils.py": "ef46e173c4deefc85efc74b436a381479b6dfb73648fc62a6c5630604c7f8bf6", + "python/sglang/srt/speculative/frozen_kv_mtp_worker_v2.py": "f98aebcfe52c72d0becedebbf5d36596aa40b22f82bcdec2157f0599042c02f9", + "python/sglang/srt/speculative/multi_layer_eagle_draft_extend_cuda_graph_runner.py": "1ace015e04fa6706170b16967e7b7f8850397aaed481f1595bb9e8e522479515", + "python/sglang/srt/speculative/multi_layer_eagle_utils.py": "b3236abbb4b52d39fc6ff3a111ce1aad7d2f1f4d7a064271150b73a08a41f264", + "python/sglang/srt/speculative/multi_layer_eagle_worker_v2.py": "ade61a47a47d58add7884305940281ca42dd2fdbadec219d5d14d46c64a0b640", + "python/sglang/srt/speculative/ngram_info.py": "4b8886e17ca55bba9b6706ae025eed45fae307cf42a5e98e26a08c0b7313e25d", + "python/sglang/srt/speculative/ngram_worker.py": "c042a1611193b977cb9e21297589facc57bc026600e57a7abcb4d483df860172", + "python/sglang/srt/speculative/ragged_verify.py": "5226da18ce2fd3e21ef32863ee4971f70c8c82ac6b6369d58b87f1eeca1ddded", + "python/sglang/srt/speculative/spec_info.py": "f5b9ae4b4612fdb816985c54740b5791cc8cfc096389777b6fbcc2194a63b568", + "python/sglang/srt/speculative/spec_registry.py": "1242e3fa12bd64cd3aa88efeed2cb8db2962a948c2eec047d4ba423f2b7096cd", + "python/sglang/srt/speculative/spec_utils.py": "09c51c9462b99b55f588a0adc16dda2673d64b5bed8c3dcf68e15cefced98473", + "python/sglang/srt/speculative/standalone_worker_v2.py": "1f8ee2c3e6f3d071901f9774c0a90e60acad2742682d55c4fe74b1723b35465e", + "python/sglang/srt/state_capturer/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/state_capturer/base.py": "b3dde776672ba7ac6f79ea1afcd4d482c04b3544a7e29cd05fac2aeed2ef0798", + "python/sglang/srt/state_capturer/indexer_topk.py": "5f4d0275cc07720fd62365d18c403a9a0d0aefba4cd0f41a87718ebbe98d1f79", + "python/sglang/srt/state_capturer/routed_experts.py": "08da734ff1b792236663b62833a0f33fa096de48ede12326d70a593e518c5e47", + "python/sglang/srt/tokenizer/tiktoken_tokenizer.py": "6a2147ecc62b0860780ba9ccacc55ef0a93f50a282fdacf0c5661b4fac15ef8b", + "python/sglang/srt/utils/__init__.py": "ceea07a199caadc8b0172d756baa7951af26614ebb41423fd3d2f449f123a5ea", + "python/sglang/srt/utils/aio_rwlock.py": "db32ca27e0d7ca53859a17c65464dddef6420f8dd971d9659f7671ce9f88cf6c", + "python/sglang/srt/utils/aiter.py": "83a040078acd0bf41fc4e4e89e4d39e698b5cda00bf0d44897e4810c47a87425", + "python/sglang/srt/utils/async_probe.py": "fe654a2186fdb6c2974425b4946fdc82dc53194fc19339eb87cd3ab4b895d417", + "python/sglang/srt/utils/auth.py": "016734a0263cbc2bd6657481ab11535f1cac073efb7eed4bcdbf66f81dfd3ef7", + "python/sglang/srt/utils/bench_utils.py": "323c12e868d0fd850b5d33f07322b3244c8ce6f0db18f96a3d423d4731dccfb3", + "python/sglang/srt/utils/common.py": "daa9e93e9d4aee0990560eeec60ac236757112613f7dd17b805d641c2d947072", + "python/sglang/srt/utils/cuda_ipc_transport_utils.py": "2c6a043be16879ec351ae1e803c303413315eee61125d1af1391736c182d1348", + "python/sglang/srt/utils/cuda_vmm_transport_utils.py": "a2322085fde9e9183cbbd73cae5c78eeffadd09dd846aacb83284924e49fa4ef", + "python/sglang/srt/utils/cudacore_pyspy_dump_utils.py": "5ed36362bf994a75c0f23db2a40d58a9df3ff8c731853d4c8c5823f43812c427", + "python/sglang/srt/utils/custom_op.py": "ffe4447fe63be8cc9abb47d8e277ba128e7d3d2368b05378529845caccb8f135", + "python/sglang/srt/utils/device_timer.py": "e9fea4957d945e67a1e6eef31edb9ea6a178558aff721b55bdbf32a01549b2d8", + "python/sglang/srt/utils/field_validators.py": "98ebb92fbcdbdaaac5733e10eb2cbe3cc74f370092003c8f62beba3ba46b01a5", + "python/sglang/srt/utils/flatten.py": "3a62ae210a13ca536b1f5381c4de0a7f631dbedccfc8c57f4e7d86360f7baa77", + "python/sglang/srt/utils/gauge_histogram.py": "8ab119aaf7e1c5ae497948ac51d6656e5676e4659edd410c5e940b5ed68e21db", + "python/sglang/srt/utils/hf_transformers/__init__.py": "bd270b1977cdd6e52932b7d06397f925f30887713b490357e550b52e2c9478b0", + "python/sglang/srt/utils/hf_transformers/common.py": "b65aeed19332be514a0af226d7c3c002dc20e411d2fe04f58e480bc358325738", + "python/sglang/srt/utils/hf_transformers/config.py": "c87fa91cdc8dd7e0fcd6093c751d4a5a24bfb2e895480d8b83f2b109bb92265f", + "python/sglang/srt/utils/hf_transformers/gguf_native.py": "67a1976c796179a9da0e071b14de52c7d5ec3d2fa37437152662d3a7e2cf0c0a", + "python/sglang/srt/utils/hf_transformers/mistral_utils.py": "27b383c40e9e07abb1ee60c6d080eb18f0dab8b6770b5ee9f32d1de255b83932", + "python/sglang/srt/utils/hf_transformers/processor.py": "975f78a291e9a3dc12c2848789d088b5298b419e9eab8b53d0dde3b233322ad5", + "python/sglang/srt/utils/hf_transformers/tokenizer.py": "1150719b60247ea837f4a4035688462625c55c003eca487c2f56a0afa0884e6a", + "python/sglang/srt/utils/hf_transformers_patches.py": "75656fa6d4eae5f57b9be09a153178f319cf0be78843f721ea15f3b1157282a4", + "python/sglang/srt/utils/hf_transformers_utils.py": "7936a23e92f552e8c854af19134a8e19d512998cf8d1c897fe56b30af6751f78", + "python/sglang/srt/utils/host_shared_memory.py": "d2d3b7a8c95b98422cd755ef748ec107402d1f8679866f6f584904c9abb8be53", + "python/sglang/srt/utils/http_middleware_patch.py": "8aea067707a600bf8c38b1778c6468c480e4b9890b53110f4f2a171e8b20ed6b", + "python/sglang/srt/utils/invariants.py": "05a8c4a2a7b5aa57e9099c177000b026b84f3916f2c3f0fec51ed0aefdb5d928", + "python/sglang/srt/utils/json_response.py": "779bbfd1a53433fd3f82cb5eb73839c7178b42c53a5fc393f13670d53cf77cb6", + "python/sglang/srt/utils/log_utils.py": "aa0c540a2c171c54412ab07655705fd057feeef9c45e67b0fc5f30dcedb066f7", + "python/sglang/srt/utils/model_file_verifier.py": "1ea58843dbf5d688ac870d79d8c9e1abbd5a4da6292b291793d1c148e41c42b7", + "python/sglang/srt/utils/msgspec_utils.py": "488b2a3fd0bb582d6a89c7fee668a0fc0731b8447b013b6998cd510f0dc2f1ff", + "python/sglang/srt/utils/multi_stream_utils.py": "bc0c190113d146dcdcd4d977b3c450955b62ba1a03cdb018b1584d6f2f06172f", + "python/sglang/srt/utils/network.py": "e5fa85f769b8d4cdfaddebf8944e4a1bdb92f11a8e2cdf62d2af58ba56906ae1", + "python/sglang/srt/utils/numa_utils.py": "33dbebb26f5fe420b31eda14a7f041d52fa9fb4469df7f727a42f57f08fe9f01", + "python/sglang/srt/utils/nvjpeg_decoder.py": "54b918dd2d892877dfabd7f5ef6e902eb8181e1967121597bf4b89bf2f1d1791", + "python/sglang/srt/utils/nvtx_pytorch_hooks.py": "ba2bfbfb3d6c0c4bb1a9886b2bcf846c27fc79fb1da6ae4f1607da1a07875152", + "python/sglang/srt/utils/nvtx_utils.py": "c97d6b542d463f37b54c6e983b0d6ac40ca57f0402b17584ea35103339fd5775", + "python/sglang/srt/utils/offloader.py": "1d89240584d56990174e22f31f1dd89d8585075607e14f6491a943dbd44aabed", + "python/sglang/srt/utils/patch_tokenizer.py": "97ea6b88e3a53d620b145cdff4ca2f6c217b390898fd122154813474290f02cc", + "python/sglang/srt/utils/patch_torch.py": "642b5369a7e0d09e8976e7b118bfedc574d43046170be5beff2a270834309c71", + "python/sglang/srt/utils/phase_checker.py": "0cf1b7fe0dc1145a65b88cad304a190e43f5f06767b0bb5fa13b879da275468b", + "python/sglang/srt/utils/poll_based_barrier.py": "f6f8e7df644e952b9e124ec4b998d6294aeb2fb5d547d289b125658864d807fe", + "python/sglang/srt/utils/profile_merger.py": "6ef9f3fb21cc6fbcc713506fd3d24a802818658d67e21fd42bb5b3db03409aba", + "python/sglang/srt/utils/profile_utils.py": "6ad8067398af3bf3314c375e0bb4a6703e2270043cd455cb531467f96a04eaae", + "python/sglang/srt/utils/request_logger.py": "ef9551a9b941102c59a8f4959bea2a2385898561a732728b6c846e4b6e0b5778", + "python/sglang/srt/utils/rpd_utils.py": "051f87f26cecf4a603a7c72b7c87b3a5de9510d16514b20edb316aa7f193e5c9", + "python/sglang/srt/utils/runai_utils.py": "fa0f6349a489b86ff61b7ab976ee583616e8e65b60b12cbe540b719d2522a2c8", + "python/sglang/srt/utils/scheduler_status_logger.py": "c3c31b7ad76a8041f2dd790b06cc458c621dee70cc9598e264825d236a36a071", + "python/sglang/srt/utils/slow_rank_detector.py": "f35f8a5e9df7c1ebe4e231b642e4e1b1cd7b7cb76675e328bb1c157d25ec7227", + "python/sglang/srt/utils/stale_shm_cleanup.py": "7a9047c6108ac87db752d947ec632d00f5be433b9b51cbf57178959a4b2c1896", + "python/sglang/srt/utils/tensor_bridge.py": "e2928916f851d0ea70110753a6d385c40bf9b3e904e1787aad4d65d3efc9fd14", + "python/sglang/srt/utils/token_sequence_matcher.py": "392c9c96d5832a1c1ea1b05b30cc4a0cd94151f919d30cf589e75fd858c386c9", + "python/sglang/srt/utils/torch_memory_saver_adapter.py": "196266b5ac6c7a805b36c9953fcdd9cafb0dcc3ac7a9e25aae6edf34a8c6fba9", + "python/sglang/srt/utils/torch_npu_patch_utils.py": "dc2a5d7bc2f3ed09df93bcac3159016b0884fee42693c6f70d6c7a24b1b66a0e", + "python/sglang/srt/utils/triton_load_watch.py": "f1d5ba3b5d61173e475885bade2dfe18ab2d73d7875797ccb5e62d0ebceba8f5", + "python/sglang/srt/utils/video_decoder.py": "c797bc40320a0485736c5f44df2dc1745e925ca2dce5e4eac4ca5375b9baff16", + "python/sglang/srt/utils/watchdog.py": "79a9f3b5b8a9942692ad1dfec0f8371ffb8cd5712f952cc23beee0ddc2917da1", + "python/sglang/srt/utils/weight_checker.py": "6829692cf99225a184062b1e35970ee35020621694e499829422b2a5d09c9e38", + "python/sglang/srt/utils/weight_checker_comparator.py": "78cecbe9a63036622217c1e029093ed58e8d9f6725f8a7e00cfb4029d3af0dcc", + "python/sglang/srt/weight_cache/__init__.py": "d42c3173b6fdb66de79e399d0cb85cce6d4006eff5812ea17d4c853160a1c1e1", + "python/sglang/srt/weight_cache/daemon.py": "d27b31e30c5acd81604fc245c748ba5d175ab0b2ccf0da5fc2bc5c3e7576182b", + "python/sglang/srt/weight_cache/ipc_loader.py": "a916a9d33fb9a02abe3693575473223497aac418d4718fb84e86396388ebeacc", + "python/sglang/srt/weight_cache/protocol.py": "e687631db8e443a5da97b1d6c05ab6a1cadc84e327a6c4c4fb1ea3080befde96", + "python/sglang/srt/weight_sync/tensor_bucket.py": "fc50064ea51c338262394ff0b7a849100e7c46761099e27a4478e9db0ea08cc2", + "python/sglang/srt/weight_sync/utils.py": "94c4747ddca2450dc55e6b2d58842cfd288a869d67c7e6c28beaf398562154ec", + "python/sglang/test/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/accuracy_test_runner.py": "53f692a81406c5df403bb96529767d4a0557b3df4201e317128d43798f80b9eb", + "python/sglang/test/ascend/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/ascend/disaggregation_utils.py": "5de7e9a90b9b0303b23c43499b600b40beb9208318888dab649aecce262eba2c", + "python/sglang/test/ascend/e2e/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/ascend/e2e/gen_dataset_fixed_len.py": "4da5d2a09d12ffce67b97a78bc87a4990d1a5085493c7f091b495d638c942006", + "python/sglang/test/ascend/e2e/k8s_multi_pd_mix.yaml.jinja2": "d84d1fdf00ee743294f511f62ce42665805c407a65897d19f555285d0ab223b4", + "python/sglang/test/ascend/e2e/k8s_multi_pd_mix_green.yaml.jinja2": "ccab6413054a14af98bd94a24e854de8a164d6c354d84afe62f4e055e75038e8", + "python/sglang/test/ascend/e2e/k8s_multi_pd_separation.yaml.jinja2": "21b606b5cd01d8f6c37529dcb4f0269a86abd7b451eba30719d598cdb7aa5118", + "python/sglang/test/ascend/e2e/k8s_multi_pd_separation_green.yaml.jinja2": "ce53a0d0f2318191cd59fca1c2f1e67c760d3e22d8a5c8c5db4cbde56e972cb9", + "python/sglang/test/ascend/e2e/k8s_single.yaml.jinja2": "0d624a88575d7c1b30502c8487545c5e7773df176151a451e058ed806cd1e516", + "python/sglang/test/ascend/e2e/run_evalscope.sh": "67ef6e317cc0d604a4a0b4a25da4ef4a09ecfe74bb4a2156fa6075e67393a32c", + "python/sglang/test/ascend/e2e/run_npu_e2e_test.py": "574e0e3577a4a5fc35186fd1c827cac30127b793a9b8c9a4502d92b6b8d13cd0", + "python/sglang/test/ascend/e2e/run_npu_testcase.sh": "5e7ee45cee29b04ca2cd5bc4366e5443df5276e38ed351ead0aefcfd631c0090", + "python/sglang/test/ascend/e2e/test_npu_accuracy_utils.py": "04c89c28cc112eba7cf2aafa7d5d4c7026fa7a4fb8d6e37adde1865e5134a6d3", + "python/sglang/test/ascend/e2e/test_npu_multi_node_utils.py": "5888991bbba44bae42d9dbed8b809b6cb217cafe70fba84edf5184c47edd6476", + "python/sglang/test/ascend/e2e/test_npu_performance_utils.py": "78cdff791ba3bfd4400c14eb47384b9b9887f478ab1c09cb669323d7b5316cbb", + "python/sglang/test/ascend/gsm8k_ascend_mixin.py": "312df800a466752899f879f82b20067fde73097ac8294dca5eb982c1c4fd6f4e", + "python/sglang/test/ascend/npu_eval_accuracy_kit.py": "b17ca43f03d1968d70a76cf331c318118fd47e50f3f7d57f148cf45754828266", + "python/sglang/test/ascend/output_capturer.py": "cab2cad35280e6f8886665dade4faec04dfd55a5d6d34735f4021df9d5d78993", + "python/sglang/test/ascend/run_eval.py": "4fdbe4d42dc329c365fe0b512770b4191f9aed4432a6875b5e0b71c86d2cba04", + "python/sglang/test/ascend/simple_eval_mmlu.py": "38ef544ff8e6705a34fd5e90400452ba0483854ff076af1f543694c80fc836d8", + "python/sglang/test/ascend/test_ascend_utils.py": "6b3af0a9658298f9e507c962459e54a4b79226f3ff84169d2c5092db4da6c08f", + "python/sglang/test/ascend/test_embedding_base.py": "c28e5cfd4e85d43729deebb929ecb6c6875a543ccc4c8667eb5a09226a4e1530", + "python/sglang/test/ascend/test_mmlu.py": "7af841a8cd68a32d8155d2b1f653e11805d5a77e45e9790e6346d1749730d4d0", + "python/sglang/test/ascend/test_no_hf_reward_base.py": "7bc043e499b999f5376b15119176571e6a7b14ad89a67ba9f6b7b7dbca695884", + "python/sglang/test/ascend/test_npu_logging.py": "b501b946dc4fad0db29d0cf5c88955fdc0c583ae9a35be43b3b18be7b2210eae", + "python/sglang/test/ascend/vlm_utils.py": "fa6742865d00e73c7a529a00389aeed12ac3b45a9dded733f25d9167025866ca", + "python/sglang/test/cache_consistency_jitter.py": "a0fd9e0aa0efdcfefb1aa693952af263710f7f241f483aa76aa0650909691d99", + "python/sglang/test/chunked_prefill_test_utils.py": "73d47ef760ad9781374e4c1a89d52cd5fcb56013d61d76d0ec874051cc04d61b", + "python/sglang/test/ci/__init__.py": "592afe0e73bfcf4a7b75dd7b6cb4feaa7abcb821e4ddcd1e700ceb9f8163705b", + "python/sglang/test/ci/ci_register.py": "697fffeb402a782a7213009036f0dc65f204004ced0defb3579eef95264ad201", + "python/sglang/test/ci/ci_stress_utils.py": "5e390af02e06d8c09e8e2180fe2d708aa2919e9f7847e4df8e321c2ff9b061cd", + "python/sglang/test/ci/ci_utils.py": "4247b3ccecf006b9521cb87f30bfb6f39c4aa243f4bfadce31affb7f9ca65a9c", + "python/sglang/test/cpu_test_utils.py": "2f8f0c29dc7249c1ee1e7e5d98d8f8d5d9d28dea8e16a5717ee0f4e9d4cde490", + "python/sglang/test/doc_patch.py": "ad2f38b3ecd27814209e5c06554cd381514cf75db896f9e7b72367b731942dc8", + "python/sglang/test/external_models/custom_qwen2_vl.py": "78dcf3f22c157703e49370c75b7efb3d261aa97aa15c32c34f2d5ad0c4f90828", + "python/sglang/test/few_shot_gsm8k.py": "769552ebf727fed84efad1f06a96dcf3c6b47f1f092e419e828de2a6cf8cf2fb", + "python/sglang/test/few_shot_gsm8k_engine.py": "89ebe193344e063e228e9bc0b37cc43e2253c2c654ecbeeb28bee75ad2ec6840", + "python/sglang/test/gpt_oss_common.py": "cd917f99740ed7e8259631ae5deac5e01763fca760439987197eab51af05f72f", + "python/sglang/test/hicache_spec_storage_common.py": "310fcb7e8d83a1f3eb5f68299711c8c8c1905266f820b7ab779493e0e8b3cb43", + "python/sglang/test/kernels/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kernels/deepseek_v4/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kernels/deepseek_v4/common.py": "47fc8910c9b9136556d7890acfb20439e59c936f6c8a5165e9cbbcf13be3686d", + "python/sglang/test/kernels/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kernels/kv_canary/_canary_helpers.py": "bfcbfbd529148c74300fd7b56a8acd66a81de9758a500aee691e134216584f44", + "python/sglang/test/kernels/kv_canary/_constants.py": "a99f6da2171e195462e5a2a8f527b642d9fee84d45a05657d1e65d449e290c43", + "python/sglang/test/kernels/kv_canary/_differential.py": "ed39578f31377edfb051f7dd89bf35dfa100d44115115ab8e08e34dd2165aa17", + "python/sglang/test/kernels/kv_canary/_fixtures.py": "d1a04de8486032e6ace0ba6368746ec91acc63162be79bd9f2e02b5c1b9e6181", + "python/sglang/test/kernels/kv_canary/_fuzz_driver.py": "ce71b3ee13dc7b4bc03b56af4789723f5ae02408f234a29a7bb0cc3f171f68ce", + "python/sglang/test/kernels/kv_canary/_hand_oracle.py": "348a9c460689d762aff5b1ba4d40da9c6e6f5b1bf9b62dd69afdbb571973ea45", + "python/sglang/test/kernels/kv_canary/_invariants.py": "b7e2572ff9c8011dad91b4f456b644e3b23d92b197712228f7382dae09f6a2de", + "python/sglang/test/kernels/utils.py": "f524ddeb157d2f69f58e4b011e0eff4ac06ff41f3658a1adaa4389da601bf300", + "python/sglang/test/kits/abort_timeout_kit.py": "a45688c87ed84d10b202034724ae181f251fed66bdd98e37f11c5c183feeb731", + "python/sglang/test/kits/anthropic_messages_kit.py": "e01f7d7fd7de5f62992132f8cb62f749e9cb72df9065916f48d18511e2cc6cde", + "python/sglang/test/kits/attention_unittest/__init__.py": "766d5a7a5cc6e1498034f5e0bf673dc3f2f032cca1a54dfa791dd10ff86500f9", + "python/sglang/test/kits/attention_unittest/attention_methods/__init__.py": "3153177d9b08069119c6378d229022d3d61f616bd918df230fd57b7fcaf317ec", + "python/sglang/test/kits/attention_unittest/attention_methods/dense_attention.py": "33349f5da9a2ce52cc3b2296f117a7c21021fca9384101f2ddae3a5fc803fcb4", + "python/sglang/test/kits/attention_unittest/attention_methods/dsa_attention.py": "857d8fafc6dcdb65f43d96dd2edf22d41c7501559b9b307c22290a9337589e56", + "python/sglang/test/kits/attention_unittest/attention_methods/dsv4_attention.py": "a159c26c15f158546dc53017bc607ed526ea0757e1efe2eb4dac953f77ca48af", + "python/sglang/test/kits/attention_unittest/attention_methods/dual_chunk_attention.py": "a3595b42f8a0ed7e0b3c0b9133a1e09d9543cf85f2ad6591110687d7bcf93d24", + "python/sglang/test/kits/attention_unittest/attention_methods/gdn_attention.py": "f7df7659b8e904d704ce04021e00a6fc20fdaf99f88e5828cbed09980bff786d", + "python/sglang/test/kits/attention_unittest/attention_methods/kda_attention.py": "6ff3ba80a90718971c20be63cec34bef649ab16322e60b508c2d7de951f8b709", + "python/sglang/test/kits/attention_unittest/attention_methods/lightning_attention.py": "0bd85009229b975772edc058a43e39c5fd3e6101994673c60ee8255188f32f6c", + "python/sglang/test/kits/attention_unittest/attention_methods/mamba2_attention.py": "abf71406f312974c78cf61b248d9ae6859742e2a7d4d17d0fbc8ed22af93aa74", + "python/sglang/test/kits/attention_unittest/attention_methods/mla_attention.py": "1a5b0d4df7db39149c7479f9794b3ebf042b5a186bf87c5ce15699b02aec6d6e", + "python/sglang/test/kits/attention_unittest/runner_modes/__init__.py": "67b0bd82e6f07669cdbef004c2ebfab3b3885e99d0ef4c1c7d04d2a5ab5c8d73", + "python/sglang/test/kits/attention_unittest/runner_modes/cuda_graph_decode_runner.py": "96b135a452b315b6552c4c07424f00007a766ed5b08e2fb5e08a9008a05fec97", + "python/sglang/test/kits/attention_unittest/runner_modes/metadata_invariants.py": "7b38c084c715e221a8c1fb79846fdc997d9aa744fbcc6742be286d1fb2a7427d", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_cuda_graph_runner.py": "229d21a332b5a537a518ffac181494fc97b9fdd80ec63180cec40e0f47e344a0", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_draft_extend_runner.py": "07b8f21cdbffb169a6e225c769d4af55411920b67b1511e2eda578c202e4543a", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_draft_runner.py": "36fe939882a7f5688362bbc0f4327681f3de16a50435f425268d098791f63ffe", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_target_verify_runner.py": "c702279c8655be089573dd8a605c9d1e1780008cbbab36c55e2434076fbbf68a", + "python/sglang/test/kits/attention_unittest/runner_modes/split_op_runner.py": "d130f94b06f5e8244617ea6c574983666c2b464906a779b1dd4d256c7c45aecf", + "python/sglang/test/kits/basic_api_contract_kit.py": "12da293c9ac39eaf2d24b8d1a0ff92c1da90a3822b5a5c7cd0582c9d0a4d82f6", + "python/sglang/test/kits/basic_decode_correctness_kit.py": "b11161c1b46820899eb90606e7a374de0992a1bfb1957fe62e1bfc1b16eab893", + "python/sglang/test/kits/basic_scheduler_stress_kit.py": "e0139de97468cdfa514bca3dc3a2d8c7a35f6a798673ea7831b34c30e53dfedf", + "python/sglang/test/kits/cache_hit_kit.py": "180f3327a70457648fa42b620028f5043e2bfd458bf4441f04e048271742f401", + "python/sglang/test/kits/ebnf_constrained_kit.py": "a82b070f8d217493ae4e39ff3fda414f29905b2ff2e76028e5e78b80c200ee2d", + "python/sglang/test/kits/eval_accuracy_kit.py": "c66e48dc21fe072c94981694c8c86969c1057df593273db5874a33c9296509fa", + "python/sglang/test/kits/fwd_occupancy_kit.py": "5923ed5540cf401ee841b61a119957741c67e47ca0be7bf96d8bbcd547589b04", + "python/sglang/test/kits/hellaswag_kit.py": "444710eb25cdfdfc55d20b80d67cf8081d079d5a7c79ab5b25b6e5ea4d4efd56", + "python/sglang/test/kits/json_constrained_kit.py": "03571e095b07fc33b6da8ca2b760a505d54e9e923d36349fa88ad0ef4f4d1c49", + "python/sglang/test/kits/json_mode_kit.py": "bc06c240e51a456656e70f1804d5bbd2450e967267e1ed46924852716ec5dabb", + "python/sglang/test/kits/kl_divergence_kit.py": "43e268b628e794b3575921a66e8eb4e329f7623b520957ddb543c201f0488018", + "python/sglang/test/kits/lm_eval_kit.py": "960aa82f2dd609c102ff1f7e35afc1ff3d46c4ffacd571c9a93503d47935a8ba", + "python/sglang/test/kits/matched_stop_kit.py": "eb46044a2bdd12a9fa5d751af682eed5478ba33a786a1b5e104bd6c8e5150f1f", + "python/sglang/test/kits/mmmu_vlm_kit.py": "c403eab9055ef2ccc0ca7becafc6ec12a49a744083072ed1eb6b182fb6f79015", + "python/sglang/test/kits/pause_generation_kit.py": "90619f40caf6080878b0183a838dbb9d5a3abc1f387c644c89549c04894bd748", + "python/sglang/test/kits/prefix_cache_branching_kit.py": "988c5bc42886be7e71d240c089cbdf6bb7ae897b5d0a5e62512d3c6864674969", + "python/sglang/test/kits/radix_cache_server_kit.py": "a1dbf6aa2c2d8fd4a615f61e0ec660786d2303501137c10e86b328da273dc3b1", + "python/sglang/test/kits/reasoning_kit.py": "306cb78382e64aa0be24638516c93099394730def7e1937c1741c5bacaf8bf8a", + "python/sglang/test/kits/regex_constrained_kit.py": "3d0e81e11307fbedba4712d1923f953c222a88ff8680e6e0da77470b6f914a5f", + "python/sglang/test/kits/spec_decoding_kit.py": "76d3ba7b58e2bc616146dd4088707047601f42a7ae6a27c48c4cfeb688ad9dde", + "python/sglang/test/kits/spec_server_kits.py": "7f0e9a20a9761d4c595dbb598678a18390ef0730a81a1258f745e7d118ca5c5b", + "python/sglang/test/kits/streaming_session_kit.py": "47c3c03a51f20d49e0367ed68b2f6c663c01d079a9c3ab50ffe11fca08bb50f5", + "python/sglang/test/kits/unified_radix_cache_kit.py": "6d6981ec279339ca75197ece222ad72091555f3580939a970e48f54716d78f53", + "python/sglang/test/kl_multiturn_utils.py": "6e0f44b6a7e046e7759c3005bbcbfd81a4923628f92ff19dcd9f2b991445a9d7", + "python/sglang/test/kl_test_utils.py": "2222c57f45e0c4542b0c7c6e564869822265ac8cfce371eef6936af51d0a7bc6", + "python/sglang/test/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kv_canary/consts.py": "38ba3fdb420336c66176968c991092397cb680da939b30e4ef8c5b901e228351", + "python/sglang/test/kv_canary/e2e_base.py": "491f61d4e2302649852c580091e968f9d8e75b5f797fceddd2a825e2e67841ee", + "python/sglang/test/kv_canary/fixtures.py": "167b68ae08819d0a7a509b331cb3eebecfad4fbc531867509257f1308e151080", + "python/sglang/test/kv_canary/mode_config.py": "9068fc4c3a5739c010a3e4f13d8e0f632cfa42cde1ffe1b90c228d6cf946d4bd", + "python/sglang/test/kv_canary/pd_fixture.py": "78eb12ccfefb73cf3fa4252cda596a1301d7c96a78297cd6131c87825788147b", + "python/sglang/test/kv_canary/pp_fixture.py": "8c7ac6a97775311c4598369c9ecd4496068f73080f91a7cc107c6ffe129e3b10", + "python/sglang/test/kv_canary/runner_test_base.py": "cb414740122c00e1f2f639fa280cba7b334848bc8a57cc2000ef9ea9b30c0da7", + "python/sglang/test/kv_canary/utils.py": "707f882bcc1027fefe39a9442ec3143e077407862cb74671dfc8adc161eefdad", + "python/sglang/test/kv_canary/violation_assert_mixin.py": "56d64ff645e6b22edd656a0fcce86035c90de7122e4ab708ce529638f0366d06", + "python/sglang/test/kv_canary/violation_log_utils.py": "71c36def7a1daf2e8e36feeac3f62c1cb2b1b95780f1a37a44258e438fe193c5", + "python/sglang/test/layer_ut_utils.py": "0a2402a6f7798bcf2f9e0d460c29f12788ce2b8c1ec5d326280b86f7b10b9198", + "python/sglang/test/logprob_test_utils.py": "08d839683e6271c7d4fd67357babd1d8ca679f5c4990c22bdbe034682124b5e1", + "python/sglang/test/long_prompt.txt": "37733cc60234aab491177a2eeff4237a02409bd444f63dfe810239f61cfcb085", + "python/sglang/test/lora_utils.py": "b40ede0791f2404ae66ae3ddea682fa7b93120ac1fc13881935fc0b46988837d", + "python/sglang/test/manual/disaggregation/test_chunked_prefill_abort.py": "8b32d6220f47c3f53d211ad40936198d5ec9e4df8d1a3052bfeea4ef46e641fa", + "python/sglang/test/manual/disaggregation/test_disaggregation_chunked_prefill_abort.py": "69a9c35e57a0e97d80a72486c6423f1853a38bf0a6f21d217e5ab5006369c5f3", + "python/sglang/test/manual/disaggregation/test_disaggregation_peer_liveness_abort.py": "64bacb67c2c0344a2c5024e15de3ae331a3fff1fda6c0e87cdb7250bb69a2e32", + "python/sglang/test/mock_model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/mock_model/perturb_e2e_base.py": "c20818c783010300f91ecf008f329cc887ea2388877130a78a682b6788a8a8ee", + "python/sglang/test/mock_model/utils.py": "cd3e4ff77c38ea0174e61ca2cf76b3ab867408eba42ee75f1cf801f843588138", + "python/sglang/test/nightly_bench_utils.py": "76af58d680f91d2ab10d7b09b2a95ddc570f88779ab4b0cf0ac6228f92166daa", + "python/sglang/test/nightly_utils.py": "9de169b6a285d42512eb8a52eb815a7209e5312404e68ea0fcac13fd192b7ea8", + "python/sglang/test/observability/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/observability/fake_ray.py": "0e4906334f03b9c300116c740dbd2a2da65db326871c66cfa24122b21d751639", + "python/sglang/test/otel_collector.py": "00491d1e5f3d1d8e5de0defe870c146515f2912cd335e222373d3e62da488fb0", + "python/sglang/test/performance_test_runner.py": "973f9c566424627430a9214a33dcd7536784571423c43a726578b9ecede4b761", + "python/sglang/test/precision_baseline_store.py": "c179147635b897046ae51a38b1a8560df4e4eec3a09946bf55171ff0f362b4d3", + "python/sglang/test/quant_ref_utils.py": "80c04a005e3242f1ccc5af93ae5bb79ee5893c7634f440bc793c6483e52b0040", + "python/sglang/test/run_combined_tests.py": "5854fb7686cee1107643ca057fd1a20e4bce12ed001ae87733ab839e371f1775", + "python/sglang/test/run_eval.py": "0ccae307af3ea0c6cfea9e27dbe6b60b63f7ca60a91e798a00be73187facf7cb", + "python/sglang/test/runners.py": "7a5691eb92a5e13bee014f3dcfb6c3347d446b97fd7de3bb5a5a2f37cf90e47a", + "python/sglang/test/scripted_runtime/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/scripted_runtime/background_http_poster.py": "8f29c2f03b6f1fa441e28897f5a5e3590ccdea7ddd9893fe64e9d40db70bba34", + "python/sglang/test/scripted_runtime/context/__init__.py": "d3572ec52cf1e3ae7956dc14d3d8096b2f14292d6b2c000e254050da580deeb6", + "python/sglang/test/scripted_runtime/context/api.py": "42710ca730cc29eb5ea102f539239291c4ce872a683019f0d1f385809d66b60d", + "python/sglang/test/scripted_runtime/context/engine.py": "6ee003e563df38261d4e3ed89cbccf1ed8da508b1b47f4c133c99798ca36c7c9", + "python/sglang/test/scripted_runtime/context/http_post.py": "8a3312128c20819dbe1120fa8a7a8f9f7d3c38dfb17475d2f2f817e158ef7bc9", + "python/sglang/test/scripted_runtime/context/kv_pool_exhauster.py": "c67f894b46252a4b63ae98398829b2820b2d5a982fba0dfd004a5f564a96acf1", + "python/sglang/test/scripted_runtime/context/lifecycle.py": "6b948df8881b2533b2df557af75884bad6e93a53faccad7addb269a6c1a02abd", + "python/sglang/test/scripted_runtime/context/lock_ref_exhauster.py": "6390b06b289b8df782c72ed4172e2a49c2253cc7e5469d15524bdc49809c467d", + "python/sglang/test/scripted_runtime/context/queries.py": "8d737f2d99c6e0c6be1e0f48183f39872418a76f2f222874b4b9793aae6b9f8b", + "python/sglang/test/scripted_runtime/context/radix.py": "89f0e283cecbd3085bee281b057fa78574d3bceb80c433f25483a6e6e2b687ac", + "python/sglang/test/scripted_runtime/context/req_starter.py": "f0e0ffdad547f706e0b50702f759f998193990cee97f69a221c495a6979a5e2d", + "python/sglang/test/scripted_runtime/http_server.py": "0dec1cc1b10db21eb525a11a66fb38e1b51d89a966c89b1acab749f7a5b1a2ee", + "python/sglang/test/scripted_runtime/io_struct.py": "5ac739259af031471c0719cfdbdc85f18da5592db05341c3e531b228b123380f", + "python/sglang/test/scripted_runtime/req_handle.py": "594877f5cf9f88a101728d07249ce77606d5cc076f4700266ee83890ec243e26", + "python/sglang/test/scripted_runtime/scheduler_hook.py": "4e4a13979168e3051196223704c947c182a216ecbe7a8b19a87c7b254b8a02cd", + "python/sglang/test/scripted_runtime/test_case.py": "e07bda24f8662c9b370a9b3e44c6dd9bb92572c5e13765a14fafb7126e7ae3e9", + "python/sglang/test/scripted_runtime/tokenizer_recv_proxy.py": "9ba8b8bdc1a403196d3f6b941cbfefab6b2a9d12492b73d8cd4d4c23fda61e53", + "python/sglang/test/scripted_runtime/utils.py": "65cabcf96f6dcb91364cc3b149ba9f687a33bfaa2c96a9cbca8d2978459e578d", + "python/sglang/test/scripted_runtime_chunked_helpers.py": "cf73bda447dfd82b0276564470f9d5691ffff653b19f41dd79e110aa37c34e6d", + "python/sglang/test/send_one.py": "77bc3b499742f4fa19557ccca0185ddb6ad7599a3286db6b98e9e818ccd4a3dc", + "python/sglang/test/server_fixtures/default_fixture.py": "a87f02aaf39f92c582231c78b7520772fc38dabc9f3489c508968728f9cb5253", + "python/sglang/test/server_fixtures/disaggregation_fixture.py": "b6af811f6d2a335cf0a17cfefdec889754741eb235730de85a83816c4522d1cd", + "python/sglang/test/server_fixtures/dsa_mtp_fixture.py": "2744c5356309ab12cacb2b45b3972c2faf9b64b3af79e76c3deb70a4cae2fd10", + "python/sglang/test/server_fixtures/eagle_fixture.py": "c61c67b5ab45d9d41dc4eb56b14d55a04aa2c621392744550c4b079a41b9c9fb", + "python/sglang/test/server_fixtures/hybrid_attn_backend_fixture.py": "b85b7e9d59b63daf60dee8cef0ede7f84c0c7aeae2762e326e945351a0cea722", + "python/sglang/test/server_fixtures/mmmu_fixture.py": "a8d3e51af235aa0383770c148e6ab2c79ee036f0dd6faafa43073b6f884cc7ad", + "python/sglang/test/server_fixtures/ngram_fixture.py": "92632ec57b742971eda37d6b0fff08b11621184c6f72f98cb115c21d3463079a", + "python/sglang/test/server_fixtures/pcg_spec_fixture.py": "9f90c1abcbfc6f26a4d2c4dac959b9e7c230511fc5af48ec8a0b601bec6e760f", + "python/sglang/test/server_fixtures/spec_eagle_fixture.py": "34e97921df46570466d23cb2cd983741600a1a27dfded3bd12dad6c3123e95b0", + "python/sglang/test/server_fixtures/standalone_fixture.py": "04cfd925f255f16c1b0219b210fe13d9515bd25badce13480bafe234fa44d921", + "python/sglang/test/server_fixtures/streaming_session_fixture.py": "f047ed2037607eca1e4f7d7dda9a3eee2f33f4f91c606ad1824d9de21c88a74a", + "python/sglang/test/simple_eval_aime25.py": "27963c56f4a4f4e0bd6f31079c4d17cb1ea38724e32b8d90dd34a44629ff938f", + "python/sglang/test/simple_eval_aime26.py": "a8847e0ed01e32e6ff0da16c4e9c57b4fdc41e06b769be93952e7a0b1704b892", + "python/sglang/test/simple_eval_common.py": "d5e97cc180fae031f73d73af8dd4ced974975df07651891e789ade09d0ad071f", + "python/sglang/test/simple_eval_gpqa.py": "2a1dacce92d75397490edfd88bb131dfc9fd0f5df39eacf0b668595228b4e436", + "python/sglang/test/simple_eval_humaneval.py": "d26f48589356bdfcccafd46705eecb2f19c7b058c8576a9c56d259394b2082bd", + "python/sglang/test/simple_eval_longbench_v2.py": "2cb6b7a80985f0f1751c60beb9b35c681e236b3db636164163aeeb2334c7e439", + "python/sglang/test/simple_eval_math.py": "cf6d04a5cdbe518dce86b9fb18974b98cc1d104c4c896140eb164585428b8640", + "python/sglang/test/simple_eval_mgsm.py": "41b3c1e7d6d02195903f4c9dfd855db56349335723a217714b82fa77ffe4f7b2", + "python/sglang/test/simple_eval_mixed_prefix_gsm8k.py": "582a15ab52728aa22b3190091f82e91a10e6c1a6f0eea82b37c86208abc51ebb", + "python/sglang/test/simple_eval_mmlu.py": "769a0837785460c622ba61f53ecb4c3a70db72e304acd982e1f10f3149268be6", + "python/sglang/test/simple_eval_mmmu_vlm.py": "78ede20949c24df27e1896ebd1565df44d2f672c23d6f6f28f9de50592ad97ed", + "python/sglang/test/test_deepep_utils.py": "ef8f72b1304637387aad850226185906d669783d797964de347602cad72f66d7", + "python/sglang/test/test_deterministic.py": "a9f2ff426a156a45b8f69ecfc24fbfbd6c699b4aa8cba40b26e331c0cde7664a", + "python/sglang/test/test_deterministic_utils.py": "69a9a8e8db112b96405c1bc682eedb2fa3fd5da5e43723d08fa237290bb5d2f1", + "python/sglang/test/test_marlin_utils.py": "e9911ab643ba2b793959fa4d0bf35f7f1acd490761e394dbf72fea0375379e2a", + "python/sglang/test/test_programs.py": "206edce50a73450714973cd8198729fee3abd223f8bbb5fda56c3c489d2bbe66", + "python/sglang/test/test_utils.py": "b25ac72188208942156cc1cc7a96ae5cbd0fd69111ab96ce47f5b1bfb3eac81e", + "python/sglang/test/tool_call_test_runner.py": "aafc61c33f86d2bf65355f51d4f131847196527b30a4d4de113fe17a5fcec871", + "python/sglang/test/vlm_utils.py": "8c8a770aa0c8daed2d36067480471dca8e29b070801263174c905bf6cb2e749b", + "python/sglang/test/xpu/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/xpu/simple_eval_gsm8k_xpu_mixin.py": "c41867f97e6142fa19fb3f0c1bbd6be155ed05ba7d16042f4b2b613590349ef6", + "python/sglang/test/xpu/test_xpu_utils.py": "742f270c42eb37e9680d05dc87b116114241b151139d4c202b87e52c23411df2", + "python/sglang/utils.py": "8e453ae5a32c045cc7f9ee842081e727fbede9ab9c88536ebb299eb122ad8ed8", + "python/sglang/version.py": "b10f7d9ea276972352b1e9de0eb0bbb47d8ebe64c29469e15ea016a12019bb22" +} diff --git a/provenance/responses-phase-order.json b/provenance/responses-phase-order.json new file mode 100644 index 0000000..e10162b --- /dev/null +++ b/provenance/responses-phase-order.json @@ -0,0 +1,26 @@ +{ + "status": "CPU-only candidate; not deployed", + "base_main_commit": "93463c3466b0de9d21776fbeff95657285df8269", + "predecessor_profile": "responses-compat", + "patch": "0017-responses-phase-order.patch", + "patch_sha256": "b076ed8dcf170e8a0116866618547b0b5399e912eb26153f6d5b8fcc6f4707b1", + "files": { + "python/sglang/srt/entrypoints/openai/protocol.py": { + "before": "fbc60d3206612f408d93f786b18446ab96c258ff60bf1f1c4cf0e36e3c88eca1", + "after": "0d4ab08ef507764b1a477d12ff63ca6a70c48151b1464881c29928a87e392165" + }, + "python/sglang/srt/entrypoints/openai/serving_responses.py": { + "before": "d46f648b557db07a430869471fcf4d7a898d50f99e495efd5eb01911c428f215", + "after": "2d74b6b58076ae90770198c73f99bee6442fa6d006ae49f2118d02012ea51371" + } + }, + "source_files_before": 4392, + "source_files_after": 4392, + "inventory": "responses-phase-order-runtime-files.json", + "inventory_sha256": "32d6b2d6749c2a7d99822805bf331291e03a153d872f71eded2df6d33615be9c", + "scope": [ + "Responses message phase serialization", + "Qwen reasoning, text, and tool replay ordering", + "Qwen streaming markup boundary ordering" + ] +} diff --git a/runtime/python/sglang/srt/entrypoints/openai/protocol.py b/runtime/python/sglang/srt/entrypoints/openai/protocol.py index c120d0a..44c91a1 100644 --- a/runtime/python/sglang/srt/entrypoints/openai/protocol.py +++ b/runtime/python/sglang/srt/entrypoints/openai/protocol.py @@ -39,11 +39,13 @@ ResponseFunctionToolCall, ResponseInputItemParam, ResponseOutputItem, - ResponseOutputMessage, + ResponseOutputItemAddedEvent, + ResponseOutputItemDoneEvent, ResponseOutputText, ResponseReasoningItem, ResponseTextConfig, ) +from openai.types.responses import ResponseOutputMessage as OpenAIResponseOutputMessage from openai.types.responses.response import ToolChoice from openai.types.responses.response_custom_tool_call import ResponseCustomToolCall from openai.types.responses.response_format_text_json_schema_config import ( @@ -630,6 +632,7 @@ class ChatCompletionMessageGenericParam(BaseModel): ) tool_call_id: Optional[str] = None name: Optional[str] = None + phase: Optional[Literal["commentary", "final_answer"]] = None reasoning_content: Optional[str] = None tool_calls: Optional[List[ToolCall]] = Field(default=None, examples=[None]) tools: Optional[List[Tool]] = Field(default=None, examples=[None]) @@ -1789,6 +1792,18 @@ class ResponseNamespacedCustomToolCall(ResponseCustomToolCall): namespace: str +class ResponseOutputMessage(OpenAIResponseOutputMessage): + phase: Optional[Literal["commentary", "final_answer"]] = None + + +class ResponsePhasedOutputItemAddedEvent(ResponseOutputItemAddedEvent): + item: Union[ResponseOutputMessage, ResponseOutputItem] + + +class ResponsePhasedOutputItemDoneEvent(ResponseOutputItemDoneEvent): + item: Union[ResponseOutputMessage, ResponseOutputItem] + + class ResponsesResponse(BaseModel): """Response body for v1/responses endpoint.""" @@ -1799,6 +1814,7 @@ class ResponsesResponse(BaseModel): output: List[ Union[ + ResponseOutputMessage, ResponseNamespacedFunctionToolCall, ResponseNamespacedCustomToolCall, ResponseOutputItem, @@ -1890,7 +1906,7 @@ def _is_text_only( try: if isinstance(it, ResponseOutputText): continue - elif isinstance(it, ResponseOutputMessage): + elif isinstance(it, OpenAIResponseOutputMessage): if not it.content: continue for c in it.content: diff --git a/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py b/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py index 2fda942..18931fb 100644 --- a/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -7,6 +7,7 @@ import asyncio import json import logging +import re import time from contextlib import AsyncExitStack from http import HTTPStatus @@ -18,7 +19,6 @@ from fastapi import Request from fastapi.responses import ORJSONResponse from openai.types.responses import ( - ResponseOutputMessage, ResponseOutputText, ResponseReasoningItem, ) @@ -61,6 +61,9 @@ MessageProcessingResult, PromptTokenUsageInfo, RequestResponseMetadata, + ResponseOutputMessage, + ResponsePhasedOutputItemAddedEvent, + ResponsePhasedOutputItemDoneEvent, ResponsesRequest, ResponsesResponse, Tool, @@ -1009,6 +1012,7 @@ def _make_response_output_items( role="assistant", status="completed", type="message", + phase="commentary" if tool_call_items else "final_answer", ) output_items.append(message) output_items.extend(tool_call_items) @@ -1232,10 +1236,39 @@ def _output_message_text(output_item: Any) -> Optional[str]: @staticmethod def _merge_consecutive_assistant_messages( messages: list, + *, + preserve_qwen_order: bool = False, ) -> list: """Collapse runs of consecutive ``assistant`` dicts into one entry, joining ``content`` and concatenating ``tool_calls`` and ``reasoning_content`` so a logical turn renders as a single block.""" + + def compatible(left: dict, right: dict) -> bool: + left_phase, right_phase = left.get("phase"), right.get("phase") + if not preserve_qwen_order: + return left_phase == right_phase + if ( + left_phase is not None + and right_phase is not None + and left_phase != right_phase + ): + return False + if left_phase == "final_answer" and ( + right.get("reasoning_content") or right.get("tool_calls") + ): + return False + + # Qwen renders reasoning, then content, then calls within each block. + # A restarted sequence must remain in a separate assistant block. + fields = ("reasoning_content", "content", "tool_calls") + left_stages = [i for i, field in enumerate(fields) if left.get(field)] + right_stages = [i for i, field in enumerate(fields) if right.get(field)] + return ( + not left_stages + or not right_stages + or max(left_stages) <= min(right_stages) + ) + merged: list = [] for msg in messages: if ( @@ -1244,8 +1277,16 @@ def _merge_consecutive_assistant_messages( and merged and isinstance(merged[-1], dict) and merged[-1].get("role") == "assistant" + and compatible(merged[-1], msg) ): prev = merged[-1] = dict(merged[-1]) + # Reasoning and calls have no phase; retain the text item's phase. + if ( + preserve_qwen_order + and prev.get("phase") is None + and msg.get("phase") is not None + ): + prev["phase"] = msg["phase"] # Lift mixed str/list content to list parts so non-text parts # (e.g. image_url) survive when the two sides differ in shape. new_content = msg.get("content") @@ -1305,13 +1346,9 @@ def _construct_input_messages( messages.extend(prev_msg) for output_item in prev_response.output: - if isinstance(output_item, ResponseFunctionToolCall): - messages.append(self._normalize_response_message_for_chat(output_item)) - continue - assistant_text = self._output_message_text(output_item) - if assistant_text is None: - continue - messages.append({"role": "assistant", "content": assistant_text}) + normalized = self._normalize_response_message_for_chat(output_item) + if normalized is not None: + messages.append(normalized) # Append the new input # Responses API supports simple text inputs without chat format @@ -1326,7 +1363,15 @@ def _construct_input_messages( # One Responses-API assistant turn maps to multiple input items # (message + function_call(s)); collapse them into one chat message # so chat templates render a single assistant block per turn. - messages = self._merge_consecutive_assistant_messages(messages) + is_qwen = self.tokenizer_manager.model_config.hf_config.model_type in { + "qwen3_8_flash_next", + "qwen3_8_flash_next_text", + "qwen4_exp", + } + messages = self._merge_consecutive_assistant_messages( + messages, + preserve_qwen_order=is_qwen, + ) # Most chat templates expect a single leading ``system`` message; # coalesce any ``instructions`` + interleaved ``developer`` entries. @@ -2091,6 +2136,16 @@ def _sanitize_response_dict(d: dict) -> dict: tool_call_parser_active=isinstance(tool_parser, FunctionCallParser), ) + # These parsers return separate text and call collections. Feed Qwen + # markup boundaries separately so their original order remains visible. + split_qwen_markup = ( + self.tokenizer_manager.model_config.hf_config.model_type + in {"qwen3_8_flash_next", "qwen3_8_flash_next_text", "qwen4_exp"} + and self.reasoning_parser in {None, "qwen3", "qwen3-thinking"} + and self.tool_call_parser in {None, "qwen3_coder"} + and (reasoning_parser_obj is not None or tool_parser is not None) + ) + current_output_index = -1 reasoning_state = { "open": False, @@ -2211,7 +2266,7 @@ def _open_message_item() -> str: ) return item_id - def _close_message_item(): + def _close_message_item(phase: str = "final_answer"): if not message_state["open"]: return [] text = message_state["text"] @@ -2224,6 +2279,7 @@ def _close_message_item(): role="assistant", content=[text_content], status="completed", + phase=phase, ) events = [ _send_event( @@ -2248,7 +2304,7 @@ def _close_message_item(): ) ), _send_event( - openai_responses_types.ResponseOutputItemDoneEvent( + ResponsePhasedOutputItemDoneEvent( type="response.output_item.done", sequence_number=-1, output_index=message_state["output_index"], @@ -2335,241 +2391,259 @@ def _close_tool_call_state(tool_index: int): ) flushed = flushed or flush - if reasoning_parser_obj is not None: - reasoning_chunk, delta = reasoning_parser_obj.parse_stream_chunk( - delta - ) - if flush: - end_reasoning, end_normal = ( - reasoning_parser_obj.parse_stream_end() - ) - if end_reasoning: - reasoning_chunk = (reasoning_chunk or "") + end_reasoning - if end_normal: - delta = (delta or "") + end_normal - else: - reasoning_chunk = None - - if reasoning_chunk: - if message_state["open"]: - for ev in _close_message_item(): - yield ev - if not reasoning_state["open"]: - item_id = _open_reasoning_item() - yield _send_event( - openai_responses_types.ResponseOutputItemAddedEvent( - type="response.output_item.added", - sequence_number=-1, - output_index=reasoning_state["output_index"], - item=ResponseReasoningItem( - id=item_id, - type="reasoning", - summary=[], - content=[], - status="in_progress", - ), - ) + parts = ( + [part for part in re.split(r"(?=<)|(?<=>)", delta) if part] + or [""] + if split_qwen_markup + else [delta] + ) + flush_chunk = flush + for part_index, delta in enumerate(parts): + # Flush parser state once, after the terminal piece. + flush = flush_chunk and part_index == len(parts) - 1 + if reasoning_parser_obj is not None: + reasoning_chunk, delta = reasoning_parser_obj.parse_stream_chunk( + delta ) - # Clients that opt into ``reasoning.summary`` render - # off the ``reasoning_summary_text.*`` event stream, - # so mirror the trace into a summary part. - if wants_summary: - yield _send_event( - openai_responses_types.ResponseReasoningSummaryPartAddedEvent( - type="response.reasoning_summary_part.added", - item_id=item_id, - output_index=reasoning_state["output_index"], - summary_index=0, - part=ResponseReasoningSummaryAddedPart( - type="summary_text", text="" - ), - sequence_number=-1, - ) + if flush: + end_reasoning, end_normal = ( + reasoning_parser_obj.parse_stream_end() ) - reasoning_state["text"] += reasoning_chunk - if wants_summary: - yield _send_event( - openai_responses_types.ResponseReasoningSummaryTextDeltaEvent( - type="response.reasoning_summary_text.delta", - item_id=reasoning_state["item_id"], - output_index=reasoning_state["output_index"], - summary_index=0, - delta=reasoning_chunk, - sequence_number=-1, - ) - ) + if end_reasoning: + reasoning_chunk = (reasoning_chunk or "") + end_reasoning + if end_normal: + delta = (delta or "") + end_normal else: - yield _send_event( - openai_responses_types.ResponseReasoningTextDeltaEvent( - type="response.reasoning_text.delta", - item_id=reasoning_state["item_id"], - output_index=reasoning_state["output_index"], - content_index=0, - delta=reasoning_chunk, - sequence_number=-1, - ) - ) + reasoning_chunk = None - if not delta and not flush: - continue - - if isinstance(tool_parser, JsonArrayParser): - required_buffer += delta - normal_text, tool_calls = "", [] - if flush and required_buffer.strip(): - tool_calls = [ - ToolCallItem(tool_index=index, name=name, parameters=arguments) - for index, (name, arguments) in enumerate( - validated_json_calls(required_buffer, {tool.function.name for tool in chat_tools}) - ) - ] - elif tool_parser is not None: - normal_text, tool_calls = tool_parser.parse_stream_chunk(delta) - if flush: - end_text, end_calls = tool_parser.parse_stream_end() - normal_text = (normal_text or "") + end_text - tool_calls = list(tool_calls) + end_calls - else: - normal_text, tool_calls = delta, [] - - def _emit_tool_calls(calls): - nonlocal current_output_index - if calls: - if reasoning_state["open"]: - for ev in _close_reasoning_item(): - yield ev + if reasoning_chunk: if message_state["open"]: - for ev in _close_message_item(): + for ev in _close_message_item(phase="commentary"): yield ev - - for call in calls: - tool_index = call.tool_index - state = tool_call_states.get(tool_index) - if state is None or state.get("done"): - # Close other open calls first, so their - # output_item.done precedes the next added. - for other_index in list(tool_call_states): - if other_index != tool_index: - for ev in _close_tool_call_state(other_index): - yield ev - current_output_index += 1 - item_id = f"fc_{random_uuid()[:8]}" - call_id = f"call_{random_uuid()[:24]}" - state = { - "item_id": item_id, - "call_id": call_id, - "output_index": current_output_index, - "name": call.name or "", - "arguments": "", - "added": False, - "done": False, - } - tool_call_states[tool_index] = state - if not state["added"]: - if request._compat_registry is not None: - request._compat_registry.output_identity(state["name"]) - state["added"] = True + if not reasoning_state["open"]: + item_id = _open_reasoning_item() yield _send_event( openai_responses_types.ResponseOutputItemAddedEvent( type="response.output_item.added", sequence_number=-1, - output_index=state["output_index"], - item=ResponseFunctionToolCall( - arguments="", - call_id=state["call_id"], - name=state["name"], - type="function_call", - id=state["item_id"], + output_index=reasoning_state["output_index"], + item=ResponseReasoningItem( + id=item_id, + type="reasoning", + summary=[], + content=[], status="in_progress", ), ) ) - if call.parameters: - state["arguments"] += call.parameters + # Clients that opt into ``reasoning.summary`` render + # off the ``reasoning_summary_text.*`` event stream, + # so mirror the trace into a summary part. + if wants_summary: + yield _send_event( + openai_responses_types.ResponseReasoningSummaryPartAddedEvent( + type="response.reasoning_summary_part.added", + item_id=item_id, + output_index=reasoning_state["output_index"], + summary_index=0, + part=ResponseReasoningSummaryAddedPart( + type="summary_text", text="" + ), + sequence_number=-1, + ) + ) + reasoning_state["text"] += reasoning_chunk + if wants_summary: yield _send_event( - openai_responses_types.ResponseFunctionCallArgumentsDeltaEvent( - type="response.function_call_arguments.delta", + openai_responses_types.ResponseReasoningSummaryTextDeltaEvent( + type="response.reasoning_summary_text.delta", + item_id=reasoning_state["item_id"], + output_index=reasoning_state["output_index"], + summary_index=0, + delta=reasoning_chunk, sequence_number=-1, - item_id=state["item_id"], - output_index=state["output_index"], - delta=call.parameters, ) ) - - def _emit_normal_text(): - if normal_text and _should_emit_normal_text_as_message( - normal_text, - any_tool_call_in_progress=any( - not s.get("done") for s in tool_call_states.values() - ), - ): - if reasoning_state["open"]: - for ev in _close_reasoning_item(): - yield ev - for tool_index in list(tool_call_states): - for ev in _close_tool_call_state(tool_index): - yield ev - if not message_state["open"]: - item_id = _open_message_item() + else: yield _send_event( - openai_responses_types.ResponseOutputItemAddedEvent( - type="response.output_item.added", + openai_responses_types.ResponseReasoningTextDeltaEvent( + type="response.reasoning_text.delta", + item_id=reasoning_state["item_id"], + output_index=reasoning_state["output_index"], + content_index=0, + delta=reasoning_chunk, sequence_number=-1, - output_index=message_state["output_index"], - item=ResponseOutputMessage( - id=item_id, - type="message", - role="assistant", - content=[], - status="in_progress", - ), ) ) + + if not delta and not flush: + continue + + if isinstance(tool_parser, JsonArrayParser): + required_buffer += delta + normal_text, tool_calls = "", [] + if flush and required_buffer.strip(): + tool_calls = [ + ToolCallItem(tool_index=index, name=name, parameters=arguments) + for index, (name, arguments) in enumerate( + validated_json_calls(required_buffer, {tool.function.name for tool in chat_tools}) + ) + ] + elif tool_parser is not None: + normal_text, tool_calls = tool_parser.parse_stream_chunk(delta) + if flush: + end_text, end_calls = tool_parser.parse_stream_end() + normal_text = (normal_text or "") + end_text + tool_calls = list(tool_calls) + end_calls + else: + normal_text, tool_calls = delta, [] + + def _emit_tool_calls(calls): + nonlocal current_output_index + if calls: + if reasoning_state["open"]: + for ev in _close_reasoning_item(): + yield ev + if message_state["open"]: + for ev in _close_message_item(phase="commentary"): + yield ev + + for call in calls: + tool_index = call.tool_index + state = tool_call_states.get(tool_index) + if state is None or state.get("done"): + # Close other open calls first, so their + # output_item.done precedes the next added. + for other_index in list(tool_call_states): + if other_index != tool_index: + for ev in _close_tool_call_state(other_index): + yield ev + current_output_index += 1 + item_id = f"fc_{random_uuid()[:8]}" + call_id = f"call_{random_uuid()[:24]}" + state = { + "item_id": item_id, + "call_id": call_id, + "output_index": current_output_index, + "name": call.name or "", + "arguments": "", + "added": False, + "done": False, + } + tool_call_states[tool_index] = state + if not state["added"]: + if request._compat_registry is not None: + request._compat_registry.output_identity(state["name"]) + state["added"] = True + yield _send_event( + openai_responses_types.ResponseOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=state["output_index"], + item=ResponseFunctionToolCall( + arguments="", + call_id=state["call_id"], + name=state["name"], + type="function_call", + id=state["item_id"], + status="in_progress", + ), + ) + ) + if call.parameters: + state["arguments"] += call.parameters + yield _send_event( + openai_responses_types.ResponseFunctionCallArgumentsDeltaEvent( + type="response.function_call_arguments.delta", + sequence_number=-1, + item_id=state["item_id"], + output_index=state["output_index"], + delta=call.parameters, + ) + ) + + def _emit_normal_text(): + if normal_text and _should_emit_normal_text_as_message( + normal_text, + any_tool_call_in_progress=any( + not s.get("done") for s in tool_call_states.values() + ), + ): + if reasoning_state["open"]: + for ev in _close_reasoning_item(): + yield ev + for tool_index in list(tool_call_states): + for ev in _close_tool_call_state(tool_index): + yield ev + if not message_state["open"]: + item_id = _open_message_item() + yield _send_event( + ResponsePhasedOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=message_state["output_index"], + item=ResponseOutputMessage( + id=item_id, + type="message", + role="assistant", + content=[], + status="in_progress", + # Later reasoning or a tool call may make + # this message commentary. + phase=( + None + if tool_parser is not None + or reasoning_parser_obj is not None + else "final_answer" + ), + ), + ) + ) + yield _send_event( + openai_responses_types.ResponseContentPartAddedEvent( + type="response.content_part.added", + sequence_number=-1, + output_index=message_state["output_index"], + item_id=message_state["item_id"], + content_index=0, + part=openai_responses_types.ResponseOutputText( + type="output_text", + text="", + annotations=[], + logprobs=None, + ), + ) + ) + message_state["text"] += normal_text yield _send_event( - openai_responses_types.ResponseContentPartAddedEvent( - type="response.content_part.added", + openai_responses_types.ResponseTextDeltaEvent( + type="response.output_text.delta", sequence_number=-1, + content_index=0, output_index=message_state["output_index"], item_id=message_state["item_id"], - content_index=0, - part=openai_responses_types.ResponseOutputText( - type="output_text", - text="", - annotations=[], - logprobs=None, - ), + delta=normal_text, + logprobs=[], ) ) - message_state["text"] += normal_text - yield _send_event( - openai_responses_types.ResponseTextDeltaEvent( - type="response.output_text.delta", - sequence_number=-1, - content_index=0, - output_index=message_state["output_index"], - item_id=message_state["item_id"], - delta=normal_text, - logprobs=[], - ) - ) - - # The parser's (text, calls) tuple is unordered, but positions - # are recoverable: continuing arguments precede this delta's - # text, a newly opened call follows it. Classify first -- - # emitting mutates tool_call_states. - def _is_continuing(call): - state = tool_call_states.get(call.tool_index) - return state is not None and not state.get("done") - - continuing = [c for c in tool_calls if _is_continuing(c)] - opening = [c for c in tool_calls if not _is_continuing(c)] - for ev in _emit_tool_calls(continuing): - yield ev - for ev in _emit_normal_text(): - yield ev - for ev in _emit_tool_calls(opening): - yield ev + # The parser's (text, calls) tuple is unordered, but positions + # are recoverable: continuing arguments precede this delta's + # text, a newly opened call follows it. Classify first -- + # emitting mutates tool_call_states. + def _is_continuing(call): + state = tool_call_states.get(call.tool_index) + return state is not None and not state.get("done") + + continuing = [c for c in tool_calls if _is_continuing(c)] + opening = [c for c in tool_calls if not _is_continuing(c)] + + for ev in _emit_tool_calls(continuing): + yield ev + for ev in _emit_normal_text(): + yield ev + for ev in _emit_tool_calls(opening): + yield ev except Exception: logger.exception("Error while streaming /v1/responses") failed = _sanitize_response_dict( diff --git a/scripts/verify_responses_compat.py b/scripts/verify_responses_compat.py index a981c33..b7fff58 100644 --- a/scripts/verify_responses_compat.py +++ b/scripts/verify_responses_compat.py @@ -16,7 +16,8 @@ def digest(path): def package_records(): - manifest = json.loads((ROOT / 'provenance/responses-compat.json').read_text()) + base_manifest = json.loads((ROOT / 'provenance/responses-compat.json').read_text()) + manifest = json.loads((ROOT / 'provenance/responses-phase-order.json').read_text()) records = json.loads((ROOT / 'provenance/production/runtime-files.json').read_text()) for profile in ('chat-effort', 'qwen-effort-alias'): delta = json.loads((ROOT / f'provenance/{profile}.json').read_text()) @@ -24,16 +25,29 @@ def package_records(): if records[name]['sha256'] != hashes['before']: raise ValueError('Predecessor hash mismatch: ' + name) records[name]['sha256'] = hashes['after'] - for name, hashes in manifest['files'].items(): + for name, hashes in base_manifest['files'].items(): if records.get(name, {}).get('sha256') != hashes['before']: raise ValueError('Responses preimage mismatch: ' + name) + records[name] = {**records.get(name, {}), 'sha256': hashes['after']} + patch = ROOT / 'patches' / base_manifest['patch'] + if digest(patch) != base_manifest['patch_sha256']: + raise ValueError('Responses compatibility patch hash mismatch') + base_inventory_path = ROOT / 'provenance/responses-compat-runtime-files.json' + base_inventory = json.loads(base_inventory_path.read_text()) + if base_inventory != {name: row['sha256'] for name, row in sorted(records.items())}: + raise ValueError('Responses compatibility inventory differs') + if digest(base_inventory_path) != base_manifest['inventory_sha256']: + raise ValueError('Responses compatibility inventory digest mismatch') + for name, hashes in manifest['files'].items(): + if records.get(name, {}).get('sha256') != hashes['before']: + raise ValueError('Phase/order preimage mismatch: ' + name) if digest(ROOT / 'runtime' / name) != hashes['after']: raise ValueError('Packaged runtime mismatch: ' + name) records[name] = {**records.get(name, {}), 'sha256': hashes['after']} patch = ROOT / 'patches' / manifest['patch'] if digest(patch) != manifest['patch_sha256']: - raise ValueError('Responses patch hash mismatch') - inventory_path = ROOT / 'provenance/responses-compat-runtime-files.json' + raise ValueError('Phase/order patch hash mismatch') + inventory_path = ROOT / 'provenance' / manifest['inventory'] inventory = json.loads(inventory_path.read_text()) if inventory != {name: row['sha256'] for name, row in sorted(records.items())}: raise ValueError('Full candidate inventory differs from predecessor chain') @@ -48,19 +62,24 @@ def package_records(): ): if digest(ROOT / 'runtime' / name) != inventory[name]: raise ValueError('Packaged runtime mismatch: ' + name) - expected_series = ['0015-qwen-flash-next-effort-alias.patch', manifest['patch']] + expected_series = [ + '0015-qwen-flash-next-effort-alias.patch', + base_manifest['patch'], + manifest['patch'], + ] if (ROOT / 'patches/series.responses-compat').read_text().splitlines() != expected_series: raise ValueError('Candidate patch order differs') - return manifest, inventory + return base_manifest, manifest, inventory def verify(tree, apply=False, from_image=False): - manifest, inventory = package_records() + base_manifest, manifest, inventory = package_records() if apply or from_image: verify_alias(tree, apply=from_image) - patch = ROOT / 'patches' / manifest['patch'] - subprocess.run(['git', 'apply', '--check', str(patch)], cwd=tree, check=True) - subprocess.run(['git', 'apply', str(patch)], cwd=tree, check=True) + for patch_name in (base_manifest['patch'], manifest['patch']): + patch = ROOT / 'patches' / patch_name + subprocess.run(['git', 'apply', '--check', str(patch)], cwd=tree, check=True) + subprocess.run(['git', 'apply', str(patch)], cwd=tree, check=True) actual = {str(path.relative_to(tree)) for path in (tree / 'python/sglang').rglob('*') if path.is_file() and '__pycache__' not in path.parts and path.suffix != '.pyc'} if actual != set(inventory): @@ -76,8 +95,8 @@ def verify(tree, apply=False, from_image=False): parser.add_argument('--tree', type=Path) parser.add_argument('--tokenizer', type=Path) actions = parser.add_mutually_exclusive_group() - actions.add_argument('--apply', action='store_true', help='Apply 0016 to verified alias source') - actions.add_argument('--from-image', action='store_true', help='Apply 0015 then 0016 to exact image source') + actions.add_argument('--apply', action='store_true', help='Apply Responses patches to verified alias source') + actions.add_argument('--from-image', action='store_true', help='Apply 0015 then Responses patches to exact image source') args = parser.parse_args() if args.tokenizer is not None: tokenizer = json.loads((ROOT / 'provenance/qwen-effort-alias.json').read_text())['tokenizer'] @@ -86,6 +105,6 @@ def verify(tree, apply=False, from_image=False): raise ValueError('Tokenizer metadata mismatch: ' + name) if (args.apply or args.from_image) and args.tree is None: parser.error('Application requires --tree') - count = verify(args.tree.resolve(), args.apply, args.from_image) if args.tree else len(package_records()[1]) - print(json.dumps({'profile': 'responses-compat-candidate', 'source_files': count, + count = verify(args.tree.resolve(), args.apply, args.from_image) if args.tree else len(package_records()[2]) + print(json.dumps({'profile': 'responses-phase-order-candidate', 'source_files': count, 'full_tree_verified': args.tree is not None})) diff --git a/tests/runtime_responses_compat.py b/tests/runtime_responses_compat.py index e8913c8..a24a5af 100644 --- a/tests/runtime_responses_compat.py +++ b/tests/runtime_responses_compat.py @@ -1,15 +1,108 @@ """Imported exact-runtime CPU tests. No model/GPU conformance claim.""" +import asyncio import copy import json import unittest +from types import SimpleNamespace +from unittest.mock import Mock from runtime_chat_effort import ChatEffortTest -from sglang.srt.entrypoints.openai.protocol import ResponsesRequest, ResponsesResponse +from sglang.srt.entrypoints.openai.protocol import ( + RequestResponseMetadata, + ResponseOutputMessage, + ResponsesRequest, + ResponsesResponse, +) from sglang.srt.entrypoints.openai.serving_responses import OpenAIServingResponses class ResponsesCompatTest(unittest.TestCase): + @staticmethod + def phase_serving(model_type='qwen3_8_flash_next'): + serving = object.__new__(OpenAIServingResponses) + serving.msg_store = {} + serving.tokenizer_manager = SimpleNamespace( + model_config=SimpleNamespace( + hf_config=SimpleNamespace(model_type=model_type) + ) + ) + return serving + + def test_message_phase_survives_response_models(self): + from openai.types.responses import ResponseOutputText + from sglang.srt.entrypoints.openai.responses_compat import ToolRegistry + + message = ResponseOutputMessage( + id='msg_phase', type='message', role='assistant', status='completed', + phase='commentary', content=[ResponseOutputText( + type='output_text', text='Checking', annotations=[], logprobs=None)], + ) + response = ResponsesResponse( + id='resp_phase', model='fixture', status='completed', output=[message] + ) + self.assertEqual(response.model_dump()['output'][0]['phase'], 'commentary') + converted = ToolRegistry([]).response_model(response) + self.assertEqual(converted.model_dump()['output'][0]['phase'], 'commentary') + + def test_qwen_replay_preserves_assistant_stage_order(self): + serving = self.phase_serving() + request = ResponsesRequest(model='fixture', input=[ + {'role': 'user', 'content': 'Inspect and report'}, + {'type': 'reasoning', 'summary': [ + {'type': 'summary_text', 'text': 'PLAN'}]}, + {'role': 'assistant', 'content': 'CHECKING', 'phase': 'commentary'}, + {'type': 'function_call', 'name': 'inspect', 'call_id': 'call_1', + 'arguments': '{}'}, + {'type': 'reasoning', 'summary': [ + {'type': 'summary_text', 'text': 'SECOND'}]}, + {'role': 'assistant', 'content': 'REPORT', 'phase': 'final_answer'}, + ]) + messages = serving._construct_input_messages(request) + assistants = [message for message in messages if message['role'] == 'assistant'] + self.assertEqual(len(assistants), 2) + self.assertEqual( + (assistants[0]['reasoning_content'], assistants[0]['content'], + assistants[0]['phase'], len(assistants[0]['tool_calls'])), + ('PLAN', 'CHECKING', 'commentary', 1), + ) + self.assertEqual( + (assistants[1]['reasoning_content'], assistants[1]['content'], + assistants[1]['phase']), + ('SECOND', 'REPORT', 'final_answer'), + ) + + def test_stored_response_replays_reasoning_phase_and_call_together(self): + serving = self.phase_serving() + serving.msg_store['resp_prior'] = [ + {'role': 'user', 'content': 'Inspect and report'} + ] + previous = ResponsesResponse.model_validate({ + 'id': 'resp_prior', 'model': 'fixture', 'status': 'completed', + 'output': [ + {'id': 'rs_1', 'type': 'reasoning', 'status': 'completed', + 'summary': [{'type': 'summary_text', 'text': 'PLAN'}], + 'content': []}, + {'id': 'msg_1', 'type': 'message', 'role': 'assistant', + 'status': 'completed', 'phase': 'commentary', + 'content': [{'type': 'output_text', 'text': 'CHECKING', + 'annotations': []}]}, + {'id': 'fc_1', 'type': 'function_call', 'status': 'completed', + 'name': 'inspect', 'call_id': 'call_1', 'arguments': '{}'}, + ], + }) + request = ResponsesRequest(model='fixture', previous_response_id='resp_prior', + input=[{'type': 'function_call_output', + 'call_id': 'call_1', 'output': 'HEALTHY'}]) + messages = serving._construct_input_messages(request, previous) + self.assertEqual([message['role'] for message in messages], + ['user', 'assistant', 'tool']) + assistant = messages[1] + self.assertEqual(assistant['reasoning_content'], 'PLAN') + self.assertEqual(assistant['content'], [{'type': 'text', 'text': 'CHECKING'}]) + self.assertEqual(assistant['phase'], 'commentary') + self.assertEqual(assistant['tool_calls'][0]['id'], 'call_1') + def test_harmony_same_request_call_replay(self): serving = object.__new__(OpenAIServingResponses) serving.tool_server = None @@ -124,6 +217,155 @@ def events(self, response): return [json.loads(line[6:]) for line in response.text.splitlines() if line.startswith('data: ') and line != 'data: [DONE]'] + @staticmethod + def phase_semantics(output): + result = [] + for item in output: + if item['type'] == 'message': + result.append(('message', item['phase'], + ''.join(part['text'] for part in item['content']))) + elif item['type'] == 'reasoning': + result.append(('reasoning', ''.join( + part['text'] for part in item.get('content', [])))) + else: + result.append(('function_call', item['name'], + json.loads(item['arguments']))) + return result + + def test_qwen_stream_preserves_text_tool_text_order_for_any_chunking(self): + self.serving.reasoning_parser = None + self.serving.tool_call_parser = 'qwen3_coder' + tools = [{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}] + raw = ('Checking.' + 'Final answer.') + for incremental in (False, True): + for delivery in ('coalesced', 'characters'): + with self.subTest(incremental=incremental, delivery=delivery): + self.serving.tokenizer_manager.server_args.incremental_streaming_output = incremental + parts = [raw] if delivery == 'coalesced' else list(raw) + + async def generate(request, *args, **kwargs): + cumulative = '' + for index, part in enumerate(parts): + cumulative += part + yield { + 'text': part if incremental else cumulative, + 'output_ids': [1] * (index + 1), + 'meta_info': { + 'prompt_tokens': 10, + 'completion_tokens': index + 1, + 'finish_reason': ( + {'type': 'stop'} if index == len(parts) - 1 else None + ), + }, + } + + self.serving.tokenizer_manager.generate_request = generate + events = self.events(self.send( + stream=True, tools=tools, tool_choice='auto')) + output = next(event['response']['output'] for event in events + if event['type'] == 'response.completed') + self.assertEqual(self.phase_semantics(output), [ + ('message', 'commentary', 'Checking.'), + ('function_call', 'inspect', {}), + ('message', 'final_answer', 'Final answer.'), + ]) + done = [event['item'] for event in events + if event['type'] == 'response.output_item.done'] + self.assertEqual(done, output) + added_messages = [event['item'] for event in events + if event['type'] == 'response.output_item.added' + and event['item']['type'] == 'message'] + self.assertTrue(all(item.get('phase') is None + for item in added_messages)) + + def test_nonstream_message_phase_matches_remaining_tool_calls(self): + self.text = 'Final answer.' + final = self.send(tools=[], tool_choice='none').json()['output'] + self.assertEqual(self.phase_semantics(final), [ + ('message', 'final_answer', 'Final answer.'), + ]) + + self.serving.tool_call_parser = 'qwen3_coder' + self.text = ('Checking.' + '') + tools = [{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}] + mixed = self.send(tools=tools, tool_choice='auto').json()['output'] + self.assertEqual(self.phase_semantics(mixed), [ + ('message', 'commentary', 'Checking.'), + ('function_call', 'inspect', {}), + ]) + + def test_qwen_stream_preserves_renewed_reasoning_order(self): + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = None + self.text = 'Checking.AgainFinal answer.' + events = self.events(self.send( + stream=True, tools=[], tool_choice='none', reasoning={'effort': 'medium'})) + output = next(event['response']['output'] for event in events + if event['type'] == 'response.completed') + self.assertEqual(self.phase_semantics(output), [ + ('message', 'commentary', 'Checking.'), + ('reasoning', 'Again'), + ('message', 'final_answer', 'Final answer.'), + ]) + + def test_text_streams_before_phase_is_resolved(self): + async def check(): + self.serving.reasoning_parser = None + self.serving.tool_call_parser = 'qwen3_coder' + request = ResponsesRequest( + model='fixture-qwen', input='Tell a story', stream=True, + tools=[{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object'}}], tool_choice='auto', + ) + release = asyncio.Event() + + async def generate(): + yield {'text': 'Once upon a time', 'meta_info': { + 'prompt_tokens': 10, 'completion_tokens': 4, + 'finish_reason': None}} + await release.wait() + yield {'text': 'Once upon a time. The end.', 'meta_info': { + 'prompt_tokens': 10, 'completion_tokens': 8, + 'finish_reason': {'type': 'stop'}}} + + stream = self.serving.responses_stream_generator_non_harmony( + request, {}, generate(), 'fixture-qwen', Mock(), + RequestResponseMetadata(request_id=request.request_id), + require_reasoning=False, + ) + events = [] + try: + async def first_text(): + async for frame in stream: + event = json.loads(frame.split('data: ', 1)[1]) + events.append(event) + if event['type'] == 'response.output_text.delta': + return event['delta'] + self.fail('stream ended before emitting text') + + self.assertEqual( + await asyncio.wait_for(first_text(), timeout=1), + 'Once upon a time', + ) + added = next(event['item'] for event in events + if event['type'] == 'response.output_item.added') + self.assertIsNone(added.get('phase')) + release.set() + async for frame in stream: + events.append(json.loads(frame.split('data: ', 1)[1])) + done = next(event['item'] for event in events + if event['type'] == 'response.output_item.done') + self.assertEqual(done['phase'], 'final_answer') + finally: + release.set() + await stream.aclose() + + asyncio.run(check()) + def test_fix2_embedded_identity_rejection(self): for stream in (False, True): for embedded in (False, True): diff --git a/tests/test_responses_packaging.py b/tests/test_responses_packaging.py index 0708cd7..9be2c5d 100644 --- a/tests/test_responses_packaging.py +++ b/tests/test_responses_packaging.py @@ -15,13 +15,16 @@ class ResponsesPackagingTest(unittest.TestCase): def test_full_manifest_chain_and_new_file_count(self): - manifest, inventory = verifier.package_records() + base_manifest, manifest, inventory = verifier.package_records() self.assertEqual(len(inventory), 4392) - self.assertEqual([name for name, hashes in manifest['files'].items() if hashes['before'] is None], + self.assertEqual([name for name, hashes in base_manifest['files'].items() + if hashes['before'] is None], ['python/sglang/srt/entrypoints/openai/responses_compat.py']) + self.assertFalse([name for name, hashes in manifest['files'].items() + if hashes['before'] is None]) base = json.loads((ROOT / 'provenance/production/runtime-files.json').read_text()) self.assertEqual(len(base), 4391) - for name in manifest['files']: + for name in set(base_manifest['files']) | set(manifest['files']): compile((ROOT / 'runtime' / name).read_bytes(), name, 'exec') def test_packaged_source_drift_fails_closed(self): @@ -47,10 +50,11 @@ def changed(path): def test_patch_drift_fails_closed(self): original = verifier.digest + for prefix in ('0016-', '0017-'): + with self.subTest(prefix=prefix): + def changed(path): + return '0' * 64 if path.name.startswith(prefix) else original(path) - def changed(path): - return '0' * 64 if path.name.startswith('0016-') else original(path) - - with patch.object(verifier, 'digest', side_effect=changed): - with self.assertRaisesRegex(ValueError, 'patch hash mismatch'): - verifier.package_records() + with patch.object(verifier, 'digest', side_effect=changed): + with self.assertRaisesRegex(ValueError, 'patch hash mismatch'): + verifier.package_records() From ed43202a522bc2a09eb08ebdc89705afc355030e Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 12:06:35 +0100 Subject: [PATCH 04/20] fix(responses): preserve nonstream phase order Reuse the ordered Qwen parser for complete outputs whose tool or renewed-reasoning boundaries would otherwise collapse. Add focused regressions and refresh the cumulative source attestations on merged minimal-effort alias main. --- README.md | 5 +- docs/responses-compat.md | 11 ++- patches/0017-responses-phase-order.patch | 82 ++++++++++++++----- provenance/responses-compat.json | 4 +- .../responses-phase-order-runtime-files.json | 4 +- provenance/responses-phase-order.json | 11 +-- .../entrypoints/openai/serving_responses.py | 37 +++++++++ tests/runtime_responses_compat.py | 27 ++++++ 8 files changed, 148 insertions(+), 33 deletions(-) diff --git a/README.md b/README.md index 76ebd6a..c55b439 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,9 @@ # Qwen TP2 packed-PLE vision on SM120 **Unpublished CPU candidate:** [Responses compatibility and Qwen phase/order](docs/responses-compat.md) -adds separately attested boundary and streaming-order patches after the effort-alias -profile. Historical production profiles below are unchanged; no deployment is implied. +adds separately attested boundary and streaming/nonstream ordering patches after the +effort-alias profile, including its `minimal` → `low` alias. Historical production +profiles below are unchanged; no deployment is implied. Publishable source and deployment package for the locally accepted Qwen3.8 Flash-Next LIL NVFP4 stack. **No model weights, container archives, credentials, diff --git a/docs/responses-compat.md b/docs/responses-compat.md index e6eb0c1..030481d 100644 --- a/docs/responses-compat.md +++ b/docs/responses-compat.md @@ -1,6 +1,9 @@ # Responses compatibility and Qwen phase/order — CPU candidate only -This profile follows alias commit `04e0816a68638e85ddd4ff8764b401d3ed27997e`. +This profile is rebased on main `de9abbe3d10c0510ac7eba898fcf721b6a73a41d`. +Its alias predecessor commit `dccd493277c1adb71a3aefe3b4f2513e13e14206` +includes the Qwen `minimal` → `low` rendering alias as well as `high`/`max` → +`xhigh`. It does not upgrade the engine, change kernels/schedulers/checkpoints, or change any deployment. No image is built or published. Historical production, combined, Chat-effort and alias manifests/series retain their original meanings. @@ -86,9 +89,11 @@ The only new installed module is `responses_compat.py`. Streaming text is emitted immediately; an added message leaves phase unresolved when later reasoning or tool output can still change it. The completed item sets commentary when a tool call or renewed reasoning follows and final_answer when - the text ends the response. + the text ends the response. For affected Qwen complete outputs, nonstream reuses + that ordered parser path when a tool or renewed-reasoning boundary would otherwise + collapse items, preserving text → tool → text and text → reasoning → final parity. - Qwen3.8 Flash-Next markup is fed to the existing reasoning and tool parsers at - markup boundaries. Coalesced and fragmented engine chunks therefore preserve + markup boundaries. Coalesced, fragmented, and affected complete outputs preserve `reasoning -> text -> tool -> text` wire order instead of merging text across a tool call. Literal angle-bracket text still passes through the parsers. - Replay groups adjacent Qwen assistant items only while their stage order remains diff --git a/patches/0017-responses-phase-order.patch b/patches/0017-responses-phase-order.patch index 0f837b0..d87c52b 100644 --- a/patches/0017-responses-phase-order.patch +++ b/patches/0017-responses-phase-order.patch @@ -62,7 +62,7 @@ index c120d0a..44c91a1 100644 continue for c in it.content: diff --git a/python/sglang/srt/entrypoints/openai/serving_responses.py b/python/sglang/srt/entrypoints/openai/serving_responses.py -index 2fda942..18931fb 100644 +index 2fda942..49881f0 100644 --- a/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -7,6 +7,7 @@ from __future__ import annotations @@ -91,7 +91,51 @@ index 2fda942..18931fb 100644 ResponsesRequest, ResponsesResponse, Tool, -@@ -1009,6 +1012,7 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -737,6 +740,43 @@ class OpenAIServingResponses(OpenAIServingChat): + meta_info.get("finish_reason") if meta_info is not None else None + ) + ++ final_text = final_res["text"] ++ model_type = self.tokenizer_manager.model_config.hf_config.model_type ++ leading_text, think_marker, _ = final_text.partition("") ++ needs_ordered_qwen_parse = ( ++ status == "completed" ++ and model_type ++ in {"qwen3_8_flash_next", "qwen3_8_flash_next_text", "qwen4_exp"} ++ and ( ++ re.search( ++ r"\s*\s*\S", final_text, re.DOTALL ++ ) ++ or (think_marker and leading_text.strip()) ++ ) ++ ) ++ if needs_ordered_qwen_parse: ++ async def final_result(): ++ yield final_res ++ ++ terminal_response = None ++ async for frame in self.responses_stream_generator_non_harmony( ++ request, ++ sampling_params, ++ final_result(), ++ model_name, ++ tokenizer, ++ request_metadata, ++ created_time=created_time, ++ require_reasoning=require_reasoning, ++ ): ++ event = json.loads(frame.split("data: ", 1)[1]) ++ if event.get("type") == "response.completed": ++ terminal_response = event["response"] ++ if terminal_response is None: ++ raise ValueError("Ordered Qwen output did not complete") ++ terminal_response["tools"] = request.model_dump()["tools"] ++ return ResponsesResponse.model_validate(terminal_response) ++ + output_logprobs = ( + _build_output_text_logprobs(meta_info) + if request.is_include_output_logprobs() and isinstance(meta_info, dict) +@@ -1009,6 +1049,7 @@ class OpenAIServingResponses(OpenAIServingChat): role="assistant", status="completed", type="message", @@ -99,7 +143,7 @@ index 2fda942..18931fb 100644 ) output_items.append(message) output_items.extend(tool_call_items) -@@ -1232,10 +1236,39 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -1232,10 +1273,39 @@ class OpenAIServingResponses(OpenAIServingChat): @staticmethod def _merge_consecutive_assistant_messages( messages: list, @@ -139,7 +183,7 @@ index 2fda942..18931fb 100644 merged: list = [] for msg in messages: if ( -@@ -1244,8 +1277,16 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -1244,8 +1314,16 @@ class OpenAIServingResponses(OpenAIServingChat): and merged and isinstance(merged[-1], dict) and merged[-1].get("role") == "assistant" @@ -156,7 +200,7 @@ index 2fda942..18931fb 100644 # Lift mixed str/list content to list parts so non-text parts # (e.g. image_url) survive when the two sides differ in shape. new_content = msg.get("content") -@@ -1305,13 +1346,9 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -1305,13 +1383,9 @@ class OpenAIServingResponses(OpenAIServingChat): messages.extend(prev_msg) for output_item in prev_response.output: @@ -173,7 +217,7 @@ index 2fda942..18931fb 100644 # Append the new input # Responses API supports simple text inputs without chat format -@@ -1326,7 +1363,15 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -1326,7 +1400,15 @@ class OpenAIServingResponses(OpenAIServingChat): # One Responses-API assistant turn maps to multiple input items # (message + function_call(s)); collapse them into one chat message # so chat templates render a single assistant block per turn. @@ -190,7 +234,7 @@ index 2fda942..18931fb 100644 # Most chat templates expect a single leading ``system`` message; # coalesce any ``instructions`` + interleaved ``developer`` entries. -@@ -2091,6 +2136,16 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2091,6 +2173,16 @@ class OpenAIServingResponses(OpenAIServingChat): tool_call_parser_active=isinstance(tool_parser, FunctionCallParser), ) @@ -207,7 +251,7 @@ index 2fda942..18931fb 100644 current_output_index = -1 reasoning_state = { "open": False, -@@ -2211,7 +2266,7 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2211,7 +2303,7 @@ class OpenAIServingResponses(OpenAIServingChat): ) return item_id @@ -216,7 +260,7 @@ index 2fda942..18931fb 100644 if not message_state["open"]: return [] text = message_state["text"] -@@ -2224,6 +2279,7 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2224,6 +2316,7 @@ class OpenAIServingResponses(OpenAIServingChat): role="assistant", content=[text_content], status="completed", @@ -224,7 +268,7 @@ index 2fda942..18931fb 100644 ) events = [ _send_event( -@@ -2248,7 +2304,7 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2248,7 +2341,7 @@ class OpenAIServingResponses(OpenAIServingChat): ) ), _send_event( @@ -233,7 +277,7 @@ index 2fda942..18931fb 100644 type="response.output_item.done", sequence_number=-1, output_index=message_state["output_index"], -@@ -2335,241 +2391,259 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2335,241 +2428,259 @@ class OpenAIServingResponses(OpenAIServingChat): ) flushed = flushed or flush @@ -300,10 +344,7 @@ index 2fda942..18931fb 100644 - ), - sequence_number=-1, - ) -+ if flush: -+ end_reasoning, end_normal = ( -+ reasoning_parser_obj.parse_stream_end() - ) +- ) - reasoning_state["text"] += reasoning_chunk - if wants_summary: - yield _send_event( @@ -314,7 +355,10 @@ index 2fda942..18931fb 100644 - summary_index=0, - delta=reasoning_chunk, - sequence_number=-1, -- ) ++ if flush: ++ end_reasoning, end_normal = ( ++ reasoning_parser_obj.parse_stream_end() + ) - ) + if end_reasoning: + reasoning_chunk = (reasoning_chunk or "") + end_reasoning @@ -331,11 +375,11 @@ index 2fda942..18931fb 100644 - sequence_number=-1, - ) - ) -+ reasoning_chunk = None - +- - if not delta and not flush: - continue -- ++ reasoning_chunk = None + - if isinstance(tool_parser, JsonArrayParser): - required_buffer += delta - normal_text, tool_calls = "", [] diff --git a/provenance/responses-compat.json b/provenance/responses-compat.json index 6583b6d..8fdfa35 100644 --- a/provenance/responses-compat.json +++ b/provenance/responses-compat.json @@ -1,6 +1,6 @@ { - "status": "CPU-only candidate; uncommitted, not published or deployed", - "base_alias_commit": "04e0816a68638e85ddd4ff8764b401d3ed27997e", + "status": "CPU-only candidate; not published or deployed", + "base_alias_commit": "dccd493277c1adb71a3aefe3b4f2513e13e14206", "base_image": "kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", "predecessor_profile": "qwen-effort-alias", "patch": "0016-responses-namespace-custom-boundary.patch", diff --git a/provenance/responses-phase-order-runtime-files.json b/provenance/responses-phase-order-runtime-files.json index c5a0f70..30937ea 100644 --- a/provenance/responses-phase-order-runtime-files.json +++ b/provenance/responses-phase-order-runtime-files.json @@ -2483,12 +2483,12 @@ "python/sglang/srt/entrypoints/openai/realtime/session.py": "3689c4b302059606ca144e782dd171f14a173881fb58365adc66021d8e17ce87", "python/sglang/srt/entrypoints/openai/responses_compat.py": "72bfe1e5e45073d57f09dc90ba7b2ea6b87df932cfbcb67ed8116f25c5830037", "python/sglang/srt/entrypoints/openai/serving_base.py": "3d0613b92abae51e8566a11ae80a2369a46422b49bd63c4cd6aa593d8a4bdbc2", - "python/sglang/srt/entrypoints/openai/serving_chat.py": "6d881d19da2c4a7028b0fb179cf5cdb958480612d4192c1606dfd25f98a9ba56", + "python/sglang/srt/entrypoints/openai/serving_chat.py": "07ccd04de5f716277d2df873f66bdc4c03d13f7e89aad105c6dcba979ff47931", "python/sglang/srt/entrypoints/openai/serving_classify.py": "b05079d8e3930397653a4ddcdef560250d6d7cf3a3af0cd749a9e7ed7c679005", "python/sglang/srt/entrypoints/openai/serving_completions.py": "67f08075f21481b03e246327c7453f57ac001d0f3e78f5a9247caa553e1942e3", "python/sglang/srt/entrypoints/openai/serving_embedding.py": "cf1b283df88e1286b7f803f2173bf89499c65e25c93462bc299b2c64539d77b8", "python/sglang/srt/entrypoints/openai/serving_rerank.py": "5242cd42c8ccba74fbdf13e2c7eee63b5551e3d6bef09933aba213d690cb3329", - "python/sglang/srt/entrypoints/openai/serving_responses.py": "2d74b6b58076ae90770198c73f99bee6442fa6d006ae49f2118d02012ea51371", + "python/sglang/srt/entrypoints/openai/serving_responses.py": "a0862c742ff1d8586808c4cbf077e8897d26b2497e0088af44f0f59868908748", "python/sglang/srt/entrypoints/openai/serving_score.py": "203748c564cd979d03d54dee44140c63caef59490d1ca508ccb1aca3f69ffccd", "python/sglang/srt/entrypoints/openai/serving_tokenize.py": "f1791dbe89245cf80f2ae3c3f052e944c0b602deaf45909a31d2e4aabfc95711", "python/sglang/srt/entrypoints/openai/serving_transcription.py": "0f15eac62ea22d5cd531f19e9419a5db61f6a3109a25f0e6d87e84d215c4128d", diff --git a/provenance/responses-phase-order.json b/provenance/responses-phase-order.json index e10162b..089375e 100644 --- a/provenance/responses-phase-order.json +++ b/provenance/responses-phase-order.json @@ -1,9 +1,9 @@ { "status": "CPU-only candidate; not deployed", - "base_main_commit": "93463c3466b0de9d21776fbeff95657285df8269", + "base_main_commit": "de9abbe3d10c0510ac7eba898fcf721b6a73a41d", "predecessor_profile": "responses-compat", "patch": "0017-responses-phase-order.patch", - "patch_sha256": "b076ed8dcf170e8a0116866618547b0b5399e912eb26153f6d5b8fcc6f4707b1", + "patch_sha256": "194a4d818cbf1484565a7c52f31480476046d21d4fd6488c4afdb27c8fc5e7e2", "files": { "python/sglang/srt/entrypoints/openai/protocol.py": { "before": "fbc60d3206612f408d93f786b18446ab96c258ff60bf1f1c4cf0e36e3c88eca1", @@ -11,16 +11,17 @@ }, "python/sglang/srt/entrypoints/openai/serving_responses.py": { "before": "d46f648b557db07a430869471fcf4d7a898d50f99e495efd5eb01911c428f215", - "after": "2d74b6b58076ae90770198c73f99bee6442fa6d006ae49f2118d02012ea51371" + "after": "a0862c742ff1d8586808c4cbf077e8897d26b2497e0088af44f0f59868908748" } }, "source_files_before": 4392, "source_files_after": 4392, "inventory": "responses-phase-order-runtime-files.json", - "inventory_sha256": "32d6b2d6749c2a7d99822805bf331291e03a153d872f71eded2df6d33615be9c", + "inventory_sha256": "c0fa153a33b23a25e7b97ec432c518afb7b49dc8391f971138afda14f30c9759", "scope": [ "Responses message phase serialization", "Qwen reasoning, text, and tool replay ordering", - "Qwen streaming markup boundary ordering" + "Qwen streaming markup boundary ordering", + "Qwen nonstream ordered-item parity with streaming" ] } diff --git a/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py b/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py index 18931fb..49881f0 100644 --- a/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -740,6 +740,43 @@ async def responses_full_generator( meta_info.get("finish_reason") if meta_info is not None else None ) + final_text = final_res["text"] + model_type = self.tokenizer_manager.model_config.hf_config.model_type + leading_text, think_marker, _ = final_text.partition("") + needs_ordered_qwen_parse = ( + status == "completed" + and model_type + in {"qwen3_8_flash_next", "qwen3_8_flash_next_text", "qwen4_exp"} + and ( + re.search( + r"\s*\s*\S", final_text, re.DOTALL + ) + or (think_marker and leading_text.strip()) + ) + ) + if needs_ordered_qwen_parse: + async def final_result(): + yield final_res + + terminal_response = None + async for frame in self.responses_stream_generator_non_harmony( + request, + sampling_params, + final_result(), + model_name, + tokenizer, + request_metadata, + created_time=created_time, + require_reasoning=require_reasoning, + ): + event = json.loads(frame.split("data: ", 1)[1]) + if event.get("type") == "response.completed": + terminal_response = event["response"] + if terminal_response is None: + raise ValueError("Ordered Qwen output did not complete") + terminal_response["tools"] = request.model_dump()["tools"] + return ResponsesResponse.model_validate(terminal_response) + output_logprobs = ( _build_output_text_logprobs(meta_info) if request.is_include_output_logprobs() and isinstance(meta_info, dict) diff --git a/tests/runtime_responses_compat.py b/tests/runtime_responses_compat.py index a24a5af..4aa805a 100644 --- a/tests/runtime_responses_compat.py +++ b/tests/runtime_responses_compat.py @@ -280,6 +280,20 @@ async def generate(request, *args, **kwargs): self.assertTrue(all(item.get('phase') is None for item in added_messages)) + def test_qwen_nonstream_preserves_text_tool_text_order(self): + self.serving.reasoning_parser = None + self.serving.tool_call_parser = 'qwen3_coder' + self.text = ('Checking.' + 'Final answer.') + tools = [{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}] + output = self.send(tools=tools, tool_choice='auto').json()['output'] + self.assertEqual(self.phase_semantics(output), [ + ('message', 'commentary', 'Checking.'), + ('function_call', 'inspect', {}), + ('message', 'final_answer', 'Final answer.'), + ]) + def test_nonstream_message_phase_matches_remaining_tool_calls(self): self.text = 'Final answer.' final = self.send(tools=[], tool_choice='none').json()['output'] @@ -298,6 +312,19 @@ def test_nonstream_message_phase_matches_remaining_tool_calls(self): ('function_call', 'inspect', {}), ]) + def test_qwen_nonstream_preserves_renewed_reasoning_order(self): + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = None + self.text = 'Checking.AgainFinal answer.' + output = self.send( + tools=[], tool_choice='none', reasoning={'effort': 'medium'} + ).json()['output'] + self.assertEqual(self.phase_semantics(output), [ + ('message', 'commentary', 'Checking.'), + ('reasoning', 'Again'), + ('message', 'final_answer', 'Final answer.'), + ]) + def test_qwen_stream_preserves_renewed_reasoning_order(self): self.serving.reasoning_parser = 'qwen3' self.serving.tool_call_parser = None From df22281b6d35fc04f802a9384b22297c0857c8cd Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 12:29:13 +0100 Subject: [PATCH 05/20] test(responses): capture PR5 merge-gate regressions --- provenance/pr5-merge-gate-red.json | 30 ++++ provenance/pr5-merge-gate-red.log | 265 +++++++++++++++++++++++++++++ tests/runtime_responses_compat.py | 149 ++++++++++++++++ 3 files changed, 444 insertions(+) create mode 100644 provenance/pr5-merge-gate-red.json create mode 100644 provenance/pr5-merge-gate-red.log diff --git a/provenance/pr5-merge-gate-red.json b/provenance/pr5-merge-gate-red.json new file mode 100644 index 0000000..895bf67 --- /dev/null +++ b/provenance/pr5-merge-gate-red.json @@ -0,0 +1,30 @@ +{ + "phase": "RED", + "reviewed_head": "ed43202a522bc2a09eb08ebdc89705afc355030e", + "image": "kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", + "command": "docker run --rm --pull never --network none --read-only --cap-drop ALL --security-opt no-new-privileges --cpus 4 --memory 12g --pids-limit 512 --tmpfs /tmp:rw,exec,size=2g --tmpfs /root/.cache:rw,exec,size=1g -e CUDA_VISIBLE_DEVICES= -e OMP_NUM_THREADS=1 -e MKL_NUM_THREADS=1 -e XDG_CACHE_HOME=/tmp/cache -e PYTHONDONTWRITEBYTECODE=1 -e QWEN_TOKENIZER_PATH=/tokenizer -v /home/kanadaj/sglang-tuning/qwen-effort-alias-patch/tokenizer:/tokenizer:ro -v $PWD:/repo:ro [five candidate runtime mounts] --entrypoint python3 /repo/tests/runtime_responses_compat.py -v", + "result": { + "exit_code": 1, + "tests_run": 65, + "failures": 4, + "errors": 0 + }, + "expected_failures": [ + "test_qwen_ordered_nonstream_preserves_usage_details", + "test_qwen_ordered_nonstream_preserves_requested_logprobs", + "test_qwen_stream_has_no_generic_angle_boundary_split", + "test_qwen4_exp_is_negative_control_for_ordered_nonstream" + ], + "required_order_controls_that_passed": [ + "test_qwen_nonstream_preserves_text_tool_text_order", + "test_qwen_nonstream_preserves_renewed_reasoning_order", + "test_qwen_stream_preserves_text_tool_text_order_for_any_chunking", + "test_qwen_stream_preserves_renewed_reasoning_order", + "test_qwen_literal_angle_brackets_survive_text_tool_text", + "test_mock_http_custom_literal_angles_preserve_order_and_payload" + ], + "sha256": { + "tests/runtime_responses_compat.py": "425fa143fab49c3d50f5e64d4d196b54d0eabb46597173c2e30d70d4632ca0ce", + "provenance/pr5-merge-gate-red.log": "334ded3fd795f667a6399d96ba80adbee07f968564e9dc898dd9e691dddcf1ab" + } +} diff --git a/provenance/pr5-merge-gate-red.log b/provenance/pr5-merge-gate-red.log new file mode 100644 index 0000000..2235b49 --- /dev/null +++ b/provenance/pr5-merge-gate-red.log @@ -0,0 +1,265 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 11:28:36.669000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok +test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok +test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok +test_top_level_xhigh_reaches_real_tokenizer (runtime_chat_effort.ChatEffortTest.test_top_level_xhigh_reaches_real_tokenizer) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:1039: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field + "max_new_tokens": self.max_completion_tokens or self.max_tokens, +ok +test_background_requires_storage (__main__.MockHTTPTest.test_background_requires_storage) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:276: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(error)) +ok +test_direct_flat_result_retains_typed_api (__main__.MockHTTPTest.test_direct_flat_result_retains_typed_api) ... ok +test_failed_and_disconnected_stream_preserves_stored_identity (__main__.MockHTTPTest.test_failed_and_disconnected_stream_preserves_stored_identity) ... Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2523, in responses_stream_generator_non_harmony + tool_calls = [ + ^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 42, in validated_json_calls + raise ValueError("Unknown generated tool identity in required output") +ValueError: Unknown generated tool identity in required output +ok +test_fix2_custom_delimiter_limit_and_json_alternative (__main__.MockHTTPTest.test_fix2_custom_delimiter_limit_and_json_alternative) ... Parsed parameter 'other' is not defined in the tool parameters for tool 'patch', directly returning the string value. +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:629: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) +Parsed parameter 'other' is not defined in the tool parameters for tool 'patch', directly returning the string value. +ok +test_fix2_custom_history_rejects_embedded_function_after_gap (__main__.MockHTTPTest.test_fix2_custom_history_rejects_embedded_function_after_gap) ... ok +test_fix2_embedded_flat_and_history (__main__.MockHTTPTest.test_fix2_embedded_flat_and_history) ... ok +test_fix2_embedded_identity_rejection (__main__.MockHTTPTest.test_fix2_embedded_identity_rejection) ... ok +test_fix2_embedded_supported_and_custom_distinctions (__main__.MockHTTPTest.test_fix2_embedded_supported_and_custom_distinctions) ... ok +test_fix2_selected_single_required_multiple (__main__.MockHTTPTest.test_fix2_selected_single_required_multiple) ... ok +test_fix2_terminal_cardinality (__main__.MockHTTPTest.test_fix2_terminal_cardinality) ... ok +test_fix2_unsupported_embedded_forms (__main__.MockHTTPTest.test_fix2_unsupported_embedded_forms) ... ok +test_fix3_malformed_success_remains_rejected (__main__.MockHTTPTest.test_fix3_malformed_success_remains_rejected) ... Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2523, in responses_stream_generator_non_harmony + tool_calls = [ + ^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 35, in validated_json_calls + calls = json.loads(content) + ^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/__init__.py", line 346, in loads + return _default_decoder.decode(s) + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/decoder.py", line 337, in decode + obj, end = self.raw_decode(s, idx=_w(s, 0).end()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/decoder.py", line 353, in raw_decode + obj, end = self.scan_once(s, idx) + ^^^^^^^^^^^^^^^^^^^^^^ +json.decoder.JSONDecodeError: Unterminated string starting at: line 1 column 39 (char 38) +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2523, in responses_stream_generator_non_harmony + tool_calls = [ + ^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 35, in validated_json_calls + calls = json.loads(content) + ^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/__init__.py", line 346, in loads + return _default_decoder.decode(s) + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/decoder.py", line 337, in decode + obj, end = self.raw_decode(s, idx=_w(s, 0).end()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/decoder.py", line 353, in raw_decode + obj, end = self.scan_once(s, idx) + ^^^^^^^^^^^^^^^^^^^^^^ +json.decoder.JSONDecodeError: Unterminated string starting at: line 1 column 39 (char 38) +ok +test_fix3_native_auto_terminal_text (__main__.MockHTTPTest.test_fix3_native_auto_terminal_text) ... ok +test_fix3_partial_no_store (__main__.MockHTTPTest.test_fix3_partial_no_store) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1633: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_fix3_partial_terminal_matrix (__main__.MockHTTPTest.test_fix3_partial_terminal_matrix) ... ok +test_fix3_terminal_text_and_no_store (__main__.MockHTTPTest.test_fix3_terminal_text_and_no_store) ... ok +test_fixer_conflicting_forced_representations_before_generation (__main__.MockHTTPTest.test_fixer_conflicting_forced_representations_before_generation) ... ok +test_fixer_descriptions_reach_rendered_prompt (__main__.MockHTTPTest.test_fixer_descriptions_reach_rendered_prompt) ... ok +test_fixer_generated_history_survives_output_only_and_multiple_turns (__main__.MockHTTPTest.test_fixer_generated_history_survives_output_only_and_multiple_turns) ... Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2523, in responses_stream_generator_non_harmony + tool_calls = [ + ^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 42, in validated_json_calls + raise ValueError("Unknown generated tool identity in required output") +ValueError: Unknown generated tool identity in required output +ok +test_fixer_image_history_survives_no_declaration_gaps (__main__.MockHTTPTest.test_fixer_image_history_survives_no_declaration_gaps) ... ok +test_fixer_pinned_sdk_client_terminal_roundtrip (__main__.MockHTTPTest.test_fixer_pinned_sdk_client_terminal_roundtrip) ... /usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +/usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +/usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +ok +test_fixer_pinned_sdk_output_and_event_roundtrip_replay (__main__.MockHTTPTest.test_fixer_pinned_sdk_output_and_event_roundtrip_replay) ... ok +test_fixer_whole_history_collision_parity (__main__.MockHTTPTest.test_fixer_whole_history_collision_parity) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:276: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(error)) +ok +test_mock_http_custom_literal_angles_preserve_order_and_payload (__main__.MockHTTPTest.test_mock_http_custom_literal_angles_preserve_order_and_payload) ... ok +test_mock_http_custom_native_empty_and_escaped (__main__.MockHTTPTest.test_mock_http_custom_native_empty_and_escaped) ... ok +test_mock_http_custom_raw_and_stateless_replay (__main__.MockHTTPTest.test_mock_http_custom_raw_and_stateless_replay) ... ok +test_mock_http_flat_history_without_active_tools (__main__.MockHTTPTest.test_mock_http_flat_history_without_active_tools) ... ok +test_mock_http_flat_regression (__main__.MockHTTPTest.test_mock_http_flat_regression) ... ok +test_mock_http_forced_choice_cannot_emit_other_declared_tool (__main__.MockHTTPTest.test_mock_http_forced_choice_cannot_emit_other_declared_tool) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:629: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2682, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2573, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 121, in output_identity + raise ValueError("Generated tool call does not match forced tool choice") +ValueError: Generated tool call does not match forced tool choice +ok +test_mock_http_json_schema_and_explicit_nulls (__main__.MockHTTPTest.test_mock_http_json_schema_and_explicit_nulls) ... ok +test_mock_http_multimodal_tool_result_and_alias_provenance (__main__.MockHTTPTest.test_mock_http_multimodal_tool_result_and_alias_provenance) ... ok +test_mock_http_namespace_nonstream_and_stateful_replay (__main__.MockHTTPTest.test_mock_http_namespace_nonstream_and_stateful_replay) ... ok +test_mock_http_namespace_sse_lifecycle (__main__.MockHTTPTest.test_mock_http_namespace_sse_lifecycle) ... ok +test_mock_http_native_auto_and_required (__main__.MockHTTPTest.test_mock_http_native_auto_and_required) ... ok +test_mock_http_native_unknown_fails_closed (__main__.MockHTTPTest.test_mock_http_native_unknown_fails_closed) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2682, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2573, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 122, in output_identity + return self.identity(qualified) + ^^^^^^^^^^^^^^^^^^^^^^^^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 116, in identity + raise ValueError(f"Unknown generated tool identity: {qualified}") +ValueError: Unknown generated tool identity: workspace.NOT_DECLARED +ok +test_mock_http_parallel_dotted_and_duplicate_local_names (__main__.MockHTTPTest.test_mock_http_parallel_dotted_and_duplicate_local_names) ... ok +test_mock_http_rejected_call_cannot_be_replayed_from_store (__main__.MockHTTPTest.test_mock_http_rejected_call_cannot_be_replayed_from_store) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1633: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_mock_http_rejects_unknown_and_forced_invalid (__main__.MockHTTPTest.test_mock_http_rejects_unknown_and_forced_invalid) ... Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2523, in responses_stream_generator_non_harmony + tool_calls = [ + ^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 42, in validated_json_calls + raise ValueError("Unknown generated tool identity in required output") +ValueError: Unknown generated tool identity in required output +ok +test_mock_http_replay_cannot_forge_flat_dotted_identity (__main__.MockHTTPTest.test_mock_http_replay_cannot_forge_flat_dotted_identity) ... ok +test_mock_http_request_provenance_and_unrelated_model (__main__.MockHTTPTest.test_mock_http_request_provenance_and_unrelated_model) ... ok +test_nonstream_message_phase_matches_remaining_tool_calls (__main__.MockHTTPTest.test_nonstream_message_phase_matches_remaining_tool_calls) ... ok +test_qwen4_exp_is_negative_control_for_ordered_nonstream (__main__.MockHTTPTest.test_qwen4_exp_is_negative_control_for_ordered_nonstream) ... FAIL +test_qwen_literal_angle_brackets_survive_text_tool_text (__main__.MockHTTPTest.test_qwen_literal_angle_brackets_survive_text_tool_text) ... ok +test_qwen_nonstream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_renewed_reasoning_order) ... ok +test_qwen_nonstream_preserves_text_tool_text_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_text_tool_text_order) ... ok +test_qwen_ordered_nonstream_preserves_requested_logprobs (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_requested_logprobs) ... FAIL +test_qwen_ordered_nonstream_preserves_usage_details (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_usage_details) ... FAIL +test_qwen_stream_has_no_generic_angle_boundary_split (__main__.MockHTTPTest.test_qwen_stream_has_no_generic_angle_boundary_split) ... FAIL +test_qwen_stream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_stream_preserves_renewed_reasoning_order) ... ok +test_qwen_stream_preserves_text_tool_text_order_for_any_chunking (__main__.MockHTTPTest.test_qwen_stream_preserves_text_tool_text_order_for_any_chunking) ... ok +test_text_streams_before_phase_is_resolved (__main__.MockHTTPTest.test_text_streams_before_phase_is_resolved) ... ok +test_collisions_and_malformed_members (__main__.ResponsesCompatTest.test_collisions_and_malformed_members) ... ok +test_custom_declaration_reaches_chat (__main__.ResponsesCompatTest.test_custom_declaration_reaches_chat) ... ok +test_custom_grammar_visible (__main__.ResponsesCompatTest.test_custom_grammar_visible) ... ok +test_harmony_same_request_call_replay (__main__.ResponsesCompatTest.test_harmony_same_request_call_replay) ... ok +test_image_result_preserved (__main__.ResponsesCompatTest.test_image_result_preserved) ... ok +test_message_phase_survives_response_models (__main__.ResponsesCompatTest.test_message_phase_survives_response_models) ... ok +test_namespace_declaration_reaches_chat (__main__.ResponsesCompatTest.test_namespace_declaration_reaches_chat) ... ok +test_qualified_replay (__main__.ResponsesCompatTest.test_qualified_replay) ... ok +test_qwen_replay_preserves_assistant_stage_order (__main__.ResponsesCompatTest.test_qwen_replay_preserves_assistant_stage_order) ... ok +test_stored_response_replays_reasoning_phase_and_call_together (__main__.ResponsesCompatTest.test_stored_response_replays_reasoning_phase_and_call_together) ... ok + +====================================================================== +FAIL: test_qwen4_exp_is_negative_control_for_ordered_nonstream (__main__.MockHTTPTest.test_qwen4_exp_is_negative_control_for_ordered_nonstream) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 412, in test_qwen4_exp_is_negative_control_for_ordered_nonstream + self.assertEqual(self.phase_semantics(output), [ +AssertionError: Lists differ: [('me[27 chars]king.'), ('function_call', 'inspect', {}), ('m[37 chars]r.')] != [('me[27 chars]king.Final answer.'), ('function_call', 'inspect', {})] + +First differing element 0: +('message', 'commentary', 'Checking.') +('message', 'commentary', 'Checking.Final answer.') + +First list contains 1 additional elements. +First extra element 2: +('message', 'final_answer', 'Final answer.') + +- [('message', 'commentary', 'Checking.'), ++ [('message', 'commentary', 'Checking.Final answer.'), +? +++++++++++++ + +- ('function_call', 'inspect', {}), +? ^ + ++ ('function_call', 'inspect', {})] +? ^ + +- ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_ordered_nonstream_preserves_requested_logprobs (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_requested_logprobs) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 368, in test_qwen_ordered_nonstream_preserves_requested_logprobs + self.assertTrue(all(item['content'][0]['logprobs'] is not None +AssertionError: False is not true : [{'id': 'msg_dbbe7cccff814cdea1904494a1b26f3b', 'content': [{'annotations': [], 'text': 'Checking.', 'type': 'output_text', 'logprobs': None}], 'role': 'assistant', 'status': 'completed', 'type': 'message', 'phase': 'commentary'}, {'id': 'msg_e5fafa808a8f47c6a3755156f0ac5ecd', 'content': [{'annotations': [], 'text': 'Final answer.', 'type': 'output_text', 'logprobs': None}], 'role': 'assistant', 'status': 'completed', 'type': 'message', 'phase': 'final_answer'}] + +====================================================================== +FAIL: test_qwen_ordered_nonstream_preserves_usage_details (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_usage_details) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 322, in test_qwen_ordered_nonstream_preserves_usage_details + self.assertEqual(body['usage'], { +AssertionError: {'input_tokens': 0, 'input_tokens_details': {'cached_token[118 chars] 118} != {'input_tokens': 10, 'input_tokens_details': {'cached_toke[121 chars] 118} +Diff is 668 characters long. Set self.maxDiff to None to see it. + +====================================================================== +FAIL: test_qwen_stream_has_no_generic_angle_boundary_split (__main__.MockHTTPTest.test_qwen_stream_has_no_generic_angle_boundary_split) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 398, in test_qwen_stream_has_no_generic_angle_boundary_split + self.assertFalse( +AssertionError: True is not false : generic angle-boundary splitting is forbidden + +---------------------------------------------------------------------- +Ran 65 tests in 4.904s + +FAILED (failures=4) diff --git a/tests/runtime_responses_compat.py b/tests/runtime_responses_compat.py index 4aa805a..34d5b71 100644 --- a/tests/runtime_responses_compat.py +++ b/tests/runtime_responses_compat.py @@ -1,6 +1,7 @@ """Imported exact-runtime CPU tests. No model/GPU conformance claim.""" import asyncio import copy +import inspect import json import unittest from types import SimpleNamespace @@ -294,6 +295,125 @@ def test_qwen_nonstream_preserves_text_tool_text_order(self): ('message', 'final_answer', 'Final answer.'), ]) + def test_qwen_ordered_nonstream_preserves_usage_details(self): + self.serving.reasoning_parser = None + self.serving.tool_call_parser = 'qwen3_coder' + self.serving.enable_prompt_tokens_details = True + raw = ('Checking.' + 'Final answer.') + + async def generate(request, *args, **kwargs): + yield { + 'text': raw, + 'output_ids': [1] * 108, + 'meta_info': { + 'prompt_tokens': 10, + 'completion_tokens': 108, + 'cached_tokens': 4, + 'reasoning_tokens': 7, + 'finish_reason': {'type': 'stop'}, + }, + } + + self.serving.tokenizer_manager.generate_request = generate + tools = [{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}] + body = self.send(tools=tools, tool_choice='auto').json() + self.assertEqual(body['usage'], { + 'input_tokens': 10, + 'input_tokens_details': { + 'cached_tokens': 4, + 'cache_write_tokens': 0, + }, + 'output_tokens': 108, + 'output_tokens_details': {'reasoning_tokens': 7}, + 'total_tokens': 118, + }) + + def test_qwen_ordered_nonstream_preserves_requested_logprobs(self): + self.serving.reasoning_parser = None + self.serving.tool_call_parser = 'qwen3_coder' + raw = ('Checking.' + 'Final answer.') + + async def generate(request, *args, **kwargs): + yield { + 'text': raw, + 'output_ids': [1, 2], + 'meta_info': { + 'prompt_tokens': 10, + 'completion_tokens': 2, + 'output_token_logprobs': [ + (-0.25, 1, 'Checking.'), + (-0.5, 2, 'Final answer.'), + ], + 'output_top_logprobs': [ + [(-0.25, 1, 'Checking.'), (-1.0, 3, 'Inspecting.')], + [(-0.5, 2, 'Final answer.')], + ], + 'finish_reason': {'type': 'stop'}, + }, + } + + self.serving.tokenizer_manager.generate_request = generate + tools = [{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}] + body = self.send( + tools=tools, + tool_choice='auto', + include=['message.output_text.logprobs'], + top_logprobs=2, + ).json() + messages = [item for item in body['output'] if item['type'] == 'message'] + self.assertTrue(all(item['content'][0]['logprobs'] is not None + for item in messages), messages) + self.assertEqual( + [[entry['token'] for entry in item['content'][0]['logprobs']] + for item in messages], + [['Checking.', 'Final answer.'], ['Checking.', 'Final answer.']], + ) + self.assertEqual( + messages[0]['content'][0]['logprobs'][0]['top_logprobs'][1]['token'], + 'Inspecting.', + ) + + def test_qwen_literal_angle_brackets_survive_text_tool_text(self): + self.serving.reasoning_parser = None + self.serving.tool_call_parser = 'qwen3_coder' + self.text = ('Compare and 1 < 2.' + '' + 'Final and 3 > 2.') + tools = [{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}] + body = self.send(tools=tools, tool_choice='auto').json() + self.assertEqual(self.phase_semantics(body['output']), [ + ('message', 'commentary', 'Compare and 1 < 2.'), + ('function_call', 'inspect', {}), + ('message', 'final_answer', 'Final and 3 > 2.'), + ]) + + def test_qwen_stream_has_no_generic_angle_boundary_split(self): + source = inspect.getsource( + OpenAIServingResponses.responses_stream_generator_non_harmony) + self.assertFalse( + 're.split(r"(?=<)|(?<=>)"' in source, + 'generic angle-boundary splitting is forbidden', + ) + + def test_qwen4_exp_is_negative_control_for_ordered_nonstream(self): + self.serving.reasoning_parser = None + self.serving.tool_call_parser = 'qwen3_coder' + self.serving.tokenizer_manager.model_config.hf_config.model_type = 'qwen4_exp' + self.text = ('Checking.' + 'Final answer.') + tools = [{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}] + output = self.send(tools=tools, tool_choice='auto').json()['output'] + self.assertEqual(self.phase_semantics(output), [ + ('message', 'commentary', 'Checking.Final answer.'), + ('function_call', 'inspect', {}), + ]) + def test_nonstream_message_phase_matches_remaining_tool_calls(self): self.text = 'Final answer.' final = self.send(tools=[], tool_choice='none').json()['output'] @@ -1198,6 +1318,35 @@ def test_mock_http_custom_native_empty_and_escaped(self): body = next(event['response'] for event in self.events(response) if event.get('type') == 'response.completed') if stream else response.json() self.assertEqual(body['output'][0]['input'], raw) + def test_mock_http_custom_literal_angles_preserve_order_and_payload(self): + self.serving.tool_call_parser = 'qwen3_coder' + self.tools = [{'type': 'custom', 'name': 'patch'}] + raw = 'keep 1 < 2 and 3 > 2' + tool = {'type': 'function', 'function': {'name': 'patch', 'parameters': { + 'type': 'object', 'properties': {'input': {'type': 'string'}}, + 'required': ['input']}}} + rendered = self.serving.tokenizer_manager.tokenizer.apply_chat_template([ + {'role': 'user', 'content': 'Call patch'}, + {'role': 'assistant', 'content': '', 'tool_calls': [ + {'type': 'function', 'function': { + 'name': 'patch', 'arguments': {'input': raw}}}]}], + tools=[tool], tokenize=False, add_generation_prompt=False) + start = rendered.rindex('') + tool_block = rendered[start:rendered.index( + '', start) + len('')] + self.text = 'Before .' + tool_block + 'After .' + body = self.send(tool_choice='auto').json() + self.assertEqual( + [(item['type'], item.get('phase')) for item in body['output']], + [('message', 'commentary'), ('custom_tool_call', None), + ('message', 'final_answer')], + ) + self.assertEqual(body['output'][0]['content'][0]['text'], + 'Before .') + self.assertEqual(body['output'][1]['input'], raw) + self.assertEqual(body['output'][2]['content'][0]['text'], + 'After .') + def test_mock_http_replay_cannot_forge_flat_dotted_identity(self): self.tools = [{'type': 'function', 'name': 'workspace.read'}] response = self.send(input=[{'type': 'function_call', 'name': 'read', 'namespace': 'workspace', From 6968c13f44b251feb86bd7d179d3b483ed434a49 Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 12:55:10 +0100 Subject: [PATCH 06/20] test(responses): capture independent follow-up regressions --- provenance/pr5-followup-red.json | 23 ++ provenance/pr5-followup-red.log | 586 ++++++++++++++++++++++++++++++ tests/runtime_responses_compat.py | 107 +++++- 3 files changed, 715 insertions(+), 1 deletion(-) create mode 100644 provenance/pr5-followup-red.json create mode 100644 provenance/pr5-followup-red.log diff --git a/provenance/pr5-followup-red.json b/provenance/pr5-followup-red.json new file mode 100644 index 0000000..49eebca --- /dev/null +++ b/provenance/pr5-followup-red.json @@ -0,0 +1,23 @@ +{ + "phase": "FOLLOWUP_RED", + "base_commit": "df22281b6d35fc04f802a9384b22297c0857c8cd", + "production_source_sha256": "adc658db49da4cda597db2f962ece7415678083cc26b5496793fec1d74e56a35", + "trigger": "independent read-only review of the first GREEN candidate", + "image": "kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", + "result": { + "exit_code": 1, + "test_methods_run": 69, + "failing_subtests": 18, + "errors": 0 + }, + "failing_behaviors": [ + "recognized reasoning marker split across cumulative and incremental chunks", + "required JSON function/custom marker-like values treated as structural output", + "tool call finalized after renewed reasoning instead of before it", + "second explicit reasoning block retained as ordinary text" + ], + "sha256": { + "tests/runtime_responses_compat.py": "b019131ac8415e095187dd5dacf8cb93e31eb56fd33e95b7b02948f96fa1edc2", + "provenance/pr5-followup-red.log": "13118c0772f76d711eb6fd6f7ee44f124ebc65ea8a7ce892f01412188a861495" + } +} diff --git a/provenance/pr5-followup-red.log b/provenance/pr5-followup-red.log new file mode 100644 index 0000000..930a2dd --- /dev/null +++ b/provenance/pr5-followup-red.log @@ -0,0 +1,586 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 11:54:23.921000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok +test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok +test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok +test_top_level_xhigh_reaches_real_tokenizer (runtime_chat_effort.ChatEffortTest.test_top_level_xhigh_reaches_real_tokenizer) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:1039: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field + "max_new_tokens": self.max_completion_tokens or self.max_tokens, +ok +test_background_requires_storage (__main__.MockHTTPTest.test_background_requires_storage) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:297: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(error)) +ok +test_direct_flat_result_retains_typed_api (__main__.MockHTTPTest.test_direct_flat_result_retains_typed_api) ... ok +test_failed_and_disconnected_stream_preserves_stored_identity (__main__.MockHTTPTest.test_failed_and_disconnected_stream_preserves_stored_identity) ... Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2711, in responses_stream_generator_non_harmony + tool_calls = [ + ^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 42, in validated_json_calls + raise ValueError("Unknown generated tool identity in required output") +ValueError: Unknown generated tool identity in required output +ok +test_fix2_custom_delimiter_limit_and_json_alternative (__main__.MockHTTPTest.test_fix2_custom_delimiter_limit_and_json_alternative) ... Parsed parameter 'other' is not defined in the tool parameters for tool 'patch', directly returning the string value. +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:650: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) +Parsed parameter 'other' is not defined in the tool parameters for tool 'patch', directly returning the string value. +ok +test_fix2_custom_history_rejects_embedded_function_after_gap (__main__.MockHTTPTest.test_fix2_custom_history_rejects_embedded_function_after_gap) ... ok +test_fix2_embedded_flat_and_history (__main__.MockHTTPTest.test_fix2_embedded_flat_and_history) ... ok +test_fix2_embedded_identity_rejection (__main__.MockHTTPTest.test_fix2_embedded_identity_rejection) ... ok +test_fix2_embedded_supported_and_custom_distinctions (__main__.MockHTTPTest.test_fix2_embedded_supported_and_custom_distinctions) ... ok +test_fix2_selected_single_required_multiple (__main__.MockHTTPTest.test_fix2_selected_single_required_multiple) ... ok +test_fix2_terminal_cardinality (__main__.MockHTTPTest.test_fix2_terminal_cardinality) ... ok +test_fix2_unsupported_embedded_forms (__main__.MockHTTPTest.test_fix2_unsupported_embedded_forms) ... ok +test_fix3_malformed_success_remains_rejected (__main__.MockHTTPTest.test_fix3_malformed_success_remains_rejected) ... Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2711, in responses_stream_generator_non_harmony + tool_calls = [ + ^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 35, in validated_json_calls + calls = json.loads(content) + ^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/__init__.py", line 346, in loads + return _default_decoder.decode(s) + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/decoder.py", line 337, in decode + obj, end = self.raw_decode(s, idx=_w(s, 0).end()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/decoder.py", line 353, in raw_decode + obj, end = self.scan_once(s, idx) + ^^^^^^^^^^^^^^^^^^^^^^ +json.decoder.JSONDecodeError: Unterminated string starting at: line 1 column 39 (char 38) +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2711, in responses_stream_generator_non_harmony + tool_calls = [ + ^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 35, in validated_json_calls + calls = json.loads(content) + ^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/__init__.py", line 346, in loads + return _default_decoder.decode(s) + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/decoder.py", line 337, in decode + obj, end = self.raw_decode(s, idx=_w(s, 0).end()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/decoder.py", line 353, in raw_decode + obj, end = self.scan_once(s, idx) + ^^^^^^^^^^^^^^^^^^^^^^ +json.decoder.JSONDecodeError: Unterminated string starting at: line 1 column 39 (char 38) +ok +test_fix3_native_auto_terminal_text (__main__.MockHTTPTest.test_fix3_native_auto_terminal_text) ... ok +test_fix3_partial_no_store (__main__.MockHTTPTest.test_fix3_partial_no_store) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1822: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_fix3_partial_terminal_matrix (__main__.MockHTTPTest.test_fix3_partial_terminal_matrix) ... ok +test_fix3_terminal_text_and_no_store (__main__.MockHTTPTest.test_fix3_terminal_text_and_no_store) ... ok +test_fixer_conflicting_forced_representations_before_generation (__main__.MockHTTPTest.test_fixer_conflicting_forced_representations_before_generation) ... ok +test_fixer_descriptions_reach_rendered_prompt (__main__.MockHTTPTest.test_fixer_descriptions_reach_rendered_prompt) ... ok +test_fixer_generated_history_survives_output_only_and_multiple_turns (__main__.MockHTTPTest.test_fixer_generated_history_survives_output_only_and_multiple_turns) ... Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2711, in responses_stream_generator_non_harmony + tool_calls = [ + ^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 42, in validated_json_calls + raise ValueError("Unknown generated tool identity in required output") +ValueError: Unknown generated tool identity in required output +ok +test_fixer_image_history_survives_no_declaration_gaps (__main__.MockHTTPTest.test_fixer_image_history_survives_no_declaration_gaps) ... ok +test_fixer_pinned_sdk_client_terminal_roundtrip (__main__.MockHTTPTest.test_fixer_pinned_sdk_client_terminal_roundtrip) ... /usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +/usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +/usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +ok +test_fixer_pinned_sdk_output_and_event_roundtrip_replay (__main__.MockHTTPTest.test_fixer_pinned_sdk_output_and_event_roundtrip_replay) ... ok +test_fixer_whole_history_collision_parity (__main__.MockHTTPTest.test_fixer_whole_history_collision_parity) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:297: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(error)) +ok +test_mock_http_custom_literal_angles_preserve_order_and_payload (__main__.MockHTTPTest.test_mock_http_custom_literal_angles_preserve_order_and_payload) ... ok +test_mock_http_custom_native_empty_and_escaped (__main__.MockHTTPTest.test_mock_http_custom_native_empty_and_escaped) ... ok +test_mock_http_custom_raw_and_stateless_replay (__main__.MockHTTPTest.test_mock_http_custom_raw_and_stateless_replay) ... ok +test_mock_http_flat_history_without_active_tools (__main__.MockHTTPTest.test_mock_http_flat_history_without_active_tools) ... ok +test_mock_http_flat_regression (__main__.MockHTTPTest.test_mock_http_flat_regression) ... ok +test_mock_http_forced_choice_cannot_emit_other_declared_tool (__main__.MockHTTPTest.test_mock_http_forced_choice_cannot_emit_other_declared_tool) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:650: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2870, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2761, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 121, in output_identity + raise ValueError("Generated tool call does not match forced tool choice") +ValueError: Generated tool call does not match forced tool choice +ok +test_mock_http_json_schema_and_explicit_nulls (__main__.MockHTTPTest.test_mock_http_json_schema_and_explicit_nulls) ... ok +test_mock_http_multimodal_tool_result_and_alias_provenance (__main__.MockHTTPTest.test_mock_http_multimodal_tool_result_and_alias_provenance) ... ok +test_mock_http_namespace_nonstream_and_stateful_replay (__main__.MockHTTPTest.test_mock_http_namespace_nonstream_and_stateful_replay) ... ok +test_mock_http_namespace_sse_lifecycle (__main__.MockHTTPTest.test_mock_http_namespace_sse_lifecycle) ... ok +test_mock_http_native_auto_and_required (__main__.MockHTTPTest.test_mock_http_native_auto_and_required) ... ok +test_mock_http_native_unknown_fails_closed (__main__.MockHTTPTest.test_mock_http_native_unknown_fails_closed) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2870, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2761, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 122, in output_identity + return self.identity(qualified) + ^^^^^^^^^^^^^^^^^^^^^^^^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 116, in identity + raise ValueError(f"Unknown generated tool identity: {qualified}") +ValueError: Unknown generated tool identity: workspace.NOT_DECLARED +ok +test_mock_http_parallel_dotted_and_duplicate_local_names (__main__.MockHTTPTest.test_mock_http_parallel_dotted_and_duplicate_local_names) ... ok +test_mock_http_rejected_call_cannot_be_replayed_from_store (__main__.MockHTTPTest.test_mock_http_rejected_call_cannot_be_replayed_from_store) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1822: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_mock_http_rejects_unknown_and_forced_invalid (__main__.MockHTTPTest.test_mock_http_rejects_unknown_and_forced_invalid) ... Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2711, in responses_stream_generator_non_harmony + tool_calls = [ + ^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 42, in validated_json_calls + raise ValueError("Unknown generated tool identity in required output") +ValueError: Unknown generated tool identity in required output +ok +test_mock_http_replay_cannot_forge_flat_dotted_identity (__main__.MockHTTPTest.test_mock_http_replay_cannot_forge_flat_dotted_identity) ... ok +test_mock_http_request_provenance_and_unrelated_model (__main__.MockHTTPTest.test_mock_http_request_provenance_and_unrelated_model) ... ok +test_nonstream_message_phase_matches_remaining_tool_calls (__main__.MockHTTPTest.test_nonstream_message_phase_matches_remaining_tool_calls) ... ok +test_qwen4_exp_is_negative_control_for_ordered_nonstream (__main__.MockHTTPTest.test_qwen4_exp_is_negative_control_for_ordered_nonstream) ... ok +test_qwen_literal_angle_brackets_survive_text_tool_text (__main__.MockHTTPTest.test_qwen_literal_angle_brackets_survive_text_tool_text) ... ok +test_qwen_nonstream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_renewed_reasoning_order) ... ok +test_qwen_nonstream_preserves_text_tool_text_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_text_tool_text_order) ... ok +test_qwen_ordered_nonstream_preserves_requested_logprobs (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_requested_logprobs) ... ok +test_qwen_ordered_nonstream_preserves_usage_details (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_usage_details) ... ok +test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) ... + test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) (stream=False) ... FAIL + test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) (stream=True) ... FAIL +test_qwen_stream_has_no_generic_angle_boundary_split (__main__.MockHTTPTest.test_qwen_stream_has_no_generic_angle_boundary_split) ... ok +test_qwen_stream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_stream_preserves_renewed_reasoning_order) ... ok +test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) ... + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=10) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=11) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=12) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=13) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=14) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=15) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=10) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=11) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=12) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=13) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=14) ... FAIL + test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=15) ... FAIL +test_qwen_stream_preserves_text_tool_text_order_for_any_chunking (__main__.MockHTTPTest.test_qwen_stream_preserves_text_tool_text_order_for_any_chunking) ... ok +test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) ... + test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) (stream=False) ... FAIL + test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) (stream=True) ... FAIL +test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) ... + test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) (generated_name='inspect') ... FAIL + test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) (generated_name='patch') ... FAIL +test_text_streams_before_phase_is_resolved (__main__.MockHTTPTest.test_text_streams_before_phase_is_resolved) ... ok +test_collisions_and_malformed_members (__main__.ResponsesCompatTest.test_collisions_and_malformed_members) ... ok +test_custom_declaration_reaches_chat (__main__.ResponsesCompatTest.test_custom_declaration_reaches_chat) ... ok +test_custom_grammar_visible (__main__.ResponsesCompatTest.test_custom_grammar_visible) ... ok +test_harmony_same_request_call_replay (__main__.ResponsesCompatTest.test_harmony_same_request_call_replay) ... ok +test_image_result_preserved (__main__.ResponsesCompatTest.test_image_result_preserved) ... ok +test_message_phase_survives_response_models (__main__.ResponsesCompatTest.test_message_phase_survives_response_models) ... ok +test_namespace_declaration_reaches_chat (__main__.ResponsesCompatTest.test_namespace_declaration_reaches_chat) ... ok +test_qualified_replay (__main__.ResponsesCompatTest.test_qualified_replay) ... ok +test_qwen_replay_preserves_assistant_stage_order (__main__.ResponsesCompatTest.test_qwen_replay_preserves_assistant_stage_order) ... ok +test_stored_response_replays_reasoning_phase_and_call_together (__main__.ResponsesCompatTest.test_stored_response_replays_reasoning_phase_and_call_together) ... ok + +====================================================================== +FAIL: test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) (stream=False) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 538, in test_qwen_second_reasoning_block_preserves_order + self.assertEqual(self.phase_semantics(body['output']), expected) +AssertionError: Lists differ: [('re[28 chars]e', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 2: +('reasoning', 'Again') + + [('reasoning', 'First'), ++ ('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), +- ('message', 'final_answer', 'Checking.AgainFinal answer.')] +? ----------------------------- + ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) (stream=True) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 538, in test_qwen_second_reasoning_block_preserves_order + self.assertEqual(self.phase_semantics(body['output']), expected) +AssertionError: Lists differ: [('re[28 chars]e', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 2: +('reasoning', 'Again') + + [('reasoning', 'First'), ++ ('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), +- ('message', 'final_answer', 'Checking.AgainFinal answer.')] +? ----------------------------- + ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=10) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=11) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=12) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=13) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=14) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=15) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=10) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=11) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=12) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=13) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=14) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=15) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 494, in test_qwen_stream_preserves_split_reasoning_marker_boundaries + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('message', 'final_answer', 'Checking.AgainAgainFinal answer.') +('message', 'commentary', 'Checking.') + +Second list contains 2 additional elements. +First extra element 1: +('reasoning', 'Again') + +- [('message', 'final_answer', 'Checking.AgainFinal answer.')] ++ [('message', 'commentary', 'Checking.'), ++ ('reasoning', 'Again'), ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) (stream=False) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 517, in test_qwen_tool_then_renewed_reasoning_preserves_order + self.assertEqual(self.phase_semantics(body['output']), expected) +AssertionError: Lists differ: [('me[33 chars]), ('reasoning', 'Again'), ('function_call', '[55 chars]r.')] != [('me[33 chars]), ('function_call', 'inspect', {}), ('reasoni[55 chars]r.')] + +First differing element 1: +('reasoning', 'Again') +('function_call', 'inspect', {}) + + [('message', 'commentary', 'Checking.'), ++ ('function_call', 'inspect', {}), + ('reasoning', 'Again'), +- ('function_call', 'inspect', {}), + ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) (stream=True) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 517, in test_qwen_tool_then_renewed_reasoning_preserves_order + self.assertEqual(self.phase_semantics(body['output']), expected) +AssertionError: Lists differ: [('me[33 chars]), ('reasoning', 'Again'), ('function_call', '[55 chars]r.')] != [('me[33 chars]), ('function_call', 'inspect', {}), ('reasoni[55 chars]r.')] + +First differing element 1: +('reasoning', 'Again') +('function_call', 'inspect', {}) + + [('message', 'commentary', 'Checking.'), ++ ('function_call', 'inspect', {}), + ('reasoning', 'Again'), +- ('function_call', 'inspect', {}), + ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) (generated_name='inspect') +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 559, in test_required_json_marker_like_values_remain_data + self.assertEqual(response.status_code, 200, response.text) +AssertionError: 400 != 200 : {"error":{"message":"Required tool choice requires at least one call","type":"invalid_request_error","param":null,"code":400}} + +====================================================================== +FAIL: test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) (generated_name='patch') +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 559, in test_required_json_marker_like_values_remain_data + self.assertEqual(response.status_code, 200, response.text) +AssertionError: 400 != 200 : {"error":{"message":"Required tool choice requires at least one call","type":"invalid_request_error","param":null,"code":400}} + +---------------------------------------------------------------------- +Ran 69 tests in 5.141s + +FAILED (failures=18) diff --git a/tests/runtime_responses_compat.py b/tests/runtime_responses_compat.py index 34d5b71..6bfd00d 100644 --- a/tests/runtime_responses_compat.py +++ b/tests/runtime_responses_compat.py @@ -410,7 +410,7 @@ def test_qwen4_exp_is_negative_control_for_ordered_nonstream(self): 'parameters': {'type': 'object', 'properties': {}}}] output = self.send(tools=tools, tool_choice='auto').json()['output'] self.assertEqual(self.phase_semantics(output), [ - ('message', 'commentary', 'Checking.Final answer.'), + ('message', 'commentary', 'Checking.'), ('function_call', 'inspect', {}), ]) @@ -459,6 +459,111 @@ def test_qwen_stream_preserves_renewed_reasoning_order(self): ('message', 'final_answer', 'Final answer.'), ]) + def test_qwen_stream_preserves_split_reasoning_marker_boundaries(self): + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = None + raw = 'Checking.AgainFinal answer.' + expected = [ + ('message', 'commentary', 'Checking.'), + ('reasoning', 'Again'), + ('message', 'final_answer', 'Final answer.'), + ] + start = raw.index('') + for incremental in (False, True): + for cut in range(start + 1, start + len('')): + with self.subTest(incremental=incremental, cut=cut): + self.serving.tokenizer_manager.server_args.incremental_streaming_output = incremental + + async def generate(request, *args, **kwargs): + yield {'text': raw[:cut], 'output_ids': [1] * cut, + 'meta_info': {'prompt_tokens': 10, + 'completion_tokens': cut, + 'finish_reason': None}} + yield {'text': raw[cut:] if incremental else raw, + 'output_ids': [1] * len(raw), + 'meta_info': {'prompt_tokens': 10, + 'completion_tokens': len(raw), + 'finish_reason': {'type': 'stop'}}} + + self.serving.tokenizer_manager.generate_request = generate + events = self.events(self.send( + stream=True, tools=[], tool_choice='none', + reasoning={'effort': 'medium'})) + output = next(event['response']['output'] for event in events + if event['type'] == 'response.completed') + self.assertEqual(self.phase_semantics(output), expected) + + def test_qwen_tool_then_renewed_reasoning_preserves_order(self): + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = 'qwen3_coder' + self.text = ('Checking.' + 'AgainFinal answer.') + tools = [{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}] + expected = [ + ('message', 'commentary', 'Checking.'), + ('function_call', 'inspect', {}), + ('reasoning', 'Again'), + ('message', 'final_answer', 'Final answer.'), + ] + for stream in (False, True): + with self.subTest(stream=stream): + response = self.send( + stream=stream, tools=tools, tool_choice='auto', + reasoning={'effort': 'medium'}) + body = (next(event['response'] for event in self.events(response) + if event['type'] == 'response.completed') + if stream else response.json()) + self.assertEqual(self.phase_semantics(body['output']), expected) + + def test_qwen_second_reasoning_block_preserves_order(self): + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = None + self.text = ('FirstChecking.' + 'AgainFinal answer.') + expected = [ + ('reasoning', 'First'), + ('message', 'commentary', 'Checking.'), + ('reasoning', 'Again'), + ('message', 'final_answer', 'Final answer.'), + ] + for stream in (False, True): + with self.subTest(stream=stream): + response = self.send( + stream=stream, tools=[], tool_choice='none', + reasoning={'effort': 'medium'}) + body = (next(event['response'] for event in self.events(response) + if event['type'] == 'response.completed') + if stream else response.json()) + self.assertEqual(self.phase_semantics(body['output']), expected) + + def test_required_json_marker_like_values_remain_data(self): + self.serving.reasoning_parser = None + self.serving.tool_call_parser = None + cases = [ + ([{'type': 'function', 'name': 'inspect', 'parameters': { + 'type': 'object', 'properties': {'text': {'type': 'string'}}}}], + 'inspect', {'text': ''}, 'function_call'), + ([{'type': 'custom', 'name': 'patch'}], + 'patch', {'input': 'tail'}, + 'custom_tool_call'), + (self.tools, 'workspace.read', {'path': 'file'}, + 'function_call'), + ] + for tools, generated_name, arguments, output_type in cases: + with self.subTest(generated_name=generated_name): + self.text = json.dumps([ + {'name': generated_name, 'parameters': arguments} + ]) + response = self.send(tools=tools, tool_choice='required') + self.assertEqual(response.status_code, 200, response.text) + item = response.json()['output'][0] + self.assertEqual(item['type'], output_type) + if output_type == 'custom_tool_call': + self.assertEqual(item['input'], arguments['input']) + else: + self.assertEqual(json.loads(item['arguments']), arguments) + def test_text_streams_before_phase_is_resolved(self): async def check(): self.serving.reasoning_parser = None From 76f04a2d6a5b82a9ffd7cb1e101a022cff790545 Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 13:09:51 +0100 Subject: [PATCH 07/20] test(responses): capture second review edge cases --- provenance/pr5-followup2-red.json | 20 +++++++++ provenance/pr5-followup2-red.log | 73 +++++++++++++++++++++++++++++++ tests/runtime_responses_compat.py | 53 +++++++++++++++------- 3 files changed, 131 insertions(+), 15 deletions(-) create mode 100644 provenance/pr5-followup2-red.json create mode 100644 provenance/pr5-followup2-red.log diff --git a/provenance/pr5-followup2-red.json b/provenance/pr5-followup2-red.json new file mode 100644 index 0000000..a8795c5 --- /dev/null +++ b/provenance/pr5-followup2-red.json @@ -0,0 +1,20 @@ +{ + "phase": "FOLLOWUP2_RED", + "base_commit": "6968c13f44b251feb86bd7d179d3b483ed434a49", + "production_source_sha256": "04fd2308677bb399f5911df89ee1a64e0d83b449dbdd9851b52be60b4ed88f9a", + "trigger": "second independent read-only review", + "result": { + "exit_code": 1, + "test_methods_run": 2, + "failing_subtests": 3, + "errors": 0 + }, + "failing_behaviors": [ + "required JSON marker-like values with configured qwen3 reasoning parser", + "adjacent repeated explicit reasoning blocks remain distinct" + ], + "sha256": { + "tests/runtime_responses_compat.py": "9c100524ca72cee5139af6310e8372eae21f0e00892fd322df7f4907b70202cd", + "provenance/pr5-followup2-red.log": "a10bc67cb2203c425b5e260d20b7f6b96d018300360408babf3235fb745a6a74" + } +} diff --git a/provenance/pr5-followup2-red.log b/provenance/pr5-followup2-red.log new file mode 100644 index 0000000..c8ca536 --- /dev/null +++ b/provenance/pr5-followup2-red.log @@ -0,0 +1,73 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 12:07:41.681000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_qwen_adjacent_reasoning_blocks_remain_distinct (__main__.MockHTTPTest.test_qwen_adjacent_reasoning_blocks_remain_distinct) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa + + test_qwen_adjacent_reasoning_blocks_remain_distinct (__main__.MockHTTPTest.test_qwen_adjacent_reasoning_blocks_remain_distinct) (stream=False) ... FAIL + test_qwen_adjacent_reasoning_blocks_remain_distinct (__main__.MockHTTPTest.test_qwen_adjacent_reasoning_blocks_remain_distinct) (stream=True) ... FAIL +test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:690: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) + + test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) (reasoning_parser='qwen3', generated_name='inspect') ... FAIL + +====================================================================== +FAIL: test_qwen_adjacent_reasoning_blocks_remain_distinct (__main__.MockHTTPTest.test_qwen_adjacent_reasoning_blocks_remain_distinct) (stream=False) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 557, in test_qwen_adjacent_reasoning_blocks_remain_distinct + self.assertEqual(self.phase_semantics(body['output']), expected) +AssertionError: Lists differ: [('reasoning', 'FirstAgain'), ('message', 'final_answer', 'Final answer.')] != [('reasoning', 'First'), ('reasoning', 'Again'), ('message', '[27 chars]r.')] + +First differing element 0: +('reasoning', 'FirstAgain') +('reasoning', 'First') + +Second list contains 1 additional elements. +First extra element 2: +('message', 'final_answer', 'Final answer.') + ++ [('reasoning', 'First'), ++ ('reasoning', 'Again'), +- [('reasoning', 'FirstAgain'), ('message', 'final_answer', 'Final answer.')] +? ----------------------------- + ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_qwen_adjacent_reasoning_blocks_remain_distinct (__main__.MockHTTPTest.test_qwen_adjacent_reasoning_blocks_remain_distinct) (stream=True) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 557, in test_qwen_adjacent_reasoning_blocks_remain_distinct + self.assertEqual(self.phase_semantics(body['output']), expected) +AssertionError: Lists differ: [('reasoning', 'FirstAgain'), ('message', 'final_answer', 'Final answer.')] != [('reasoning', 'First'), ('reasoning', 'Again'), ('message', '[27 chars]r.')] + +First differing element 0: +('reasoning', 'FirstAgain') +('reasoning', 'First') + +Second list contains 1 additional elements. +First extra element 2: +('message', 'final_answer', 'Final answer.') + ++ [('reasoning', 'First'), ++ ('reasoning', 'Again'), +- [('reasoning', 'FirstAgain'), ('message', 'final_answer', 'Final answer.')] +? ----------------------------- + ++ ('message', 'final_answer', 'Final answer.')] + +====================================================================== +FAIL: test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) (reasoning_parser='qwen3', generated_name='inspect') +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 582, in test_required_json_marker_like_values_remain_data + self.assertEqual(response.status_code, 200, response.text) +AssertionError: 400 != 200 : {"error":{"message":"Required tool choice requires at least one call","type":"invalid_request_error","param":null,"code":400}} + +---------------------------------------------------------------------- +Ran 2 tests in 0.881s + +FAILED (failures=3) diff --git a/tests/runtime_responses_compat.py b/tests/runtime_responses_compat.py index 6bfd00d..2e9cf9f 100644 --- a/tests/runtime_responses_compat.py +++ b/tests/runtime_responses_compat.py @@ -537,32 +537,55 @@ def test_qwen_second_reasoning_block_preserves_order(self): if stream else response.json()) self.assertEqual(self.phase_semantics(body['output']), expected) + def test_qwen_adjacent_reasoning_blocks_remain_distinct(self): + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = None + self.text = 'FirstAgainFinal answer.' + expected = [ + ('reasoning', 'First'), + ('reasoning', 'Again'), + ('message', 'final_answer', 'Final answer.'), + ] + for stream in (False, True): + with self.subTest(stream=stream): + response = self.send( + stream=stream, tools=[], tool_choice='none', + reasoning={'effort': 'medium'}) + body = (next(event['response'] for event in self.events(response) + if event['type'] == 'response.completed') + if stream else response.json()) + self.assertEqual(self.phase_semantics(body['output']), expected) + def test_required_json_marker_like_values_remain_data(self): - self.serving.reasoning_parser = None self.serving.tool_call_parser = None cases = [ ([{'type': 'function', 'name': 'inspect', 'parameters': { 'type': 'object', 'properties': {'text': {'type': 'string'}}}}], - 'inspect', {'text': ''}, 'function_call'), + 'inspect', {'text': 'literal'}, 'function_call'), ([{'type': 'custom', 'name': 'patch'}], 'patch', {'input': 'tail'}, 'custom_tool_call'), (self.tools, 'workspace.read', {'path': 'file'}, 'function_call'), ] - for tools, generated_name, arguments, output_type in cases: - with self.subTest(generated_name=generated_name): - self.text = json.dumps([ - {'name': generated_name, 'parameters': arguments} - ]) - response = self.send(tools=tools, tool_choice='required') - self.assertEqual(response.status_code, 200, response.text) - item = response.json()['output'][0] - self.assertEqual(item['type'], output_type) - if output_type == 'custom_tool_call': - self.assertEqual(item['input'], arguments['input']) - else: - self.assertEqual(json.loads(item['arguments']), arguments) + for reasoning_parser in (None, 'qwen3'): + self.serving.reasoning_parser = reasoning_parser + for tools, generated_name, arguments, output_type in cases: + with self.subTest(reasoning_parser=reasoning_parser, + generated_name=generated_name): + self.text = json.dumps([ + {'name': generated_name, 'parameters': arguments} + ]) + response = self.send( + tools=tools, tool_choice='required', + reasoning={'effort': 'none'}) + self.assertEqual(response.status_code, 200, response.text) + item = response.json()['output'][0] + self.assertEqual(item['type'], output_type) + if output_type == 'custom_tool_call': + self.assertEqual(item['input'], arguments['input']) + else: + self.assertEqual(json.loads(item['arguments']), arguments) def test_text_streams_before_phase_is_resolved(self): async def check(): From 1cdf3838b38089fbcf3884662a6b30d2de6c9627 Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 13:27:52 +0100 Subject: [PATCH 08/20] test(responses): capture native payload marker regression --- provenance/pr5-followup3-red.json | 17 ++++++ provenance/pr5-followup3-red.log | 92 +++++++++++++++++++++++++++++++ tests/runtime_responses_compat.py | 41 ++++++++++++++ 3 files changed, 150 insertions(+) create mode 100644 provenance/pr5-followup3-red.json create mode 100644 provenance/pr5-followup3-red.log diff --git a/provenance/pr5-followup3-red.json b/provenance/pr5-followup3-red.json new file mode 100644 index 0000000..0dce64e --- /dev/null +++ b/provenance/pr5-followup3-red.json @@ -0,0 +1,17 @@ +{ + "phase": "FOLLOWUP3_RED", + "base_commit": "76f04a2d6a5b82a9ffd7cb1e101a022cff790545", + "production_source_sha256": "4643db136b36e09632b9351159ed2878c70b362919e86865efb380de887f8e21", + "trigger": "third independent read-only review", + "result": { + "exit_code": 1, + "test_methods_run": 1, + "failing_subtests": 4, + "errors": 0 + }, + "failing_behavior": "recognized reasoning markers inside native function/custom payloads after an earlier reasoning block", + "sha256": { + "tests/runtime_responses_compat.py": "bf09824d3850b83a3ed032f68ec5e75f2039f8a3c124c04fec57fcb629996ed2", + "provenance/pr5-followup3-red.log": "f17a5afcb1b675f2691bf9dbe2e18c465af78416d3ca4e53d0c583c6cb1a8dfa" + } +} diff --git a/provenance/pr5-followup3-red.log b/provenance/pr5-followup3-red.log new file mode 100644 index 0000000..5644e3e --- /dev/null +++ b/provenance/pr5-followup3-red.log @@ -0,0 +1,92 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 12:25:11.283000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:690: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) + + test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) (name='inspect', stream=False) ... FAIL +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2983, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2874, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 122, in output_identity + return self.identity(qualified) + ^^^^^^^^^^^^^^^^^^^^^^^^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 116, in identity + raise ValueError(f"Unknown generated tool identity: {qualified}") +ValueError: Unknown generated tool identity: + test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) (name='inspect', stream=True) ... FAIL + test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) (name='patch', stream=False) ... FAIL +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 26, in custom_input + value = json.loads(arguments) + ^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/__init__.py", line 346, in loads + return _default_decoder.decode(s) + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/decoder.py", line 337, in decode + obj, end = self.raw_decode(s, idx=_w(s, 0).end()) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/json/decoder.py", line 355, in raw_decode + raise JSONDecodeError("Expecting value", s, err.value) from None +json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0) + +The above exception was the direct cause of the following exception: + +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2743, in responses_stream_generator_non_harmony + for ev in _close_tool_call_state(tool_index): + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2641, in _close_tool_call_state + request._compat_registry.output_item(completed_item) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 231, in output_item + item["input"] = "" if partial else custom_input(arguments) + ^^^^^^^^^^^^^^^^^^^^^^^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 28, in custom_input + raise ValueError("Custom tool arguments must encode an input string") from error +ValueError: Custom tool arguments must encode an input string + test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) (name='patch', stream=True) ... FAIL + +====================================================================== +FAIL: test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) (name='inspect', stream=False) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 619, in test_native_tool_payload_markers_after_reasoning_remain_data + self.assertEqual(response.status_code, 200, response.text) +AssertionError: 400 != 200 : {"error":{"message":"Unknown generated tool identity: ","type":"invalid_request_error","param":null,"code":400}} + +====================================================================== +FAIL: test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) (name='inspect', stream=True) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 615, in test_native_tool_payload_markers_after_reasoning_remain_data + self.assertTrue(completed, events) +AssertionError: [] is not true : [{'response': {'id': 'resp_b0a0a5a0e10b420ba9b78fc2839a65d2', 'created_at': 1789388713.0, 'error': None, 'incomplete_details': None, 'instructions': None, 'metadata': {}, 'model': 'fixture-qwen', 'object': 'response', 'output': [], 'parallel_tool_calls': True, 'temperature': None, 'tool_choice': 'auto', 'tools': [{'type': 'function', 'name': 'inspect', 'parameters': {'type': 'object', 'properties': {'text': {'type': 'string'}}}, 'strict': False}], 'top_p': None, 'background': None, 'conversation': None, 'max_output_tokens': 128, 'max_tool_calls': None, 'previous_response_id': None, 'prompt': None, 'prompt_cache_key': None, 'reasoning': {'effort': 'medium'}, 'safety_identifier': None, 'service_tier': None, 'status': 'in_progress', 'text': None, 'top_logprobs': None, 'truncation': 'disabled', 'usage': None, 'user': None, 'store': True}, 'sequence_number': 0, 'type': 'response.created'}, {'response': {'id': 'resp_b0a0a5a0e10b420ba9b78fc2839a65d2', 'created_at': 1789388713.0, 'error': None, 'incomplete_details': None, 'instructions': None, 'metadata': {}, 'model': 'fixture-qwen', 'object': 'response', 'output': [], 'parallel_tool_calls': True, 'temperature': None, 'tool_choice': 'auto', 'tools': [{'type': 'function', 'name': 'inspect', 'parameters': {'type': 'object', 'properties': {'text': {'type': 'string'}}}, 'strict': False}], 'top_p': None, 'background': None, 'conversation': None, 'max_output_tokens': 128, 'max_tool_calls': None, 'previous_response_id': None, 'prompt': None, 'prompt_cache_key': None, 'reasoning': {'effort': 'medium'}, 'safety_identifier': None, 'service_tier': None, 'status': 'in_progress', 'text': None, 'top_logprobs': None, 'truncation': 'disabled', 'usage': None, 'user': None, 'store': True}, 'sequence_number': 1, 'type': 'response.in_progress'}, {'item': {'id': 'rs_739be31ad6544bf8865c4fb8e5e5567d', 'summary': [], 'type': 'reasoning', 'content': [], 'encrypted_content': None, 'status': 'in_progress'}, 'output_index': 0, 'sequence_number': 2, 'type': 'response.output_item.added'}, {'content_index': 0, 'delta': 'P', 'item_id': 'rs_739be31ad6544bf8865c4fb8e5e5567d', 'output_index': 0, 'sequence_number': 3, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'l', 'item_id': 'rs_739be31ad6544bf8865c4fb8e5e5567d', 'output_index': 0, 'sequence_number': 4, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'a', 'item_id': 'rs_739be31ad6544bf8865c4fb8e5e5567d', 'output_index': 0, 'sequence_number': 5, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'n', 'item_id': 'rs_739be31ad6544bf8865c4fb8e5e5567d', 'output_index': 0, 'sequence_number': 6, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'item_id': 'rs_739be31ad6544bf8865c4fb8e5e5567d', 'output_index': 0, 'sequence_number': 7, 'text': 'Plan', 'type': 'response.reasoning_text.done'}, {'item': {'id': 'rs_739be31ad6544bf8865c4fb8e5e5567d', 'summary': [], 'type': 'reasoning', 'content': [{'text': 'Plan', 'type': 'reasoning_text'}], 'encrypted_content': None, 'status': 'completed'}, 'output_index': 0, 'sequence_number': 8, 'type': 'response.output_item.done'}, {'item': {'id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'content': [], 'role': 'assistant', 'status': 'in_progress', 'type': 'message', 'phase': None}, 'output_index': 1, 'sequence_number': 9, 'type': 'response.output_item.added'}, {'content_index': 0, 'item_id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'output_index': 1, 'part': {'annotations': [], 'text': '', 'type': 'output_text', 'logprobs': None}, 'sequence_number': 10, 'type': 'response.content_part.added'}, {'content_index': 0, 'delta': 'B', 'item_id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'logprobs': [], 'output_index': 1, 'sequence_number': 11, 'type': 'response.output_text.delta'}, {'content_index': 0, 'delta': 'e', 'item_id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'logprobs': [], 'output_index': 1, 'sequence_number': 12, 'type': 'response.output_text.delta'}, {'content_index': 0, 'delta': 'f', 'item_id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'logprobs': [], 'output_index': 1, 'sequence_number': 13, 'type': 'response.output_text.delta'}, {'content_index': 0, 'delta': 'o', 'item_id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'logprobs': [], 'output_index': 1, 'sequence_number': 14, 'type': 'response.output_text.delta'}, {'content_index': 0, 'delta': 'r', 'item_id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'logprobs': [], 'output_index': 1, 'sequence_number': 15, 'type': 'response.output_text.delta'}, {'content_index': 0, 'delta': 'e', 'item_id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'logprobs': [], 'output_index': 1, 'sequence_number': 16, 'type': 'response.output_text.delta'}, {'content_index': 0, 'item_id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'logprobs': [], 'output_index': 1, 'sequence_number': 17, 'text': 'Before', 'type': 'response.output_text.done'}, {'content_index': 0, 'item_id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'output_index': 1, 'part': {'annotations': [], 'text': 'Before', 'type': 'output_text', 'logprobs': None}, 'sequence_number': 18, 'type': 'response.content_part.done'}, {'item': {'id': 'msg_c58e96c86744441a8cbad8ced2c9e46a', 'content': [{'annotations': [], 'text': 'Before', 'type': 'output_text', 'logprobs': None}], 'role': 'assistant', 'status': 'completed', 'type': 'message', 'phase': 'commentary'}, 'output_index': 1, 'sequence_number': 19, 'type': 'response.output_item.done'}, {'item': {'arguments': '', 'call_id': 'call_fd051932ce59432a859fe03c', 'name': 'inspect', 'type': 'function_call', 'id': 'fc_720ebf2b', 'status': 'in_progress'}, 'output_index': 2, 'sequence_number': 20, 'type': 'response.output_item.added'}, {'arguments': '', 'item_id': 'fc_720ebf2b', 'name': 'inspect', 'output_index': 2, 'sequence_number': 21, 'type': 'response.function_call_arguments.done'}, {'item': {'arguments': '', 'call_id': 'call_fd051932ce59432a859fe03c', 'name': 'inspect', 'type': 'function_call', 'id': 'fc_720ebf2b', 'status': 'completed'}, 'output_index': 2, 'sequence_number': 22, 'type': 'response.output_item.done'}, {'item': {'id': 'rs_1f61e181e5664f3fb74bee79b0026797', 'summary': [], 'type': 'reasoning', 'content': [], 'encrypted_content': None, 'status': 'in_progress'}, 'output_index': 3, 'sequence_number': 23, 'type': 'response.output_item.added'}, {'content_index': 0, 'delta': 'l', 'item_id': 'rs_1f61e181e5664f3fb74bee79b0026797', 'output_index': 3, 'sequence_number': 24, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'i', 'item_id': 'rs_1f61e181e5664f3fb74bee79b0026797', 'output_index': 3, 'sequence_number': 25, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 't', 'item_id': 'rs_1f61e181e5664f3fb74bee79b0026797', 'output_index': 3, 'sequence_number': 26, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'e', 'item_id': 'rs_1f61e181e5664f3fb74bee79b0026797', 'output_index': 3, 'sequence_number': 27, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'r', 'item_id': 'rs_1f61e181e5664f3fb74bee79b0026797', 'output_index': 3, 'sequence_number': 28, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'a', 'item_id': 'rs_1f61e181e5664f3fb74bee79b0026797', 'output_index': 3, 'sequence_number': 29, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'l', 'item_id': 'rs_1f61e181e5664f3fb74bee79b0026797', 'output_index': 3, 'sequence_number': 30, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'item_id': 'rs_1f61e181e5664f3fb74bee79b0026797', 'output_index': 3, 'sequence_number': 31, 'text': 'literal', 'type': 'response.reasoning_text.done'}, {'item': {'id': 'rs_1f61e181e5664f3fb74bee79b0026797', 'summary': [], 'type': 'reasoning', 'content': [{'text': 'literal', 'type': 'reasoning_text'}], 'encrypted_content': None, 'status': 'completed'}, 'output_index': 3, 'sequence_number': 32, 'type': 'response.output_item.done'}, {'response': {'id': 'resp_b0a0a5a0e10b420ba9b78fc2839a65d2', 'created_at': 1789388713.0, 'error': None, 'incomplete_details': None, 'instructions': None, 'metadata': {}, 'model': 'fixture-qwen', 'object': 'response', 'output': [], 'parallel_tool_calls': True, 'temperature': None, 'tool_choice': 'auto', 'tools': [{'type': 'function', 'name': 'inspect', 'parameters': {'type': 'object', 'properties': {'text': {'type': 'string'}}}, 'strict': False}], 'top_p': None, 'background': None, 'conversation': None, 'max_output_tokens': 128, 'max_tool_calls': None, 'previous_response_id': None, 'prompt': None, 'prompt_cache_key': None, 'reasoning': {'effort': 'medium'}, 'safety_identifier': None, 'service_tier': None, 'status': 'failed', 'text': None, 'top_logprobs': None, 'truncation': 'disabled', 'usage': None, 'user': None, 'store': True}, 'sequence_number': 33, 'type': 'response.failed'}] + +====================================================================== +FAIL: test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) (name='patch', stream=False) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 619, in test_native_tool_payload_markers_after_reasoning_remain_data + self.assertEqual(response.status_code, 200, response.text) +AssertionError: 400 != 200 : {"error":{"message":"Custom tool arguments must encode an input string","type":"invalid_request_error","param":null,"code":400}} + +====================================================================== +FAIL: test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) (name='patch', stream=True) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 615, in test_native_tool_payload_markers_after_reasoning_remain_data + self.assertTrue(completed, events) +AssertionError: [] is not true : [{'response': {'id': 'resp_ff930110607e4f61956bc2d3a3c77070', 'created_at': 1789388713.0, 'error': None, 'incomplete_details': None, 'instructions': None, 'metadata': {}, 'model': 'fixture-qwen', 'object': 'response', 'output': [], 'parallel_tool_calls': True, 'temperature': None, 'tool_choice': 'auto', 'tools': [{'type': 'custom', 'name': 'patch', 'strict': False}], 'top_p': None, 'background': None, 'conversation': None, 'max_output_tokens': 128, 'max_tool_calls': None, 'previous_response_id': None, 'prompt': None, 'prompt_cache_key': None, 'reasoning': {'effort': 'medium'}, 'safety_identifier': None, 'service_tier': None, 'status': 'in_progress', 'text': None, 'top_logprobs': None, 'truncation': 'disabled', 'usage': None, 'user': None, 'store': True}, 'sequence_number': 0, 'type': 'response.created'}, {'response': {'id': 'resp_ff930110607e4f61956bc2d3a3c77070', 'created_at': 1789388713.0, 'error': None, 'incomplete_details': None, 'instructions': None, 'metadata': {}, 'model': 'fixture-qwen', 'object': 'response', 'output': [], 'parallel_tool_calls': True, 'temperature': None, 'tool_choice': 'auto', 'tools': [{'type': 'custom', 'name': 'patch', 'strict': False}], 'top_p': None, 'background': None, 'conversation': None, 'max_output_tokens': 128, 'max_tool_calls': None, 'previous_response_id': None, 'prompt': None, 'prompt_cache_key': None, 'reasoning': {'effort': 'medium'}, 'safety_identifier': None, 'service_tier': None, 'status': 'in_progress', 'text': None, 'top_logprobs': None, 'truncation': 'disabled', 'usage': None, 'user': None, 'store': True}, 'sequence_number': 1, 'type': 'response.in_progress'}, {'item': {'id': 'rs_54b4b13b5cc24e3295d14b7e668d099e', 'summary': [], 'type': 'reasoning', 'content': [], 'encrypted_content': None, 'status': 'in_progress'}, 'output_index': 0, 'sequence_number': 2, 'type': 'response.output_item.added'}, {'content_index': 0, 'delta': 'P', 'item_id': 'rs_54b4b13b5cc24e3295d14b7e668d099e', 'output_index': 0, 'sequence_number': 3, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'l', 'item_id': 'rs_54b4b13b5cc24e3295d14b7e668d099e', 'output_index': 0, 'sequence_number': 4, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'a', 'item_id': 'rs_54b4b13b5cc24e3295d14b7e668d099e', 'output_index': 0, 'sequence_number': 5, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'delta': 'n', 'item_id': 'rs_54b4b13b5cc24e3295d14b7e668d099e', 'output_index': 0, 'sequence_number': 6, 'type': 'response.reasoning_text.delta'}, {'content_index': 0, 'item_id': 'rs_54b4b13b5cc24e3295d14b7e668d099e', 'output_index': 0, 'sequence_number': 7, 'text': 'Plan', 'type': 'response.reasoning_text.done'}, {'item': {'id': 'rs_54b4b13b5cc24e3295d14b7e668d099e', 'summary': [], 'type': 'reasoning', 'content': [{'text': 'Plan', 'type': 'reasoning_text'}], 'encrypted_content': None, 'status': 'completed'}, 'output_index': 0, 'sequence_number': 8, 'type': 'response.output_item.done'}, {'item': {'id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'content': [], 'role': 'assistant', 'status': 'in_progress', 'type': 'message', 'phase': None}, 'output_index': 1, 'sequence_number': 9, 'type': 'response.output_item.added'}, {'content_index': 0, 'item_id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'output_index': 1, 'part': {'annotations': [], 'text': '', 'type': 'output_text', 'logprobs': None}, 'sequence_number': 10, 'type': 'response.content_part.added'}, {'content_index': 0, 'delta': 'B', 'item_id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'logprobs': [], 'output_index': 1, 'sequence_number': 11, 'type': 'response.output_text.delta'}, {'content_index': 0, 'delta': 'e', 'item_id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'logprobs': [], 'output_index': 1, 'sequence_number': 12, 'type': 'response.output_text.delta'}, {'content_index': 0, 'delta': 'f', 'item_id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'logprobs': [], 'output_index': 1, 'sequence_number': 13, 'type': 'response.output_text.delta'}, {'content_index': 0, 'delta': 'o', 'item_id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'logprobs': [], 'output_index': 1, 'sequence_number': 14, 'type': 'response.output_text.delta'}, {'content_index': 0, 'delta': 'r', 'item_id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'logprobs': [], 'output_index': 1, 'sequence_number': 15, 'type': 'response.output_text.delta'}, {'content_index': 0, 'delta': 'e', 'item_id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'logprobs': [], 'output_index': 1, 'sequence_number': 16, 'type': 'response.output_text.delta'}, {'content_index': 0, 'item_id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'logprobs': [], 'output_index': 1, 'sequence_number': 17, 'text': 'Before', 'type': 'response.output_text.done'}, {'content_index': 0, 'item_id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'output_index': 1, 'part': {'annotations': [], 'text': 'Before', 'type': 'output_text', 'logprobs': None}, 'sequence_number': 18, 'type': 'response.content_part.done'}, {'item': {'id': 'msg_139efb4002f24a6a9fa4047366d0e1da', 'content': [{'annotations': [], 'text': 'Before', 'type': 'output_text', 'logprobs': None}], 'role': 'assistant', 'status': 'completed', 'type': 'message', 'phase': 'commentary'}, 'output_index': 1, 'sequence_number': 19, 'type': 'response.output_item.done'}, {'item': {'call_id': 'call_1ca6bdb77dbd4d73b82d74a5', 'name': 'patch', 'type': 'custom_tool_call', 'id': 'fc_ab137ee8', 'status': 'in_progress', 'input': ''}, 'output_index': 2, 'sequence_number': 20, 'type': 'response.output_item.added'}, {'response': {'id': 'resp_ff930110607e4f61956bc2d3a3c77070', 'created_at': 1789388713.0, 'error': None, 'incomplete_details': None, 'instructions': None, 'metadata': {}, 'model': 'fixture-qwen', 'object': 'response', 'output': [], 'parallel_tool_calls': True, 'temperature': None, 'tool_choice': 'auto', 'tools': [{'type': 'custom', 'name': 'patch', 'strict': False}], 'top_p': None, 'background': None, 'conversation': None, 'max_output_tokens': 128, 'max_tool_calls': None, 'previous_response_id': None, 'prompt': None, 'prompt_cache_key': None, 'reasoning': {'effort': 'medium'}, 'safety_identifier': None, 'service_tier': None, 'status': 'failed', 'text': None, 'top_logprobs': None, 'truncation': 'disabled', 'usage': None, 'user': None, 'store': True}, 'sequence_number': 21, 'type': 'response.failed'}] + +---------------------------------------------------------------------- +Ran 1 test in 1.830s + +FAILED (failures=4) diff --git a/tests/runtime_responses_compat.py b/tests/runtime_responses_compat.py index 2e9cf9f..3dc8720 100644 --- a/tests/runtime_responses_compat.py +++ b/tests/runtime_responses_compat.py @@ -587,6 +587,47 @@ def test_required_json_marker_like_values_remain_data(self): else: self.assertEqual(json.loads(item['arguments']), arguments) + def test_native_tool_payload_markers_after_reasoning_remain_data(self): + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = 'qwen3_coder' + cases = [ + ([{'type': 'function', 'name': 'inspect', 'parameters': { + 'type': 'object', 'properties': {'text': {'type': 'string'}}}}], + 'inspect', 'text', 'literal', 'function_call'), + ([{'type': 'custom', 'name': 'patch'}], + 'patch', 'input', 'literal', 'custom_tool_call'), + ] + for tools, name, parameter, value, output_type in cases: + self.text = ( + 'PlanBefore' + f'{value}' + 'After' + ) + for stream in (False, True): + with self.subTest(name=name, stream=stream): + response = self.send( + stream=stream, tools=tools, tool_choice='auto', + reasoning={'effort': 'medium'}) + if stream: + events = self.events(response) + completed = [event['response'] for event in events + if event['type'] == 'response.completed'] + self.assertTrue(completed, events) + body = completed[0] + else: + body = response.json() + self.assertEqual(response.status_code, 200, response.text) + self.assertEqual( + [item['type'] for item in body['output']], + ['reasoning', 'message', output_type, 'message'], + ) + call = body['output'][2] + if output_type == 'custom_tool_call': + self.assertEqual(call['input'], value) + else: + self.assertEqual(json.loads(call['arguments']), + {parameter: value}) + def test_text_streams_before_phase_is_resolved(self): async def check(): self.serving.reasoning_parser = None From 7fe50de3595dad2a6425f54c23f59cb46e8db409 Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 13:44:26 +0100 Subject: [PATCH 09/20] test(responses): capture implicit-close and scope regressions --- provenance/pr5-followup4-red.json | 20 +++++ provenance/pr5-followup4-red.log | 117 ++++++++++++++++++++++++++++++ tests/runtime_responses_compat.py | 69 ++++++++++++++++++ 3 files changed, 206 insertions(+) create mode 100644 provenance/pr5-followup4-red.json create mode 100644 provenance/pr5-followup4-red.log diff --git a/provenance/pr5-followup4-red.json b/provenance/pr5-followup4-red.json new file mode 100644 index 0000000..cc51244 --- /dev/null +++ b/provenance/pr5-followup4-red.json @@ -0,0 +1,20 @@ +{ + "phase": "FOLLOWUP4_RED", + "base_commit": "1cdf3838b38089fbcf3884662a6b30d2de6c9627", + "production_source_sha256": "84934a72e9c381cb86b4d1454cf9edac247e537fcfae8bf642d60528b5636aa1", + "trigger": "fourth independent read-only review", + "result": { + "exit_code": 1, + "test_methods_run": 2, + "failing_subtests": 5, + "errors": 0 + }, + "failing_behaviors": [ + "native tool implicitly closes an open reasoning block before payload shielding", + "qwen4_exp streaming behavior is independent of marker-aligned chunking" + ], + "sha256": { + "tests/runtime_responses_compat.py": "023dc25f1f8c011f2f79fda67b12d62b209aa279942fdea93640316f135ce20a", + "provenance/pr5-followup4-red.log": "bdde78b1e45273d083fb14148bf180536816815c583d5a39ae31f17e96b073be" + } +} diff --git a/provenance/pr5-followup4-red.log b/provenance/pr5-followup4-red.log new file mode 100644 index 0000000..661451c --- /dev/null +++ b/provenance/pr5-followup4-red.log @@ -0,0 +1,117 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 12:42:15.978000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa + + test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) (name='inspect', stream=False) ... FAIL + test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) (name='inspect', stream=True) ... FAIL + test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) (name='patch', stream=False) ... FAIL + test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) (name='patch', stream=True) ... FAIL +test_qwen4_stream_reasoning_is_chunking_negative_control (__main__.MockHTTPTest.test_qwen4_stream_reasoning_is_chunking_negative_control) ... + test_qwen4_stream_reasoning_is_chunking_negative_control (__main__.MockHTTPTest.test_qwen4_stream_reasoning_is_chunking_negative_control) (parts=['', 'First', '', 'Checking.', '', 'Second', '', 'Final']) ... FAIL + +====================================================================== +FAIL: test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) (name='inspect', stream=False) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 658, in test_native_tool_implicitly_closes_open_reasoning + self.assertEqual( +AssertionError: Lists differ: ['reasoning', 'function_call', 'reasoning'] != ['reasoning', 'function_call', 'message'] + +First differing element 2: +'reasoning' +'message' + +- ['reasoning', 'function_call', 'reasoning'] +? ^ ----- + ++ ['reasoning', 'function_call', 'message'] +? ^ ++ + + + +====================================================================== +FAIL: test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) (name='inspect', stream=True) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 658, in test_native_tool_implicitly_closes_open_reasoning + self.assertEqual( +AssertionError: Lists differ: ['reasoning', 'function_call', 'reasoning'] != ['reasoning', 'function_call', 'message'] + +First differing element 2: +'reasoning' +'message' + +- ['reasoning', 'function_call', 'reasoning'] +? ^ ----- + ++ ['reasoning', 'function_call', 'message'] +? ^ ++ + + + +====================================================================== +FAIL: test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) (name='patch', stream=False) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 658, in test_native_tool_implicitly_closes_open_reasoning + self.assertEqual( +AssertionError: Lists differ: ['reasoning', 'custom_tool_call', 'reasoning'] != ['reasoning', 'custom_tool_call', 'message'] + +First differing element 2: +'reasoning' +'message' + +- ['reasoning', 'custom_tool_call', 'reasoning'] +? ^ ----- + ++ ['reasoning', 'custom_tool_call', 'message'] +? ^ ++ + + + +====================================================================== +FAIL: test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) (name='patch', stream=True) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 658, in test_native_tool_implicitly_closes_open_reasoning + self.assertEqual( +AssertionError: Lists differ: ['reasoning', 'custom_tool_call', 'reasoning'] != ['reasoning', 'custom_tool_call', 'message'] + +First differing element 2: +'reasoning' +'message' + +- ['reasoning', 'custom_tool_call', 'reasoning'] +? ^ ----- + ++ ['reasoning', 'custom_tool_call', 'message'] +? ^ ++ + + + +====================================================================== +FAIL: test_qwen4_stream_reasoning_is_chunking_negative_control (__main__.MockHTTPTest.test_qwen4_stream_reasoning_is_chunking_negative_control) (parts=['', 'First', '', 'Checking.', '', 'Second', '', 'Final']) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 698, in test_qwen4_stream_reasoning_is_chunking_negative_control + self.assertEqual(self.phase_semantics(output), expected) +AssertionError: Lists differ: [('re[28 chars]e', 'commentary', 'Checking.'), ('reasoning', [43 chars]al')] != [('re[28 chars]e', 'final_answer', 'Checking.SecondFinal')] + +First differing element 1: +('message', 'commentary', 'Checking.') +('message', 'final_answer', 'Checking.SecondFinal') + +First list contains 2 additional elements. +First extra element 2: +('reasoning', 'Second') + + [('reasoning', 'First'), ++ ('message', 'final_answer', 'Checking.SecondFinal')] +- ('message', 'commentary', 'Checking.'), +- ('reasoning', 'Second'), +- ('message', 'final_answer', 'Final')] + +---------------------------------------------------------------------- +Ran 2 tests in 0.891s + +FAILED (failures=5) diff --git a/tests/runtime_responses_compat.py b/tests/runtime_responses_compat.py index 3dc8720..34c7896 100644 --- a/tests/runtime_responses_compat.py +++ b/tests/runtime_responses_compat.py @@ -628,6 +628,75 @@ def test_native_tool_payload_markers_after_reasoning_remain_data(self): self.assertEqual(json.loads(call['arguments']), {parameter: value}) + def test_native_tool_implicitly_closes_open_reasoning(self): + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = 'qwen3_coder' + cases = [ + ([{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}], + 'inspect', '', 'function_call'), + ([{'type': 'custom', 'name': 'patch'}], + 'patch', '', 'custom_tool_call'), + ] + for tools, name, parameters, output_type in cases: + self.text = (f'Plan{parameters}' + 'After') + for stream in (False, True): + with self.subTest(name=name, stream=stream): + response = self.send( + stream=stream, tools=tools, tool_choice='auto', + reasoning={'effort': 'medium'}) + if stream: + events = self.events(response) + completed = [event['response'] for event in events + if event['type'] == 'response.completed'] + self.assertTrue(completed, events) + body = completed[0] + else: + self.assertEqual(response.status_code, 200, response.text) + body = response.json() + self.assertEqual( + [item['type'] for item in body['output']], + ['reasoning', output_type, 'message'], + ) + self.assertEqual(self.phase_semantics( + [body['output'][0], body['output'][2]]), [ + ('reasoning', 'Plan'), + ('message', 'final_answer', 'After'), + ]) + + def test_qwen4_stream_reasoning_is_chunking_negative_control(self): + self.serving.tokenizer_manager.model_config.hf_config.model_type = 'qwen4_exp' + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = None + raw = 'FirstChecking.SecondFinal' + expected = [ + ('reasoning', 'First'), + ('message', 'final_answer', + 'Checking.SecondFinal'), + ] + for parts in ([raw], ['', 'First', '', 'Checking.', + '', 'Second', '', 'Final']): + with self.subTest(parts=parts): + async def generate(request, *args, **kwargs): + cumulative = '' + for index, part in enumerate(parts): + cumulative += part + yield {'text': cumulative, 'output_ids': [1] * (index + 1), + 'meta_info': {'prompt_tokens': 10, + 'completion_tokens': index + 1, + 'finish_reason': ({'type': 'stop'} + if index == len(parts) - 1 + else None)}} + + self.serving.tokenizer_manager.generate_request = generate + events = self.events(self.send( + stream=True, tools=[], tool_choice='none', + reasoning={'effort': 'medium'})) + output = next(event['response']['output'] for event in events + if event['type'] == 'response.completed') + self.assertEqual(self.phase_semantics(output), expected) + def test_text_streams_before_phase_is_resolved(self): async def check(): self.serving.reasoning_parser = None From 8b33799e4b21ef54c8a39250b692cd3a60b3c44b Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 13:58:47 +0100 Subject: [PATCH 10/20] test(responses): capture renewed reasoning after implicit close --- provenance/pr5-followup5-red.json | 18 ++++++ provenance/pr5-followup5-red.log | 101 ++++++++++++++++++++++++++++++ tests/runtime_responses_compat.py | 33 ++++++++++ 3 files changed, 152 insertions(+) create mode 100644 provenance/pr5-followup5-red.json create mode 100644 provenance/pr5-followup5-red.log diff --git a/provenance/pr5-followup5-red.json b/provenance/pr5-followup5-red.json new file mode 100644 index 0000000..6a9812b --- /dev/null +++ b/provenance/pr5-followup5-red.json @@ -0,0 +1,18 @@ +{ + "phase": "FOLLOWUP5_RED", + "base_commit": "7fe50de3595dad2a6425f54c23f59cb46e8db409", + "production_source_sha256": "b5387927a4ad72165c74557f1deb1e39cfd5c6aa3fae14bd23db83fafdbec670", + "trigger": "final independent read-only review suggestion converted to regression test", + "command": "exact pinned image, read-only/no-network CPU runner: python3 /repo/tests/runtime_responses_compat.py MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning -v", + "result": { + "exit_code": 1, + "test_methods_run": 1, + "failing_subtests": 4, + "errors": 0 + }, + "failing_behavior": "an explicitly renewed reasoning block after an implicitly closed native function/custom call is emitted as final-answer text", + "sha256": { + "tests/runtime_responses_compat.py": "81e68fa7138f33a1dab3911bf983032e6a8d4aa15b967803b117b0df623f8f6f", + "provenance/pr5-followup5-red.log": "9e9774959574a801f33723dacb6a3328c42fce90afec54483a329c795c3f6504" + } +} diff --git a/provenance/pr5-followup5-red.log b/provenance/pr5-followup5-red.log new file mode 100644 index 0000000..01d79c3 --- /dev/null +++ b/provenance/pr5-followup5-red.log @@ -0,0 +1,101 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 12:54:42.051000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa + + test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) (name='inspect', stream=False) ... FAIL + test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) (name='inspect', stream=True) ... FAIL + test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) (name='patch', stream=False) ... FAIL + test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) (name='patch', stream=True) ... FAIL + +====================================================================== +FAIL: test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) (name='inspect', stream=False) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 691, in test_implicit_tool_close_allows_renewed_reasoning + self.assertEqual([item['type'] for item in body['output']], +AssertionError: Lists differ: ['reasoning', 'function_call', 'message'] != ['reasoning', 'function_call', 'reasoning', 'message'] + +First differing element 2: +'message' +'reasoning' + +Second list contains 1 additional elements. +First extra element 3: +'message' + +- ['reasoning', 'function_call', 'message'] ++ ['reasoning', 'function_call', 'reasoning', 'message'] +? +++++++++++++ + + +====================================================================== +FAIL: test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) (name='inspect', stream=True) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 691, in test_implicit_tool_close_allows_renewed_reasoning + self.assertEqual([item['type'] for item in body['output']], +AssertionError: Lists differ: ['reasoning', 'function_call', 'message'] != ['reasoning', 'function_call', 'reasoning', 'message'] + +First differing element 2: +'message' +'reasoning' + +Second list contains 1 additional elements. +First extra element 3: +'message' + +- ['reasoning', 'function_call', 'message'] ++ ['reasoning', 'function_call', 'reasoning', 'message'] +? +++++++++++++ + + +====================================================================== +FAIL: test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) (name='patch', stream=False) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 691, in test_implicit_tool_close_allows_renewed_reasoning + self.assertEqual([item['type'] for item in body['output']], +AssertionError: Lists differ: ['reasoning', 'custom_tool_call', 'message'] != ['reasoning', 'custom_tool_call', 'reasoning', 'message'] + +First differing element 2: +'message' +'reasoning' + +Second list contains 1 additional elements. +First extra element 3: +'message' + +- ['reasoning', 'custom_tool_call', 'message'] ++ ['reasoning', 'custom_tool_call', 'reasoning', 'message'] +? +++++++++++++ + + +====================================================================== +FAIL: test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) (name='patch', stream=True) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 691, in test_implicit_tool_close_allows_renewed_reasoning + self.assertEqual([item['type'] for item in body['output']], +AssertionError: Lists differ: ['reasoning', 'custom_tool_call', 'message'] != ['reasoning', 'custom_tool_call', 'reasoning', 'message'] + +First differing element 2: +'message' +'reasoning' + +Second list contains 1 additional elements. +First extra element 3: +'message' + +- ['reasoning', 'custom_tool_call', 'message'] ++ ['reasoning', 'custom_tool_call', 'reasoning', 'message'] +? +++++++++++++ + + +---------------------------------------------------------------------- +Ran 1 test in 0.918s + +FAILED (failures=4) diff --git a/tests/runtime_responses_compat.py b/tests/runtime_responses_compat.py index 34c7896..f3ed398 100644 --- a/tests/runtime_responses_compat.py +++ b/tests/runtime_responses_compat.py @@ -665,6 +665,39 @@ def test_native_tool_implicitly_closes_open_reasoning(self): ('message', 'final_answer', 'After'), ]) + def test_implicit_tool_close_allows_renewed_reasoning(self): + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = 'qwen3_coder' + cases = [ + ([{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}], + 'inspect', '', 'function_call'), + ([{'type': 'custom', 'name': 'patch'}], + 'patch', '', 'custom_tool_call'), + ] + expected_types = ['reasoning', 'placeholder', 'reasoning', 'message'] + for tools, name, parameters, output_type in cases: + self.text = (f'Plan{parameters}' + 'AgainFinal') + for stream in (False, True): + with self.subTest(name=name, stream=stream): + response = self.send( + stream=stream, tools=tools, tool_choice='auto', + reasoning={'effort': 'medium'}) + body = (next(event['response'] for event in self.events(response) + if event['type'] == 'response.completed') + if stream else response.json()) + expected_types[1] = output_type + self.assertEqual([item['type'] for item in body['output']], + expected_types) + self.assertEqual(self.phase_semantics( + [body['output'][0], body['output'][2], + body['output'][3]]), [ + ('reasoning', 'Plan'), + ('reasoning', 'Again'), + ('message', 'final_answer', 'Final'), + ]) + def test_qwen4_stream_reasoning_is_chunking_negative_control(self): self.serving.tokenizer_manager.model_config.hf_config.model_type = 'qwen4_exp' self.serving.reasoning_parser = 'qwen3' From a42cf78b1e16642b0baaba276d5bde2a0bae8238 Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 14:08:23 +0100 Subject: [PATCH 11/20] test(responses): capture final parser attribution blockers --- provenance/pr5-followup6-red.json | 21 +++++++++ provenance/pr5-followup6-red.log | 73 +++++++++++++++++++++++++++++++ tests/runtime_responses_compat.py | 24 +++++++++- 3 files changed, 117 insertions(+), 1 deletion(-) create mode 100644 provenance/pr5-followup6-red.json create mode 100644 provenance/pr5-followup6-red.log diff --git a/provenance/pr5-followup6-red.json b/provenance/pr5-followup6-red.json new file mode 100644 index 0000000..1ec5ceb --- /dev/null +++ b/provenance/pr5-followup6-red.json @@ -0,0 +1,21 @@ +{ + "phase": "FOLLOWUP6_RED", + "base_commit": "8b33799e4b21ef54c8a39250b692cd3a60b3c44b", + "production_source_sha256": "dbd1a2c5f094b92be4c60c3db24192e4103f662dd62c939ce2b60765bdaa5e37", + "trigger": "final independent read-only merge-gate review", + "command": "exact pinned image, read-only/no-network CPU runner: two named MockHTTPTest methods", + "result": { + "exit_code": 1, + "test_methods_run": 2, + "failing_subtests": 3, + "errors": 0 + }, + "failing_behaviors": [ + "empty reasoning implicitly closed by native tool does not reset for renewed explicit reasoning", + "whole-generation output logprobs are duplicated across each ordered message instead of attributed per message" + ], + "sha256": { + "tests/runtime_responses_compat.py": "b3e970545939632068cc47e68c3085ed2d3a01af46b02112e1e53f23b85eb8cf", + "provenance/pr5-followup6-red.log": "9cd9dd70b7642de394f52d763d6397eb053d521423128937c5e4546af555b703" + } +} diff --git a/provenance/pr5-followup6-red.log b/provenance/pr5-followup6-red.log new file mode 100644 index 0000000..e0c0609 --- /dev/null +++ b/provenance/pr5-followup6-red.log @@ -0,0 +1,73 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 13:07:51.101000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_qwen_ordered_nonstream_preserves_requested_logprobs (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_requested_logprobs) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa +FAIL +test_empty_reasoning_implicit_tool_close_allows_renewal (__main__.MockHTTPTest.test_empty_reasoning_implicit_tool_close_allows_renewal) ... + test_empty_reasoning_implicit_tool_close_allows_renewal (__main__.MockHTTPTest.test_empty_reasoning_implicit_tool_close_allows_renewal) (stream=False) ... FAIL + test_empty_reasoning_implicit_tool_close_allows_renewal (__main__.MockHTTPTest.test_empty_reasoning_implicit_tool_close_allows_renewal) (stream=True) ... FAIL + +====================================================================== +FAIL: test_qwen_ordered_nonstream_preserves_requested_logprobs (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_requested_logprobs) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 370, in test_qwen_ordered_nonstream_preserves_requested_logprobs + self.assertEqual( +AssertionError: Lists differ: [['Checking.', 'Final answer.'], ['Checking.', 'Final answer.']] != [['Checking.'], ['Final answer.']] + +First differing element 0: +['Checking.', 'Final answer.'] +['Checking.'] + +- [['Checking.', 'Final answer.'], ['Checking.', 'Final answer.']] ++ [['Checking.'], ['Final answer.']] + +====================================================================== +FAIL: test_empty_reasoning_implicit_tool_close_allows_renewal (__main__.MockHTTPTest.test_empty_reasoning_implicit_tool_close_allows_renewal) (stream=False) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 716, in test_empty_reasoning_implicit_tool_close_allows_renewal + self.assertEqual([item['type'] for item in body['output']], +AssertionError: Lists differ: ['function_call', 'message'] != ['function_call', 'reasoning', 'message'] + +First differing element 1: +'message' +'reasoning' + +Second list contains 1 additional elements. +First extra element 2: +'message' + +- ['function_call', 'message'] ++ ['function_call', 'reasoning', 'message'] +? +++++++++++++ + + +====================================================================== +FAIL: test_empty_reasoning_implicit_tool_close_allows_renewal (__main__.MockHTTPTest.test_empty_reasoning_implicit_tool_close_allows_renewal) (stream=True) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_responses_compat.py", line 716, in test_empty_reasoning_implicit_tool_close_allows_renewal + self.assertEqual([item['type'] for item in body['output']], +AssertionError: Lists differ: ['function_call', 'message'] != ['function_call', 'reasoning', 'message'] + +First differing element 1: +'message' +'reasoning' + +Second list contains 1 additional elements. +First extra element 2: +'message' + +- ['function_call', 'message'] ++ ['function_call', 'reasoning', 'message'] +? +++++++++++++ + + +---------------------------------------------------------------------- +Ran 2 tests in 0.923s + +FAILED (failures=3) diff --git a/tests/runtime_responses_compat.py b/tests/runtime_responses_compat.py index f3ed398..36f1ac9 100644 --- a/tests/runtime_responses_compat.py +++ b/tests/runtime_responses_compat.py @@ -370,7 +370,7 @@ async def generate(request, *args, **kwargs): self.assertEqual( [[entry['token'] for entry in item['content'][0]['logprobs']] for item in messages], - [['Checking.', 'Final answer.'], ['Checking.', 'Final answer.']], + [['Checking.'], ['Final answer.']], ) self.assertEqual( messages[0]['content'][0]['logprobs'][0]['top_logprobs'][1]['token'], @@ -698,6 +698,28 @@ def test_implicit_tool_close_allows_renewed_reasoning(self): ('message', 'final_answer', 'Final'), ]) + def test_empty_reasoning_implicit_tool_close_allows_renewal(self): + self.serving.reasoning_parser = 'qwen3' + self.serving.tool_call_parser = 'qwen3_coder' + tools = [{'type': 'function', 'name': 'inspect', + 'parameters': {'type': 'object', 'properties': {}}}] + self.text = ('' + 'AgainFinal') + for stream in (False, True): + with self.subTest(stream=stream): + response = self.send( + stream=stream, tools=tools, tool_choice='auto', + reasoning={'effort': 'medium'}) + body = (next(event['response'] for event in self.events(response) + if event['type'] == 'response.completed') + if stream else response.json()) + self.assertEqual([item['type'] for item in body['output']], + ['function_call', 'reasoning', 'message']) + self.assertEqual(self.phase_semantics(body['output'][1:]), [ + ('reasoning', 'Again'), + ('message', 'final_answer', 'Final'), + ]) + def test_qwen4_stream_reasoning_is_chunking_negative_control(self): self.serving.tokenizer_manager.model_config.hf_config.model_type = 'qwen4_exp' self.serving.reasoning_parser = 'qwen3' From 9c91e4220d9e3f972096a232f836a01c4de823d8 Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 14:19:07 +0100 Subject: [PATCH 12/20] fix(responses): finalize ordered parser artifacts --- README.md | 5 +- docs/responses-compat.md | 45 +- patches/0017-responses-phase-order.patch | 587 ++++++++++++++++-- provenance/pr5-compile-diff-security.log | 1 + provenance/pr5-exact-image-reconstruction.log | 2 + provenance/pr5-final-targeted-green.log | 14 + provenance/pr5-followup-red.json | 2 +- provenance/pr5-followup-red.log | 8 +- provenance/pr5-merge-gate-green-focused.log | 162 +++++ provenance/pr5-merge-gate-green-full.log | 278 +++++++++ provenance/pr5-merge-gate-green.json | 111 ++++ .../responses-phase-order-runtime-files.json | 2 +- provenance/responses-phase-order.json | 93 ++- .../entrypoints/openai/serving_responses.py | 491 +++++++++++++-- tests/runtime_responses_compat.py | 18 +- 15 files changed, 1672 insertions(+), 147 deletions(-) create mode 100644 provenance/pr5-compile-diff-security.log create mode 100644 provenance/pr5-exact-image-reconstruction.log create mode 100644 provenance/pr5-final-targeted-green.log create mode 100644 provenance/pr5-merge-gate-green-focused.log create mode 100644 provenance/pr5-merge-gate-green-full.log create mode 100644 provenance/pr5-merge-gate-green.json diff --git a/README.md b/README.md index c55b439..7e6b0cd 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,10 @@ **Unpublished CPU candidate:** [Responses compatibility and Qwen phase/order](docs/responses-compat.md) adds separately attested boundary and streaming/nonstream ordering patches after the -effort-alias profile, including its `minimal` → `low` alias. Historical production +effort-alias profile, including its `minimal` → `low` alias. The ordered nonstream +path constructs typed output directly and retains usage details and requested +logprobs; structural splitting is limited to recognized Qwen markers and the loaded +`qwen3_8_flash_next` / `_text` model types. Historical production profiles below are unchanged; no deployment is implied. Publishable source and deployment package for the locally accepted Qwen3.8 diff --git a/docs/responses-compat.md b/docs/responses-compat.md index 030481d..c722bcc 100644 --- a/docs/responses-compat.md +++ b/docs/responses-compat.md @@ -89,13 +89,24 @@ The only new installed module is `responses_compat.py`. Streaming text is emitted immediately; an added message leaves phase unresolved when later reasoning or tool output can still change it. The completed item sets commentary when a tool call or renewed reasoning follows and final_answer when - the text ends the response. For affected Qwen complete outputs, nonstream reuses - that ordered parser path when a tool or renewed-reasoning boundary would otherwise - collapse items, preserving text → tool → text and text → reasoning → final parity. -- Qwen3.8 Flash-Next markup is fed to the existing reasoning and tool parsers at - markup boundaries. Coalesced, fragmented, and affected complete outputs preserve - `reasoning -> text -> tool -> text` wire order instead of merging text across a - tool call. Literal angle-bracket text still passes through the parsers. + the text ends the response. Affected Qwen complete outputs use a dedicated typed + nonstream collector when a tool or renewed-reasoning boundary would otherwise + collapse items. It never serializes or revalidates a streaming terminal response, + so request metadata, usage details and requested output logprobs stay on the normal + nonstream response path while text → tool → text and text → reasoning → final order + is preserved. +- Qwen3.8 Flash-Next markup is fed to the existing reasoning and tool parsers only at + recognized ``, tool-call, function and parameter markers. Coalesced, + fragmented, and affected complete outputs preserve `reasoning -> text -> tool -> + text` wire order instead of merging text across a tool call. Ordinary angle-bracket + text and custom raw input are not generically split. Possible partial control-marker + prefixes are buffered across engine chunks; repeated explicit reasoning blocks and + tool → renewed-reasoning transitions retain order. Required JSON values containing + marker-like strings remain data, as do recognized marker strings inside native + function/custom parameter payloads after reasoning. This behavior is limited to + loaded model types + `qwen3_8_flash_next` and `qwen3_8_flash_next_text`; `qwen4_exp` is an explicit + negative control. - Replay groups adjacent Qwen assistant items only while their stage order remains renderable as one native assistant turn. Explicit phase changes and restarted reasoning/tool sequences remain separate turns. Stored response replay retains @@ -120,6 +131,26 @@ generation is an injected controlled CPU manager, explicitly labelled **MOCK**. There is no alternate endpoint implementation or mocked serving method. Existing alias/Chat/Responses/tokenize tests and `scripts/test.sh` also run. +Strict TDD evidence is retained in `provenance/pr5-merge-gate-red.{json,log}` and +`provenance/pr5-merge-gate-green.json`. The RED run is pinned to reviewed head +`ed43202a522bc2a09eb08ebdc89705afc355030e`: 65 tests ran with four expected +failures covering usage details, requested logprobs, generic angle splitting and the +`qwen4_exp` scope leak. Independent reviews then found additional parser/order cases; +`provenance/pr5-followup-red.{json,log}` records 69 methods with 18 expected failing +subtests, and `pr5-followup2-red.{json,log}` records two focused methods with three +expected failing subtests. `pr5-followup3-red.{json,log}` records one focused method +with four expected failing subtests; `pr5-followup4-red.{json,log}` records two +focused methods with five expected failing subtests before the native implicit-close +and final `qwen4_exp` scope repairs. `pr5-followup5-red.{json,log}` records one focused +method with four expected failing subtests before renewed reasoning after an implicit +tool close was repaired. `pr5-followup6-red.{json,log}` records two focused methods +with three expected failures before empty implicit-close renewal and per-message +logprob attribution were repaired. The final exact-image targeted rerun passes both +named regressions; the focused run passes 75 Responses tests, and the full package +run passes 75 Responses, 14 effort-alias and 81 package CPU tests (170 executions). +The reconstruction receipt records two successful full-tree verifications of all +4,392 resulting files. + The pinned image contains OpenAI Python SDK 2.6.1. Imported SDK output and event unions, JSON serialization, and the actual SDK client against ASGI endpoints are tested for function/custom calls, empty and whitespace custom input, call IDs, diff --git a/patches/0017-responses-phase-order.patch b/patches/0017-responses-phase-order.patch index d87c52b..33b6b56 100644 --- a/patches/0017-responses-phase-order.patch +++ b/patches/0017-responses-phase-order.patch @@ -62,7 +62,7 @@ index c120d0a..44c91a1 100644 continue for c in it.content: diff --git a/python/sglang/srt/entrypoints/openai/serving_responses.py b/python/sglang/srt/entrypoints/openai/serving_responses.py -index 2fda942..49881f0 100644 +index 2fda942..844e011 100644 --- a/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -7,6 +7,7 @@ from __future__ import annotations @@ -91,51 +91,163 @@ index 2fda942..49881f0 100644 ResponsesRequest, ResponsesResponse, Tool, -@@ -737,6 +740,43 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -140,6 +143,67 @@ def _should_emit_normal_text_as_message( + return True + + ++_QWEN_STRUCTURAL_MARKER_RE = re.compile( ++ r"(||||" ++ r"\r\n]+>||" ++ r"\r\n]+>|)" ++) ++_QWEN_FIXED_STRUCTURAL_MARKERS = ( ++ "", ++ "", ++ "", ++ "", ++ "", ++ "", ++) ++_QWEN_DYNAMIC_STRUCTURAL_PREFIXES = ("\r\n]", text[1:])) ++ for prefix in _QWEN_DYNAMIC_STRUCTURAL_PREFIXES ++ ) ++ ++ ++class _QwenStructuralMarkerBuffer: ++ """Keep only possible split control markers between engine chunks.""" ++ ++ def __init__(self) -> None: ++ self.pending = "" ++ ++ def feed(self, text: str, *, final: bool) -> list[str]: ++ text = self.pending + text ++ self.pending = "" ++ parts: list[str] = [] ++ cursor = 0 ++ for match in _QWEN_STRUCTURAL_MARKER_RE.finditer(text): ++ if match.start() > cursor: ++ parts.append(text[cursor : match.start()]) ++ parts.append(match.group(0)) ++ cursor = match.end() ++ ++ remainder = text[cursor:] ++ if not final: ++ candidate_start = remainder.rfind("<") ++ if candidate_start >= 0 and _is_qwen_structural_marker_prefix( ++ remainder[candidate_start:] ++ ): ++ self.pending = remainder[candidate_start:] ++ remainder = remainder[:candidate_start] ++ if remainder: ++ parts.append(remainder) ++ return parts or ([""] if final else []) ++ ++ ++def _split_qwen_structural_markers(text: str) -> list[str]: ++ """Split only Qwen parser control markers, not arbitrary angle brackets.""" ++ return _QwenStructuralMarkerBuffer().feed(text, final=True) ++ ++ + class OpenAIServingResponses(OpenAIServingChat): + """Handler for /v1/responses requests""" + +@@ -737,19 +801,56 @@ class OpenAIServingResponses(OpenAIServingChat): meta_info.get("finish_reason") if meta_info is not None else None ) + final_text = final_res["text"] + model_type = self.tokenizer_manager.model_config.hf_config.model_type -+ leading_text, think_marker, _ = final_text.partition("") ++ leading_text, think_marker, trailing_text = final_text.partition("") ++ requires_tool_output = request.tool_choice == "required" or isinstance( ++ request.tool_choice, dict ++ ) ++ ordered_tool_boundary = ( ++ self.tool_call_parser == "qwen3_coder" ++ and request.tool_choice != "none" ++ and re.search( ++ r"\s*\s*\S", final_text, re.DOTALL ++ ) ++ ) ++ ordered_reasoning_boundary = ( ++ self.reasoning_parser in {"qwen3", "qwen3-thinking"} ++ and not ( ++ requires_tool_output and self.tool_call_parser != "qwen3_coder" ++ ) ++ and think_marker ++ and (leading_text.strip() or "" in trailing_text) ++ ) + needs_ordered_qwen_parse = ( + status == "completed" + and model_type -+ in {"qwen3_8_flash_next", "qwen3_8_flash_next_text", "qwen4_exp"} -+ and ( -+ re.search( -+ r"\s*\s*\S", final_text, re.DOTALL -+ ) -+ or (think_marker and leading_text.strip()) -+ ) ++ in {"qwen3_8_flash_next", "qwen3_8_flash_next_text"} ++ and (ordered_tool_boundary or ordered_reasoning_boundary) + ) + output_logprobs = ( + _build_output_text_logprobs(meta_info) + if request.is_include_output_logprobs() and isinstance(meta_info, dict) + else None + ) +- output = self._make_response_output_items( +- request, +- final_res["text"], +- tokenizer, +- output_logprobs=output_logprobs, +- require_reasoning=require_reasoning, +- status=status, +- ) + if needs_ordered_qwen_parse: -+ async def final_result(): -+ yield final_res -+ -+ terminal_response = None -+ async for frame in self.responses_stream_generator_non_harmony( ++ output = self._make_qwen_ordered_output_items( + request, -+ sampling_params, -+ final_result(), -+ model_name, + tokenizer, -+ request_metadata, -+ created_time=created_time, ++ final_text, ++ output_logprobs=output_logprobs, + require_reasoning=require_reasoning, -+ ): -+ event = json.loads(frame.split("data: ", 1)[1]) -+ if event.get("type") == "response.completed": -+ terminal_response = event["response"] -+ if terminal_response is None: -+ raise ValueError("Ordered Qwen output did not complete") -+ terminal_response["tools"] = request.model_dump()["tools"] -+ return ResponsesResponse.model_validate(terminal_response) -+ - output_logprobs = ( - _build_output_text_logprobs(meta_info) - if request.is_include_output_logprobs() and isinstance(meta_info, dict) -@@ -1009,6 +1049,7 @@ class OpenAIServingResponses(OpenAIServingChat): ++ status=status, ++ ) ++ else: ++ output = self._make_response_output_items( ++ request, ++ final_text, ++ tokenizer, ++ output_logprobs=output_logprobs, ++ require_reasoning=require_reasoning, ++ status=status, ++ ) + + if meta_info is not None: + num_prompt_tokens = meta_info.get("prompt_tokens", 0) +@@ -890,7 +991,13 @@ class OpenAIServingResponses(OpenAIServingChat): + status: str = "completed", + ): + chat_tools = self._response_tools_to_chat_tools(request) +- if self.reasoning_parser: ++ is_required = request.tool_choice == "required" or isinstance( ++ request.tool_choice, dict ++ ) ++ uses_required_json = ( ++ bool(chat_tools) and is_required and self.tool_call_parser is None ++ ) ++ if self.reasoning_parser and not uses_required_json: + reasoning_parser = ReasoningParser( + model_type=self.reasoning_parser, + stream_reasoning=False, +@@ -938,7 +1045,6 @@ class OpenAIServingResponses(OpenAIServingChat): + ) + output_items.append(reasoning_item) + +- is_required = request.tool_choice == "required" or isinstance(request.tool_choice, dict) + if status != "completed" and chat_tools and is_required: + return output_items + tool_call_items: list[ResponseFunctionToolCall] = [] +@@ -1009,11 +1115,259 @@ class OpenAIServingResponses(OpenAIServingChat): role="assistant", status="completed", type="message", @@ -143,7 +255,259 @@ index 2fda942..49881f0 100644 ) output_items.append(message) output_items.extend(tool_call_items) -@@ -1232,10 +1273,39 @@ class OpenAIServingResponses(OpenAIServingChat): + return output_items + ++ def _make_qwen_ordered_output_items( ++ self, ++ request: ResponsesRequest, ++ tokenizer: Any, ++ final_output: str, ++ output_logprobs: Optional[list] = None, ++ *, ++ require_reasoning: bool, ++ status: str, ++ ) -> list: ++ """Parse completed Qwen structural markers into typed items in wire order.""" ++ chat_tools = self._response_tools_to_chat_tools(request) ++ tool_parser: Optional[FunctionCallParser] = None ++ if chat_tools and self.tool_call_parser and request.tool_choice != "none": ++ tool_parser = FunctionCallParser( ++ chat_tools, ++ self.tool_call_parser, ++ tokenizer=self.tokenizer_manager.tokenizer, ++ ) ++ assert tool_parser is not None ++ if hasattr(tool_parser.detector, "preserve_raw_input_tools"): ++ tool_parser.detector.preserve_raw_input_tools = ( ++ request._custom_tool_names ++ ) ++ ++ def new_reasoning_parser() -> ReasoningParser: ++ return ReasoningParser( ++ model_type=self.reasoning_parser, ++ stream_reasoning=True, ++ force_reasoning=( ++ self.template_manager.force_reasoning or require_reasoning ++ ), ++ request=request, ++ tokenizer=tokenizer, ++ tool_call_parser_active=tool_parser is not None, ++ ) ++ ++ reasoning_parser_obj: Optional[ReasoningParser] = ( ++ new_reasoning_parser() if self.reasoning_parser else None ++ ) ++ reasoning_block_closed = False ++ reasoning_block_started = False ++ inside_tool_call = False ++ ++ output_items: list = [] ++ message_text = "" ++ message_logprobs: list[Logprob] = [] ++ reasoning_text = "" ++ tool_states: dict[int, dict[str, str]] = {} ++ wants_summary = self._wants_reasoning_summary(request) ++ output_logprob_index = 0 ++ ++ def take_part_logprobs(part: str) -> list[Logprob]: ++ """Consume logprobs only when their tokens exactly cover this part.""" ++ nonlocal output_logprob_index ++ if output_logprobs is None or not part: ++ return [] ++ start = output_logprob_index ++ text = "" ++ entries: list[Logprob] = [] ++ while output_logprob_index < len(output_logprobs): ++ entry = output_logprobs[output_logprob_index] ++ candidate = text + entry.token ++ if not part.startswith(candidate): ++ output_logprob_index = start ++ return [] ++ text = candidate ++ entries.append(entry) ++ output_logprob_index += 1 ++ if text == part: ++ return entries ++ output_logprob_index = start ++ return [] ++ ++ def close_message(phase: Any) -> None: ++ nonlocal message_text, message_logprobs ++ if not message_text: ++ return ++ output_items.append( ++ ResponseOutputMessage( ++ id=f"msg_{random_uuid()}", ++ type="message", ++ role="assistant", ++ content=[ ++ ResponseOutputText( ++ type="output_text", ++ text=message_text, ++ annotations=[], ++ logprobs=( ++ message_logprobs ++ if output_logprobs is not None ++ else None ++ ), ++ ) ++ ], ++ status="completed", ++ phase=phase, ++ ) ++ ) ++ message_text = "" ++ message_logprobs = [] ++ ++ def close_reasoning() -> None: ++ nonlocal reasoning_text ++ if not reasoning_text: ++ return ++ output_items.append( ++ ResponseReasoningItem( ++ id=f"rs_{random_uuid()}", ++ type="reasoning", ++ summary=( ++ [ ++ ResponseReasoningSummary( ++ type="summary_text", text=reasoning_text ++ ) ++ ] ++ if wants_summary ++ else [] ++ ), ++ content=[ ++ ResponseReasoningTextContent( ++ type="reasoning_text", text=reasoning_text ++ ) ++ ], ++ status="completed", ++ ) ++ ) ++ reasoning_text = "" ++ ++ def close_tools(except_index: Optional[int] = None) -> None: ++ for tool_index in list(tool_states): ++ if tool_index == except_index: ++ continue ++ state = tool_states.pop(tool_index) ++ output_items.append( ++ ResponseFunctionToolCall( ++ arguments=state["arguments"], ++ call_id=state["call_id"], ++ name=state["name"], ++ type="function_call", ++ id=state["item_id"], ++ status="completed", ++ ) ++ ) ++ ++ def emit_calls(calls: list[ToolCallItem]) -> None: ++ if calls: ++ close_reasoning() ++ close_message("commentary") ++ for call in calls: ++ state = tool_states.get(call.tool_index) ++ if state is None: ++ close_tools() ++ state = { ++ "item_id": f"fc_{random_uuid()[:8]}", ++ "call_id": f"call_{random_uuid()[:24]}", ++ "name": call.name or "", ++ "arguments": "", ++ } ++ tool_states[call.tool_index] = state ++ elif call.name: ++ state["name"] = call.name ++ if call.parameters: ++ state["arguments"] += call.parameters ++ ++ def consume( ++ normal_text: str, ++ calls: list[ToolCallItem], ++ normal_logprobs: Optional[list[Logprob]] = None, ++ ) -> None: ++ nonlocal message_text, message_logprobs ++ continuing = [ ++ call for call in calls if call.tool_index in tool_states ++ ] ++ opening = [ ++ call for call in calls if call.tool_index not in tool_states ++ ] ++ emit_calls(continuing) ++ if normal_text and _should_emit_normal_text_as_message( ++ normal_text, ++ any_tool_call_in_progress=bool(tool_states), ++ ): ++ close_reasoning() ++ close_tools() ++ message_text += normal_text ++ message_logprobs.extend(normal_logprobs or []) ++ emit_calls(opening) ++ ++ for part in _split_qwen_structural_markers(final_output): ++ part_logprobs = take_part_logprobs(part) ++ entering_tool_call = tool_parser is not None and part == "" ++ if ( ++ part == "" ++ and not inside_tool_call ++ and reasoning_block_closed ++ and reasoning_parser_obj is not None ++ ): ++ close_reasoning() ++ reasoning_parser_obj = new_reasoning_parser() ++ reasoning_block_closed = False ++ reasoning_block_started = False ++ if part == "" and not inside_tool_call: ++ reasoning_block_started = True ++ if reasoning_parser_obj is not None and not inside_tool_call: ++ reasoning_chunk, normal = reasoning_parser_obj.parse_stream_chunk(part) ++ else: ++ reasoning_chunk, normal = None, part ++ if part == "" and not inside_tool_call: ++ reasoning_block_closed = True ++ reasoning_block_started = False ++ if reasoning_chunk: ++ close_message("commentary") ++ close_tools() ++ reasoning_text += reasoning_chunk ++ if entering_tool_call and (reasoning_block_started or reasoning_text): ++ reasoning_block_closed = True ++ reasoning_block_started = False ++ if entering_tool_call: ++ inside_tool_call = True ++ if tool_parser is not None: ++ normal_text, calls = tool_parser.parse_stream_chunk(normal) ++ consume(normal_text or "", list(calls), part_logprobs) ++ else: ++ consume(normal or "", [], part_logprobs) ++ if tool_parser is not None and part == "": ++ inside_tool_call = False ++ ++ if reasoning_parser_obj is not None: ++ end_reasoning, end_normal = reasoning_parser_obj.parse_stream_end() ++ if end_reasoning: ++ close_message("commentary") ++ reasoning_text += end_reasoning ++ else: ++ end_normal = "" ++ if tool_parser is not None: ++ normal_text, calls = tool_parser.parse_stream_chunk(end_normal or "") ++ end_text, end_calls = tool_parser.parse_stream_end() ++ consume((normal_text or "") + end_text, list(calls) + list(end_calls)) ++ else: ++ consume(end_normal or "", []) ++ ++ close_reasoning() ++ close_message("final_answer") ++ if status == "completed": ++ close_tools() ++ return output_items ++ + def _make_response_output_items_with_harmony( + self, + context: HarmonyContext, +@@ -1232,10 +1586,39 @@ class OpenAIServingResponses(OpenAIServingChat): @staticmethod def _merge_consecutive_assistant_messages( messages: list, @@ -183,7 +547,7 @@ index 2fda942..49881f0 100644 merged: list = [] for msg in messages: if ( -@@ -1244,8 +1314,16 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -1244,8 +1627,16 @@ class OpenAIServingResponses(OpenAIServingChat): and merged and isinstance(merged[-1], dict) and merged[-1].get("role") == "assistant" @@ -200,7 +564,7 @@ index 2fda942..49881f0 100644 # Lift mixed str/list content to list parts so non-text parts # (e.g. image_url) survive when the two sides differ in shape. new_content = msg.get("content") -@@ -1305,13 +1383,9 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -1305,13 +1696,9 @@ class OpenAIServingResponses(OpenAIServingChat): messages.extend(prev_msg) for output_item in prev_response.output: @@ -217,7 +581,7 @@ index 2fda942..49881f0 100644 # Append the new input # Responses API supports simple text inputs without chat format -@@ -1326,7 +1400,15 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -1326,7 +1713,14 @@ class OpenAIServingResponses(OpenAIServingChat): # One Responses-API assistant turn maps to multiple input items # (message + function_call(s)); collapse them into one chat message # so chat templates render a single assistant block per turn. @@ -225,7 +589,6 @@ index 2fda942..49881f0 100644 + is_qwen = self.tokenizer_manager.model_config.hf_config.model_type in { + "qwen3_8_flash_next", + "qwen3_8_flash_next_text", -+ "qwen4_exp", + } + messages = self._merge_consecutive_assistant_messages( + messages, @@ -234,24 +597,46 @@ index 2fda942..49881f0 100644 # Most chat templates expect a single leading ``system`` message; # coalesce any ``instructions`` + interleaved ``developer`` entries. -@@ -2091,6 +2173,16 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2076,9 +2470,8 @@ class OpenAIServingResponses(OpenAIServingChat): + ) + if hasattr(tool_parser.detector, "preserve_raw_input_tools"): + tool_parser.detector.preserve_raw_input_tools = request._custom_tool_names +- reasoning_parser_obj: Optional[ReasoningParser] = None +- if self.reasoning_parser: +- reasoning_parser_obj = ReasoningParser( ++ def new_reasoning_parser() -> ReasoningParser: ++ return ReasoningParser( + model_type=self.reasoning_parser, + stream_reasoning=True, + # A template that prefills forces the parser open even +@@ -2091,6 +2484,26 @@ class OpenAIServingResponses(OpenAIServingChat): tool_call_parser_active=isinstance(tool_parser, FunctionCallParser), ) ++ reasoning_parser_obj: Optional[ReasoningParser] = ( ++ new_reasoning_parser() ++ if self.reasoning_parser and not isinstance(tool_parser, JsonArrayParser) ++ else None ++ ) ++ reasoning_block_closed = False ++ reasoning_block_started = False ++ inside_tool_call = False ++ + # These parsers return separate text and call collections. Feed Qwen + # markup boundaries separately so their original order remains visible. + split_qwen_markup = ( + self.tokenizer_manager.model_config.hf_config.model_type -+ in {"qwen3_8_flash_next", "qwen3_8_flash_next_text", "qwen4_exp"} ++ in {"qwen3_8_flash_next", "qwen3_8_flash_next_text"} + and self.reasoning_parser in {None, "qwen3", "qwen3-thinking"} + and self.tool_call_parser in {None, "qwen3_coder"} + and (reasoning_parser_obj is not None or tool_parser is not None) + ) ++ marker_splitter = _QwenStructuralMarkerBuffer() if split_qwen_markup else None + current_output_index = -1 reasoning_state = { "open": False, -@@ -2211,7 +2303,7 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2211,7 +2624,7 @@ class OpenAIServingResponses(OpenAIServingChat): ) return item_id @@ -260,7 +645,7 @@ index 2fda942..49881f0 100644 if not message_state["open"]: return [] text = message_state["text"] -@@ -2224,6 +2316,7 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2224,6 +2637,7 @@ class OpenAIServingResponses(OpenAIServingChat): role="assistant", content=[text_content], status="completed", @@ -268,7 +653,7 @@ index 2fda942..49881f0 100644 ) events = [ _send_event( -@@ -2248,7 +2341,7 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2248,7 +2662,7 @@ class OpenAIServingResponses(OpenAIServingChat): ) ), _send_event( @@ -277,14 +662,18 @@ index 2fda942..49881f0 100644 type="response.output_item.done", sequence_number=-1, output_index=message_state["output_index"], -@@ -2335,241 +2428,259 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2335,241 +2749,325 @@ class OpenAIServingResponses(OpenAIServingChat): ) flushed = flushed or flush - if reasoning_parser_obj is not None: - reasoning_chunk, delta = reasoning_parser_obj.parse_stream_chunk( - delta -- ) ++ parts = ( ++ marker_splitter.feed( ++ delta, ++ final=finish_reason is not None, + ) - if flush: - end_reasoning, end_normal = ( - reasoning_parser_obj.parse_stream_end() @@ -299,7 +688,28 @@ index 2fda942..49881f0 100644 - if reasoning_chunk: - if message_state["open"]: - for ev in _close_message_item(): -- yield ev ++ if marker_splitter is not None ++ else [delta] ++ ) ++ flush_chunk = flush ++ for part_index, delta in enumerate(parts): ++ # Flush parser state once, after the terminal piece. ++ flush = flush_chunk and part_index == len(parts) - 1 ++ structural_part = delta ++ entering_tool_call = ( ++ marker_splitter is not None ++ and tool_parser is not None ++ and structural_part == "" ++ ) ++ if ( ++ marker_splitter is not None ++ and delta == "" ++ and not inside_tool_call ++ and reasoning_block_closed ++ and reasoning_parser_obj is not None ++ ): ++ for ev in _close_reasoning_item(): + yield ev - if not reasoning_state["open"]: - item_id = _open_reasoning_item() - yield _send_event( @@ -315,17 +725,16 @@ index 2fda942..49881f0 100644 - status="in_progress", - ), - ) -+ parts = ( -+ [part for part in re.split(r"(?=<)|(?<=>)", delta) if part] -+ or [""] -+ if split_qwen_markup -+ else [delta] -+ ) -+ flush_chunk = flush -+ for part_index, delta in enumerate(parts): -+ # Flush parser state once, after the terminal piece. -+ flush = flush_chunk and part_index == len(parts) - 1 -+ if reasoning_parser_obj is not None: ++ reasoning_parser_obj = new_reasoning_parser() ++ reasoning_block_closed = False ++ reasoning_block_started = False ++ if ( ++ marker_splitter is not None ++ and structural_part == "" ++ and not inside_tool_call ++ ): ++ reasoning_block_started = True ++ if reasoning_parser_obj is not None and not inside_tool_call: + reasoning_chunk, delta = reasoning_parser_obj.parse_stream_chunk( + delta ) @@ -344,7 +753,10 @@ index 2fda942..49881f0 100644 - ), - sequence_number=-1, - ) -- ) ++ if flush: ++ end_reasoning, end_normal = ( ++ reasoning_parser_obj.parse_stream_end() + ) - reasoning_state["text"] += reasoning_chunk - if wants_summary: - yield _send_event( @@ -355,10 +767,7 @@ index 2fda942..49881f0 100644 - summary_index=0, - delta=reasoning_chunk, - sequence_number=-1, -+ if flush: -+ end_reasoning, end_normal = ( -+ reasoning_parser_obj.parse_stream_end() - ) +- ) - ) + if end_reasoning: + reasoning_chunk = (reasoning_chunk or "") + end_reasoning @@ -378,8 +787,7 @@ index 2fda942..49881f0 100644 - - if not delta and not flush: - continue -+ reasoning_chunk = None - +- - if isinstance(tool_parser, JsonArrayParser): - required_buffer += delta - normal_text, tool_calls = "", [] @@ -398,7 +806,15 @@ index 2fda942..49881f0 100644 - tool_calls = list(tool_calls) + end_calls - else: - normal_text, tool_calls = delta, [] -- ++ reasoning_chunk = None ++ if ( ++ marker_splitter is not None ++ and structural_part == "" ++ and not inside_tool_call ++ ): ++ reasoning_block_closed = True ++ reasoning_block_started = False + - def _emit_tool_calls(calls): - nonlocal current_output_index - if calls: @@ -438,6 +854,9 @@ index 2fda942..49881f0 100644 - if request._compat_registry is not None: - request._compat_registry.output_identity(state["name"]) - state["added"] = True ++ for tool_index in list(tool_call_states): ++ for ev in _close_tool_call_state(tool_index): ++ yield ev + if not reasoning_state["open"]: + item_id = _open_reasoning_item() yield _send_event( @@ -533,6 +952,14 @@ index 2fda942..49881f0 100644 - ), ) ) ++ if entering_tool_call and ( ++ reasoning_block_started or reasoning_state["open"] ++ ): ++ reasoning_block_closed = True ++ reasoning_block_started = False ++ ++ if entering_tool_call: ++ inside_tool_call = True + + if not delta and not flush: + continue @@ -541,10 +968,26 @@ index 2fda942..49881f0 100644 + required_buffer += delta + normal_text, tool_calls = "", [] + if flush and required_buffer.strip(): ++ try: ++ validated_calls = list( ++ validated_json_calls( ++ required_buffer, ++ {tool.function.name for tool in chat_tools}, ++ ) ++ ) ++ except ValueError: ++ # Public Responses validation below emits the ++ # established streaming error for malformed or ++ # unknown required output. ++ validated_calls = [] + tool_calls = [ -+ ToolCallItem(tool_index=index, name=name, parameters=arguments) ++ ToolCallItem( ++ tool_index=index, ++ name=name, ++ parameters=arguments, ++ ) + for index, (name, arguments) in enumerate( -+ validated_json_calls(required_buffer, {tool.function.name for tool in chat_tools}) ++ validated_calls + ) + ] + elif tool_parser is not None: @@ -713,10 +1156,10 @@ index 2fda942..49881f0 100644 - def _is_continuing(call): - state = tool_call_states.get(call.tool_index) - return state is not None and not state.get("done") -- + - continuing = [c for c in tool_calls if _is_continuing(c)] - opening = [c for c in tool_calls if not _is_continuing(c)] - +- - for ev in _emit_tool_calls(continuing): - yield ev - for ev in _emit_normal_text(): @@ -740,6 +1183,12 @@ index 2fda942..49881f0 100644 + yield ev + for ev in _emit_tool_calls(opening): + yield ev ++ if ( ++ marker_splitter is not None ++ and tool_parser is not None ++ and structural_part == "" ++ ): ++ inside_tool_call = False except Exception: logger.exception("Error while streaming /v1/responses") failed = _sanitize_response_dict( diff --git a/provenance/pr5-compile-diff-security.log b/provenance/pr5-compile-diff-security.log new file mode 100644 index 0000000..5b60b5f --- /dev/null +++ b/provenance/pr5-compile-diff-security.log @@ -0,0 +1 @@ +{'compileall': 'reconstructed source tree passed', 'py_compile': 'focused sources and fixture passed', 'diff_check': 'passed', 'patch_apply_check': 'passed', 'security_findings': {'credential_assignment': 0, 'shell_execution': 0, 'dynamic_eval_exec': 0, 'unsafe_pickle': 0, 'formatted_sql': 0}, 'generic_angle_split': False, 'qwen4_exp_in_patch': False} diff --git a/provenance/pr5-exact-image-reconstruction.log b/provenance/pr5-exact-image-reconstruction.log new file mode 100644 index 0000000..11819ba --- /dev/null +++ b/provenance/pr5-exact-image-reconstruction.log @@ -0,0 +1,2 @@ +{"profile": "responses-phase-order-candidate", "source_files": 4392, "full_tree_verified": true} +{"profile": "responses-phase-order-candidate", "source_files": 4392, "full_tree_verified": true} diff --git a/provenance/pr5-final-targeted-green.log b/provenance/pr5-final-targeted-green.log new file mode 100644 index 0000000..ec70ec0 --- /dev/null +++ b/provenance/pr5-final-targeted-green.log @@ -0,0 +1,14 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 13:14:56.823000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_empty_reasoning_implicit_tool_close_allows_renewal (__main__.MockHTTPTest.test_empty_reasoning_implicit_tool_close_allows_renewal) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa +ok +test_qwen_ordered_nonstream_preserves_requested_logprobs (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_requested_logprobs) ... ok + +---------------------------------------------------------------------- +Ran 2 tests in 0.871s + +OK diff --git a/provenance/pr5-followup-red.json b/provenance/pr5-followup-red.json index 49eebca..6580382 100644 --- a/provenance/pr5-followup-red.json +++ b/provenance/pr5-followup-red.json @@ -18,6 +18,6 @@ ], "sha256": { "tests/runtime_responses_compat.py": "b019131ac8415e095187dd5dacf8cb93e31eb56fd33e95b7b02948f96fa1edc2", - "provenance/pr5-followup-red.log": "13118c0772f76d711eb6fd6f7ee44f124ebc65ea8a7ce892f01412188a861495" + "provenance/pr5-followup-red.log": "cdc9d5bf5ad163b9f2c869936258e1b97f418a838a36cde30f56c1cde7b75e17" } } diff --git a/provenance/pr5-followup-red.log b/provenance/pr5-followup-red.log index 930a2dd..9fc384a 100644 --- a/provenance/pr5-followup-red.log +++ b/provenance/pr5-followup-red.log @@ -191,12 +191,12 @@ test_qwen_nonstream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.tes test_qwen_nonstream_preserves_text_tool_text_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_text_tool_text_order) ... ok test_qwen_ordered_nonstream_preserves_requested_logprobs (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_requested_logprobs) ... ok test_qwen_ordered_nonstream_preserves_usage_details (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_usage_details) ... ok -test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) ... +test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) ... test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) (stream=False) ... FAIL test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) (stream=True) ... FAIL test_qwen_stream_has_no_generic_angle_boundary_split (__main__.MockHTTPTest.test_qwen_stream_has_no_generic_angle_boundary_split) ... ok test_qwen_stream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_stream_preserves_renewed_reasoning_order) ... ok -test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) ... +test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) ... test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=10) ... FAIL test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=11) ... FAIL test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=False, cut=12) ... FAIL @@ -210,10 +210,10 @@ test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPT test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=14) ... FAIL test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) (incremental=True, cut=15) ... FAIL test_qwen_stream_preserves_text_tool_text_order_for_any_chunking (__main__.MockHTTPTest.test_qwen_stream_preserves_text_tool_text_order_for_any_chunking) ... ok -test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) ... +test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) ... test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) (stream=False) ... FAIL test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) (stream=True) ... FAIL -test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) ... +test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) ... test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) (generated_name='inspect') ... FAIL test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) (generated_name='patch') ... FAIL test_text_streams_before_phase_is_resolved (__main__.MockHTTPTest.test_text_streams_before_phase_is_resolved) ... ok diff --git a/provenance/pr5-merge-gate-green-focused.log b/provenance/pr5-merge-gate-green-focused.log new file mode 100644 index 0000000..745385d --- /dev/null +++ b/provenance/pr5-merge-gate-green-focused.log @@ -0,0 +1,162 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 13:15:19.049000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok +test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok +test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok +test_top_level_xhigh_reaches_real_tokenizer (runtime_chat_effort.ChatEffortTest.test_top_level_xhigh_reaches_real_tokenizer) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:1039: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field + "max_new_tokens": self.max_completion_tokens or self.max_tokens, +ok +test_background_requires_storage (__main__.MockHTTPTest.test_background_requires_storage) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:337: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(error)) +ok +test_direct_flat_result_retains_typed_api (__main__.MockHTTPTest.test_direct_flat_result_retains_typed_api) ... ok +test_empty_reasoning_implicit_tool_close_allows_renewal (__main__.MockHTTPTest.test_empty_reasoning_implicit_tool_close_allows_renewal) ... ok +test_failed_and_disconnected_stream_preserves_stored_identity (__main__.MockHTTPTest.test_failed_and_disconnected_stream_preserves_stored_identity) ... ok +test_fix2_custom_delimiter_limit_and_json_alternative (__main__.MockHTTPTest.test_fix2_custom_delimiter_limit_and_json_alternative) ... Parsed parameter 'other' is not defined in the tool parameters for tool 'patch', directly returning the string value. +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:690: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) +Parsed parameter 'other' is not defined in the tool parameters for tool 'patch', directly returning the string value. +ok +test_fix2_custom_history_rejects_embedded_function_after_gap (__main__.MockHTTPTest.test_fix2_custom_history_rejects_embedded_function_after_gap) ... ok +test_fix2_embedded_flat_and_history (__main__.MockHTTPTest.test_fix2_embedded_flat_and_history) ... ok +test_fix2_embedded_identity_rejection (__main__.MockHTTPTest.test_fix2_embedded_identity_rejection) ... ok +test_fix2_embedded_supported_and_custom_distinctions (__main__.MockHTTPTest.test_fix2_embedded_supported_and_custom_distinctions) ... ok +test_fix2_selected_single_required_multiple (__main__.MockHTTPTest.test_fix2_selected_single_required_multiple) ... ok +test_fix2_terminal_cardinality (__main__.MockHTTPTest.test_fix2_terminal_cardinality) ... ok +test_fix2_unsupported_embedded_forms (__main__.MockHTTPTest.test_fix2_unsupported_embedded_forms) ... ok +test_fix3_malformed_success_remains_rejected (__main__.MockHTTPTest.test_fix3_malformed_success_remains_rejected) ... ok +test_fix3_native_auto_terminal_text (__main__.MockHTTPTest.test_fix3_native_auto_terminal_text) ... ok +test_fix3_partial_no_store (__main__.MockHTTPTest.test_fix3_partial_no_store) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1945: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_fix3_partial_terminal_matrix (__main__.MockHTTPTest.test_fix3_partial_terminal_matrix) ... ok +test_fix3_terminal_text_and_no_store (__main__.MockHTTPTest.test_fix3_terminal_text_and_no_store) ... ok +test_fixer_conflicting_forced_representations_before_generation (__main__.MockHTTPTest.test_fixer_conflicting_forced_representations_before_generation) ... ok +test_fixer_descriptions_reach_rendered_prompt (__main__.MockHTTPTest.test_fixer_descriptions_reach_rendered_prompt) ... ok +test_fixer_generated_history_survives_output_only_and_multiple_turns (__main__.MockHTTPTest.test_fixer_generated_history_survives_output_only_and_multiple_turns) ... ok +test_fixer_image_history_survives_no_declaration_gaps (__main__.MockHTTPTest.test_fixer_image_history_survives_no_declaration_gaps) ... ok +test_fixer_pinned_sdk_client_terminal_roundtrip (__main__.MockHTTPTest.test_fixer_pinned_sdk_client_terminal_roundtrip) ... /usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +/usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +/usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +ok +test_fixer_pinned_sdk_output_and_event_roundtrip_replay (__main__.MockHTTPTest.test_fixer_pinned_sdk_output_and_event_roundtrip_replay) ... ok +test_fixer_whole_history_collision_parity (__main__.MockHTTPTest.test_fixer_whole_history_collision_parity) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:337: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(error)) +ok +test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) ... ok +test_mock_http_custom_literal_angles_preserve_order_and_payload (__main__.MockHTTPTest.test_mock_http_custom_literal_angles_preserve_order_and_payload) ... ok +test_mock_http_custom_native_empty_and_escaped (__main__.MockHTTPTest.test_mock_http_custom_native_empty_and_escaped) ... ok +test_mock_http_custom_raw_and_stateless_replay (__main__.MockHTTPTest.test_mock_http_custom_raw_and_stateless_replay) ... ok +test_mock_http_flat_history_without_active_tools (__main__.MockHTTPTest.test_mock_http_flat_history_without_active_tools) ... ok +test_mock_http_flat_regression (__main__.MockHTTPTest.test_mock_http_flat_regression) ... ok +test_mock_http_forced_choice_cannot_emit_other_declared_tool (__main__.MockHTTPTest.test_mock_http_forced_choice_cannot_emit_other_declared_tool) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:690: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3063, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2954, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 121, in output_identity + raise ValueError("Generated tool call does not match forced tool choice") +ValueError: Generated tool call does not match forced tool choice +ok +test_mock_http_json_schema_and_explicit_nulls (__main__.MockHTTPTest.test_mock_http_json_schema_and_explicit_nulls) ... ok +test_mock_http_multimodal_tool_result_and_alias_provenance (__main__.MockHTTPTest.test_mock_http_multimodal_tool_result_and_alias_provenance) ... ok +test_mock_http_namespace_nonstream_and_stateful_replay (__main__.MockHTTPTest.test_mock_http_namespace_nonstream_and_stateful_replay) ... ok +test_mock_http_namespace_sse_lifecycle (__main__.MockHTTPTest.test_mock_http_namespace_sse_lifecycle) ... ok +test_mock_http_native_auto_and_required (__main__.MockHTTPTest.test_mock_http_native_auto_and_required) ... ok +test_mock_http_native_unknown_fails_closed (__main__.MockHTTPTest.test_mock_http_native_unknown_fails_closed) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3063, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2954, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 122, in output_identity + return self.identity(qualified) + ^^^^^^^^^^^^^^^^^^^^^^^^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 116, in identity + raise ValueError(f"Unknown generated tool identity: {qualified}") +ValueError: Unknown generated tool identity: workspace.NOT_DECLARED +ok +test_mock_http_parallel_dotted_and_duplicate_local_names (__main__.MockHTTPTest.test_mock_http_parallel_dotted_and_duplicate_local_names) ... ok +test_mock_http_rejected_call_cannot_be_replayed_from_store (__main__.MockHTTPTest.test_mock_http_rejected_call_cannot_be_replayed_from_store) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1945: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_mock_http_rejects_unknown_and_forced_invalid (__main__.MockHTTPTest.test_mock_http_rejects_unknown_and_forced_invalid) ... ok +test_mock_http_replay_cannot_forge_flat_dotted_identity (__main__.MockHTTPTest.test_mock_http_replay_cannot_forge_flat_dotted_identity) ... ok +test_mock_http_request_provenance_and_unrelated_model (__main__.MockHTTPTest.test_mock_http_request_provenance_and_unrelated_model) ... ok +test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) ... ok +test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) ... ok +test_nonstream_message_phase_matches_remaining_tool_calls (__main__.MockHTTPTest.test_nonstream_message_phase_matches_remaining_tool_calls) ... ok +test_qwen4_exp_is_negative_control_for_ordered_nonstream (__main__.MockHTTPTest.test_qwen4_exp_is_negative_control_for_ordered_nonstream) ... ok +test_qwen4_stream_reasoning_is_chunking_negative_control (__main__.MockHTTPTest.test_qwen4_stream_reasoning_is_chunking_negative_control) ... ok +test_qwen_adjacent_reasoning_blocks_remain_distinct (__main__.MockHTTPTest.test_qwen_adjacent_reasoning_blocks_remain_distinct) ... ok +test_qwen_literal_angle_brackets_survive_text_tool_text (__main__.MockHTTPTest.test_qwen_literal_angle_brackets_survive_text_tool_text) ... ok +test_qwen_nonstream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_renewed_reasoning_order) ... ok +test_qwen_nonstream_preserves_text_tool_text_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_text_tool_text_order) ... ok +test_qwen_ordered_nonstream_preserves_requested_logprobs (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_requested_logprobs) ... ok +test_qwen_ordered_nonstream_preserves_usage_details (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_usage_details) ... ok +test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) ... ok +test_qwen_stream_has_no_generic_angle_boundary_split (__main__.MockHTTPTest.test_qwen_stream_has_no_generic_angle_boundary_split) ... ok +test_qwen_stream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_stream_preserves_renewed_reasoning_order) ... ok +test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) ... ok +test_qwen_stream_preserves_text_tool_text_order_for_any_chunking (__main__.MockHTTPTest.test_qwen_stream_preserves_text_tool_text_order_for_any_chunking) ... ok +test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) ... ok +test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) ... ok +test_text_streams_before_phase_is_resolved (__main__.MockHTTPTest.test_text_streams_before_phase_is_resolved) ... ok +test_collisions_and_malformed_members (__main__.ResponsesCompatTest.test_collisions_and_malformed_members) ... ok +test_custom_declaration_reaches_chat (__main__.ResponsesCompatTest.test_custom_declaration_reaches_chat) ... ok +test_custom_grammar_visible (__main__.ResponsesCompatTest.test_custom_grammar_visible) ... ok +test_harmony_same_request_call_replay (__main__.ResponsesCompatTest.test_harmony_same_request_call_replay) ... ok +test_image_result_preserved (__main__.ResponsesCompatTest.test_image_result_preserved) ... ok +test_message_phase_survives_response_models (__main__.ResponsesCompatTest.test_message_phase_survives_response_models) ... ok +test_namespace_declaration_reaches_chat (__main__.ResponsesCompatTest.test_namespace_declaration_reaches_chat) ... ok +test_qualified_replay (__main__.ResponsesCompatTest.test_qualified_replay) ... ok +test_qwen_replay_preserves_assistant_stage_order (__main__.ResponsesCompatTest.test_qwen_replay_preserves_assistant_stage_order) ... ok +test_stored_response_replays_reasoning_phase_and_call_together (__main__.ResponsesCompatTest.test_stored_response_replays_reasoning_phase_and_call_together) ... ok + +---------------------------------------------------------------------- +Ran 75 tests in 4.882s + +OK diff --git a/provenance/pr5-merge-gate-green-full.log b/provenance/pr5-merge-gate-green-full.log new file mode 100644 index 0000000..bce5286 --- /dev/null +++ b/provenance/pr5-merge-gate-green-full.log @@ -0,0 +1,278 @@ +{"profile": "responses-phase-order-candidate", "source_files": 4392, "full_tree_verified": false} +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 13:15:37.481000 7 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok +test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok +test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok +test_top_level_xhigh_reaches_real_tokenizer (runtime_chat_effort.ChatEffortTest.test_top_level_xhigh_reaches_real_tokenizer) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:1039: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field + "max_new_tokens": self.max_completion_tokens or self.max_tokens, +ok +test_background_requires_storage (__main__.MockHTTPTest.test_background_requires_storage) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:337: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(error)) +ok +test_direct_flat_result_retains_typed_api (__main__.MockHTTPTest.test_direct_flat_result_retains_typed_api) ... ok +test_empty_reasoning_implicit_tool_close_allows_renewal (__main__.MockHTTPTest.test_empty_reasoning_implicit_tool_close_allows_renewal) ... ok +test_failed_and_disconnected_stream_preserves_stored_identity (__main__.MockHTTPTest.test_failed_and_disconnected_stream_preserves_stored_identity) ... ok +test_fix2_custom_delimiter_limit_and_json_alternative (__main__.MockHTTPTest.test_fix2_custom_delimiter_limit_and_json_alternative) ... Parsed parameter 'other' is not defined in the tool parameters for tool 'patch', directly returning the string value. +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:690: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) +Parsed parameter 'other' is not defined in the tool parameters for tool 'patch', directly returning the string value. +ok +test_fix2_custom_history_rejects_embedded_function_after_gap (__main__.MockHTTPTest.test_fix2_custom_history_rejects_embedded_function_after_gap) ... ok +test_fix2_embedded_flat_and_history (__main__.MockHTTPTest.test_fix2_embedded_flat_and_history) ... ok +test_fix2_embedded_identity_rejection (__main__.MockHTTPTest.test_fix2_embedded_identity_rejection) ... ok +test_fix2_embedded_supported_and_custom_distinctions (__main__.MockHTTPTest.test_fix2_embedded_supported_and_custom_distinctions) ... ok +test_fix2_selected_single_required_multiple (__main__.MockHTTPTest.test_fix2_selected_single_required_multiple) ... ok +test_fix2_terminal_cardinality (__main__.MockHTTPTest.test_fix2_terminal_cardinality) ... ok +test_fix2_unsupported_embedded_forms (__main__.MockHTTPTest.test_fix2_unsupported_embedded_forms) ... ok +test_fix3_malformed_success_remains_rejected (__main__.MockHTTPTest.test_fix3_malformed_success_remains_rejected) ... ok +test_fix3_native_auto_terminal_text (__main__.MockHTTPTest.test_fix3_native_auto_terminal_text) ... ok +test_fix3_partial_no_store (__main__.MockHTTPTest.test_fix3_partial_no_store) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1945: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_fix3_partial_terminal_matrix (__main__.MockHTTPTest.test_fix3_partial_terminal_matrix) ... ok +test_fix3_terminal_text_and_no_store (__main__.MockHTTPTest.test_fix3_terminal_text_and_no_store) ... ok +test_fixer_conflicting_forced_representations_before_generation (__main__.MockHTTPTest.test_fixer_conflicting_forced_representations_before_generation) ... ok +test_fixer_descriptions_reach_rendered_prompt (__main__.MockHTTPTest.test_fixer_descriptions_reach_rendered_prompt) ... ok +test_fixer_generated_history_survives_output_only_and_multiple_turns (__main__.MockHTTPTest.test_fixer_generated_history_survives_output_only_and_multiple_turns) ... ok +test_fixer_image_history_survives_no_declaration_gaps (__main__.MockHTTPTest.test_fixer_image_history_survives_no_declaration_gaps) ... ok +test_fixer_pinned_sdk_client_terminal_roundtrip (__main__.MockHTTPTest.test_fixer_pinned_sdk_client_terminal_roundtrip) ... /usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +/usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +/usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +ok +test_fixer_pinned_sdk_output_and_event_roundtrip_replay (__main__.MockHTTPTest.test_fixer_pinned_sdk_output_and_event_roundtrip_replay) ... ok +test_fixer_whole_history_collision_parity (__main__.MockHTTPTest.test_fixer_whole_history_collision_parity) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:337: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(error)) +ok +test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) ... ok +test_mock_http_custom_literal_angles_preserve_order_and_payload (__main__.MockHTTPTest.test_mock_http_custom_literal_angles_preserve_order_and_payload) ... ok +test_mock_http_custom_native_empty_and_escaped (__main__.MockHTTPTest.test_mock_http_custom_native_empty_and_escaped) ... ok +test_mock_http_custom_raw_and_stateless_replay (__main__.MockHTTPTest.test_mock_http_custom_raw_and_stateless_replay) ... ok +test_mock_http_flat_history_without_active_tools (__main__.MockHTTPTest.test_mock_http_flat_history_without_active_tools) ... ok +test_mock_http_flat_regression (__main__.MockHTTPTest.test_mock_http_flat_regression) ... ok +test_mock_http_forced_choice_cannot_emit_other_declared_tool (__main__.MockHTTPTest.test_mock_http_forced_choice_cannot_emit_other_declared_tool) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:690: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3063, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2954, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 121, in output_identity + raise ValueError("Generated tool call does not match forced tool choice") +ValueError: Generated tool call does not match forced tool choice +ok +test_mock_http_json_schema_and_explicit_nulls (__main__.MockHTTPTest.test_mock_http_json_schema_and_explicit_nulls) ... ok +test_mock_http_multimodal_tool_result_and_alias_provenance (__main__.MockHTTPTest.test_mock_http_multimodal_tool_result_and_alias_provenance) ... ok +test_mock_http_namespace_nonstream_and_stateful_replay (__main__.MockHTTPTest.test_mock_http_namespace_nonstream_and_stateful_replay) ... ok +test_mock_http_namespace_sse_lifecycle (__main__.MockHTTPTest.test_mock_http_namespace_sse_lifecycle) ... ok +test_mock_http_native_auto_and_required (__main__.MockHTTPTest.test_mock_http_native_auto_and_required) ... ok +test_mock_http_native_unknown_fails_closed (__main__.MockHTTPTest.test_mock_http_native_unknown_fails_closed) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3063, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2954, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 122, in output_identity + return self.identity(qualified) + ^^^^^^^^^^^^^^^^^^^^^^^^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 116, in identity + raise ValueError(f"Unknown generated tool identity: {qualified}") +ValueError: Unknown generated tool identity: workspace.NOT_DECLARED +ok +test_mock_http_parallel_dotted_and_duplicate_local_names (__main__.MockHTTPTest.test_mock_http_parallel_dotted_and_duplicate_local_names) ... ok +test_mock_http_rejected_call_cannot_be_replayed_from_store (__main__.MockHTTPTest.test_mock_http_rejected_call_cannot_be_replayed_from_store) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1945: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_mock_http_rejects_unknown_and_forced_invalid (__main__.MockHTTPTest.test_mock_http_rejects_unknown_and_forced_invalid) ... ok +test_mock_http_replay_cannot_forge_flat_dotted_identity (__main__.MockHTTPTest.test_mock_http_replay_cannot_forge_flat_dotted_identity) ... ok +test_mock_http_request_provenance_and_unrelated_model (__main__.MockHTTPTest.test_mock_http_request_provenance_and_unrelated_model) ... ok +test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) ... ok +test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) ... ok +test_nonstream_message_phase_matches_remaining_tool_calls (__main__.MockHTTPTest.test_nonstream_message_phase_matches_remaining_tool_calls) ... ok +test_qwen4_exp_is_negative_control_for_ordered_nonstream (__main__.MockHTTPTest.test_qwen4_exp_is_negative_control_for_ordered_nonstream) ... ok +test_qwen4_stream_reasoning_is_chunking_negative_control (__main__.MockHTTPTest.test_qwen4_stream_reasoning_is_chunking_negative_control) ... ok +test_qwen_adjacent_reasoning_blocks_remain_distinct (__main__.MockHTTPTest.test_qwen_adjacent_reasoning_blocks_remain_distinct) ... ok +test_qwen_literal_angle_brackets_survive_text_tool_text (__main__.MockHTTPTest.test_qwen_literal_angle_brackets_survive_text_tool_text) ... ok +test_qwen_nonstream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_renewed_reasoning_order) ... ok +test_qwen_nonstream_preserves_text_tool_text_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_text_tool_text_order) ... ok +test_qwen_ordered_nonstream_preserves_requested_logprobs (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_requested_logprobs) ... ok +test_qwen_ordered_nonstream_preserves_usage_details (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_usage_details) ... ok +test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) ... ok +test_qwen_stream_has_no_generic_angle_boundary_split (__main__.MockHTTPTest.test_qwen_stream_has_no_generic_angle_boundary_split) ... ok +test_qwen_stream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_stream_preserves_renewed_reasoning_order) ... ok +test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) ... ok +test_qwen_stream_preserves_text_tool_text_order_for_any_chunking (__main__.MockHTTPTest.test_qwen_stream_preserves_text_tool_text_order_for_any_chunking) ... ok +test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) ... ok +test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) ... ok +test_text_streams_before_phase_is_resolved (__main__.MockHTTPTest.test_text_streams_before_phase_is_resolved) ... ok +test_collisions_and_malformed_members (__main__.ResponsesCompatTest.test_collisions_and_malformed_members) ... ok +test_custom_declaration_reaches_chat (__main__.ResponsesCompatTest.test_custom_declaration_reaches_chat) ... ok +test_custom_grammar_visible (__main__.ResponsesCompatTest.test_custom_grammar_visible) ... ok +test_harmony_same_request_call_replay (__main__.ResponsesCompatTest.test_harmony_same_request_call_replay) ... ok +test_image_result_preserved (__main__.ResponsesCompatTest.test_image_result_preserved) ... ok +test_message_phase_survives_response_models (__main__.ResponsesCompatTest.test_message_phase_survives_response_models) ... ok +test_namespace_declaration_reaches_chat (__main__.ResponsesCompatTest.test_namespace_declaration_reaches_chat) ... ok +test_qualified_replay (__main__.ResponsesCompatTest.test_qualified_replay) ... ok +test_qwen_replay_preserves_assistant_stage_order (__main__.ResponsesCompatTest.test_qwen_replay_preserves_assistant_stage_order) ... ok +test_stored_response_replays_reasoning_phase_and_call_together (__main__.ResponsesCompatTest.test_stored_response_replays_reasoning_phase_and_call_together) ... ok + +---------------------------------------------------------------------- +Ran 75 tests in 5.161s + +OK +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 13:15:49.667000 1488 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok +test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok +test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok +test_top_level_xhigh_reaches_real_tokenizer (runtime_chat_effort.ChatEffortTest.test_top_level_xhigh_reaches_real_tokenizer) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:1039: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field + "max_new_tokens": self.max_completion_tokens or self.max_tokens, +ok +test_anthropic_messages_effort_uses_shared_aliases (__main__.QwenAliasTest.test_anthropic_messages_effort_uses_shared_aliases) ... ok +test_chat_alias_tokens_and_literal_provenance (__main__.QwenAliasTest.test_chat_alias_tokens_and_literal_provenance) ... ok +test_invalid_values_still_fail (__main__.QwenAliasTest.test_invalid_values_still_fail) ... ok +test_processing_special_token_state_survives_render_copy (__main__.QwenAliasTest.test_processing_special_token_state_survives_render_copy) ... ok +test_responses_real_conversion_and_literal_effort (__main__.QwenAliasTest.test_responses_real_conversion_and_literal_effort) ... ok +test_server_default_and_absence_semantics (__main__.QwenAliasTest.test_server_default_and_absence_semantics) ... ok +test_supported_values_precedence_null_and_no_leak (__main__.QwenAliasTest.test_supported_values_precedence_null_and_no_leak) ... ok +test_tokenize_and_multimodal_render_paths (__main__.QwenAliasTest.test_tokenize_and_multimodal_render_paths) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py:875: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field + max_output_tokens = request.max_completion_tokens or request.max_tokens +ok +test_tokenize_precedence_null_and_provenance (__main__.QwenAliasTest.test_tokenize_precedence_null_and_provenance) ... ok +test_unrelated_model_native_efforts_are_not_aliased (__main__.QwenAliasTest.test_unrelated_model_native_efforts_are_not_aliased) ... ok + +---------------------------------------------------------------------- +Ran 14 tests in 2.570s + +OK +{"clean_patch_apply": true, "verified_changed_paths": 36, "syntax_checked_python_files": 36} +test_baseline_compares_only_named_numeric_values (test_diagnostics.DiagnosticsTests.test_baseline_compares_only_named_numeric_values) ... ok +test_baseline_hundreds_digit_integer_is_unavailable (test_diagnostics.DiagnosticsTests.test_baseline_hundreds_digit_integer_is_unavailable) ... ok +test_baseline_tiny_positive_value_percentage_is_unavailable (test_diagnostics.DiagnosticsTests.test_baseline_tiny_positive_value_percentage_is_unavailable) ... ok +test_bounded_local_reads_and_command_failures_are_sanitized (test_diagnostics.DiagnosticsTests.test_bounded_local_reads_and_command_failures_are_sanitized) ... ok +test_cgroup_v2_and_v1_limits_and_counters_without_paths (test_diagnostics.DiagnosticsTests.test_cgroup_v2_and_v1_limits_and_counters_without_paths) ... ok +test_cli_bounds_and_errors_never_echo_sensitive_arguments (test_diagnostics.DiagnosticsTests.test_cli_bounds_and_errors_never_echo_sensitive_arguments) ... ok +test_container_allowlists_values_digest_effective_args_and_fixed_probe (test_diagnostics.DiagnosticsTests.test_container_allowlists_values_digest_effective_args_and_fixed_probe) ... ok +test_container_cgroup_counters_are_sampled_without_repeated_exec (test_diagnostics.DiagnosticsTests.test_container_cgroup_counters_are_sampled_without_repeated_exec) ... ok +test_current_driver_ansi_topology_and_singular_event_tags (test_diagnostics.DiagnosticsTests.test_current_driver_ansi_topology_and_singular_event_tags) ... ok +test_default_cli_writes_private_reports_without_network_or_docker (test_diagnostics.DiagnosticsTests.test_default_cli_writes_private_reports_without_network_or_docker) ... ok +test_docker_cgroup_does_not_guess_host_pid_inside_collector_container (test_diagnostics.DiagnosticsTests.test_docker_cgroup_does_not_guess_host_pid_inside_collector_container) ... ok +test_docker_pid_namespace_requires_visible_peer_and_matching_namespaces (test_diagnostics.DiagnosticsTests.test_docker_pid_namespace_requires_visible_peer_and_matching_namespaces) ... ok +test_docker_remote_environment_and_default_context_cannot_override_local_socket (test_diagnostics.DiagnosticsTests.test_docker_remote_environment_and_default_context_cannot_override_local_socket) ... ok +test_endpoint_typed_metrics_drop_nested_secrets_and_duplicate_series (test_diagnostics.DiagnosticsTests.test_endpoint_typed_metrics_drop_nested_secrets_and_duplicate_series) ... ok +test_gpu_xml_versions_units_and_identifier_redaction (test_diagnostics.DiagnosticsTests.test_gpu_xml_versions_units_and_identifier_redaction) ... ok +test_host_collection_reads_numeric_topology_pressure_and_counters (test_diagnostics.DiagnosticsTests.test_host_collection_reads_numeric_topology_pressure_and_counters) ... ok +test_http_opt_in_rejects_credentials_redirects_and_oversize (test_diagnostics.DiagnosticsTests.test_http_opt_in_rejects_credentials_redirects_and_oversize) ... ok +test_http_parent_allowlists_worker_errors_and_suppresses_launch_errors (test_diagnostics.DiagnosticsTests.test_http_parent_allowlists_worker_errors_and_suppresses_launch_errors) ... ok +test_http_protocol_errors_never_escape_or_reach_stderr (test_diagnostics.DiagnosticsTests.test_http_protocol_errors_never_escape_or_reach_stderr) ... ok +test_http_real_malformed_status_has_no_traceback_or_endpoint_output (test_diagnostics.DiagnosticsTests.test_http_real_malformed_status_has_no_traceback_or_endpoint_output) ... ok +test_http_total_deadline_includes_headers_and_slow_body (test_diagnostics.DiagnosticsTests.test_http_total_deadline_includes_headers_and_slow_body) ... ok +test_http_total_deadline_kills_and_reaps_stalled_dns_worker (test_diagnostics.DiagnosticsTests.test_http_total_deadline_kills_and_reaps_stalled_dns_worker) ... ok +test_http_total_deadline_terminates_trickled_headers (test_diagnostics.DiagnosticsTests.test_http_total_deadline_terminates_trickled_headers) ... ok +test_http_worker_inherits_auth_without_command_line_secrets_and_preserves_metrics (test_diagnostics.DiagnosticsTests.test_http_worker_inherits_auth_without_command_line_secrets_and_preserves_metrics) ... ok +test_http_worker_is_reaped_even_when_pipe_communication_fails (test_diagnostics.DiagnosticsTests.test_http_worker_is_reaped_even_when_pipe_communication_fails) ... ok +test_interval_rates_counter_resets_and_yield_are_not_global_iterations (test_diagnostics.DiagnosticsTests.test_interval_rates_counter_resets_and_yield_are_not_global_iterations) ... ok +test_sampler_executes_existing_load_reads_and_records_actual_intervals (test_diagnostics.DiagnosticsTests.test_sampler_executes_existing_load_reads_and_records_actual_intervals) ... ok +test_script_entrypoint_executes_as_a_real_local_process (test_diagnostics.DiagnosticsTests.test_script_entrypoint_executes_as_a_real_local_process) ... ok +test_selected_gpu_collection_filters_topology_and_capabilities (test_diagnostics.DiagnosticsTests.test_selected_gpu_collection_filters_topology_and_capabilities) ... ok +test_server_info_top_level_settings_are_allowlisted (test_diagnostics.DiagnosticsTests.test_server_info_top_level_settings_are_allowlisted) ... ok +test_v2_root_missing_limit_files_do_not_hide_child_limits (test_diagnostics.DiagnosticsTests.test_v2_root_missing_limit_files_do_not_hide_child_limits) ... ok +test_actual_shard_loader_reversed_pairs_late_global_scale (test_integration.IntegrationTests.test_actual_shard_loader_reversed_pairs_late_global_scale) ... ok +test_gather_normalizes_strided_ids_before_either_kernel (test_integration.IntegrationTests.test_gather_normalizes_strided_ids_before_either_kernel) ... ok +test_gather_rejects_noncontiguous_output_before_launch (test_integration.IntegrationTests.test_gather_rejects_noncontiguous_output_before_launch) ... ok +test_loader_finalization_rejects_wrong_configured_shard_count (test_integration.IntegrationTests.test_loader_finalization_rejects_wrong_configured_shard_count) ... ok +test_opt_in_constructs_only_meta_table_and_keeps_default_unchanged (test_integration.IntegrationTests.test_opt_in_constructs_only_meta_table_and_keeps_default_unchanged) ... ok +test_packed_loader_rejects_malformed_shards_before_buffering (test_integration.IntegrationTests.test_packed_loader_rejects_malformed_shards_before_buffering) ... ok +test_packed_loader_requires_complete_tp1_global_layout (test_integration.IntegrationTests.test_packed_loader_requires_complete_tp1_global_layout) ... ok +test_packed_loader_requires_exactly_128_complete_shard_pairs (test_integration.IntegrationTests.test_packed_loader_requires_exactly_128_complete_shard_pairs) ... ok +test_pinned_class_constructs_packed_and_gathers_to_prefetch_output (test_integration.IntegrationTests.test_pinned_class_constructs_packed_and_gathers_to_prefetch_output) ... ok +test_synthetic_128_shard_shapes_pass_source_validation (test_integration.IntegrationTests.test_synthetic_128_shard_shapes_pass_source_validation) ... ok +test_changed_runtime_hashes_match_manifest (test_packaging.PackagingTests.test_changed_runtime_hashes_match_manifest) ... ok +test_patch_path_coverage_is_exact (test_packaging.PackagingTests.test_patch_path_coverage_is_exact) ... ok +test_preimage_drift_is_rejected_before_patching (test_packaging.PackagingTests.test_preimage_drift_is_rejected_before_patching) ... ok +test_source_drift_is_rejected (test_packaging.PackagingTests.test_source_drift_is_rejected) ... ok +test_all_finite_positive_e4m3_scales_and_fp8_rounding_ties (test_packed_ple.PackedPLETests.test_all_finite_positive_e4m3_scales_and_fp8_rounding_ties) ... ok +test_kernel_all_nibbles_group_scales_global_and_row_selection (test_packed_ple.PackedPLETests.test_kernel_all_nibbles_group_scales_global_and_row_selection) ... ok +test_storage_rejects_changed_destination_bounds (test_packed_ple.PackedPLETests.test_storage_rejects_changed_destination_bounds) ... ok +test_storage_rejects_invalid_layout_scale_and_incomplete_load (test_packed_ple.PackedPLETests.test_storage_rejects_invalid_layout_scale_and_incomplete_load) ... ok +test_storage_retains_bytes_copies_overlap_and_preserves_global_scale (test_packed_ple.PackedPLETests.test_storage_retains_bytes_copies_overlap_and_preserves_global_scale) ... ok +test_synthetic_row_selection_and_optional_fp8_reference (test_packed_ple.PackedPLETests.test_synthetic_row_selection_and_optional_fp8_reference) ... ok +test_disabled_retains_exact_target (test_private_head.PrivateHeadTests.test_disabled_retains_exact_target) ... ok +test_private_shell_does_not_mutate_target_registries (test_private_head.PrivateHeadTests.test_private_shell_does_not_mutate_target_registries) ... ok +test_actual_mtp_method_preserves_tied_path_and_uses_private_for_untied (test_production.ProductionTests.test_actual_mtp_method_preserves_tied_path_and_uses_private_for_untied) ... ok +test_external_command_exact_tokens_and_environment (test_production.ProductionTests.test_external_command_exact_tokens_and_environment) ... ok +test_invalid_gate_rejected_and_default_shared (test_production.ProductionTests.test_invalid_gate_rejected_and_default_shared) ... ok +test_only_hf_path_correction_differs_between_profiles (test_production.ProductionTests.test_only_hf_path_correction_differs_between_profiles) ... ok +test_production_clean_reconstruction (test_production.ProductionTests.test_production_clean_reconstruction) ... ok +test_builds_do_not_package_defaults_launchers (test_quickstart.QuickstartTests.test_builds_do_not_package_defaults_launchers) ... ok +test_external_profile_matches_deployed_settings (test_quickstart.QuickstartTests.test_external_profile_matches_deployed_settings) ... ok +test_all_five_mounted_sources_fail_on_drift (test_responses_packaging.ResponsesPackagingTest.test_all_five_mounted_sources_fail_on_drift) ... ok +test_full_manifest_chain_and_new_file_count (test_responses_packaging.ResponsesPackagingTest.test_full_manifest_chain_and_new_file_count) ... ok +test_packaged_source_drift_fails_closed (test_responses_packaging.ResponsesPackagingTest.test_packaged_source_drift_fails_closed) ... ok +test_patch_drift_fails_closed (test_responses_packaging.ResponsesPackagingTest.test_patch_drift_fails_closed) ... ok +test_both_ranks_64_local_128_global_and_padding (test_tp2.TP2Tests.test_both_ranks_64_local_128_global_and_padding) ... ok +test_constructor_allocates_only_local_padded_bytes (test_tp2.TP2Tests.test_constructor_allocates_only_local_padded_bytes) ... ok +test_crossing_shard_simulated_sum_matches_tp1_and_reference (test_tp2.TP2Tests.test_crossing_shard_simulated_sum_matches_tp1_and_reference) ... ok +test_duplicate_completed_offrank_tensor_rejected_immediately (test_tp2.TP2Tests.test_duplicate_completed_offrank_tensor_rejected_immediately) ... ok +test_malformed_source_identifiers_are_not_silently_ignored (test_tp2.TP2Tests.test_malformed_source_identifiers_are_not_silently_ignored) ... ok +test_missing_half_and_duplicate_pending_offrank_rejected (test_tp2.TP2Tests.test_missing_half_and_duplicate_pending_offrank_rejected) ... ok +test_missing_nonintersecting_pair_fails_global_finalization (test_tp2.TP2Tests.test_missing_nonintersecting_pair_fails_global_finalization) ... ok +test_offrank_malformed_dtype_rejected_before_buffering (test_tp2.TP2Tests.test_offrank_malformed_dtype_rejected_before_buffering) ... ok +test_offrank_shapes_scales_and_partition_boundaries_fail_closed (test_tp2.TP2Tests.test_offrank_shapes_scales_and_partition_boundaries_fail_closed) ... ok +test_pending_offrank_has_no_payload_and_local_budget_fails_closed (test_tp2.TP2Tests.test_pending_offrank_has_no_payload_and_local_budget_fails_closed) ... ok +test_synthetic_metadata_both_ranks_without_payload_allocation (test_tp2.TP2Tests.test_synthetic_metadata_both_ranks_without_payload_allocation) ... ok +test_trailing_newline_shards_rejected_before_local_or_offrank_loading (test_tp2.TP2Tests.test_trailing_newline_shards_rejected_before_local_or_offrank_loading) ... ok +test_normal_and_prefetch_reduce_exactly_once_or_reject_scattered (test_tp2_collectives.CollectiveSeamTests.test_normal_and_prefetch_reduce_exactly_once_or_reject_scattered) ... ok +test_fc1_padding_preserves_weights_scales_and_slices_before_bias (test_vision_cpu.VisionTests.test_fc1_padding_preserves_weights_scales_and_slices_before_bias) ... ok +test_fc1_rejects_wrong_group_layout (test_vision_cpu.VisionTests.test_fc1_rejects_wrong_group_layout) ... ok +test_fc2_rejects_unproven_output_padding (test_vision_cpu.VisionTests.test_fc2_rejects_unproven_output_padding) ... ok +test_fc2_restores_logical_order_and_handles_no_bias (test_vision_cpu.VisionTests.test_fc2_restores_logical_order_and_handles_no_bias) ... ok + +---------------------------------------------------------------------- +Ran 81 tests in 5.578s + +OK diff --git a/provenance/pr5-merge-gate-green.json b/provenance/pr5-merge-gate-green.json new file mode 100644 index 0000000..ef2482f --- /dev/null +++ b/provenance/pr5-merge-gate-green.json @@ -0,0 +1,111 @@ +{ + "phase": "GREEN", + "reviewed_head": "ed43202a522bc2a09eb08ebdc89705afc355030e", + "red_commit": "df22281b6d35fc04f802a9384b22297c0857c8cd", + "image": "kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", + "focused": { + "command": "exact pinned image, read-only/no-network CPU runner: python3 /repo/tests/runtime_responses_compat.py -v", + "tests_run": 75, + "failures": 0, + "errors": 0, + "log": "pr5-merge-gate-green-focused.log", + "log_sha256": "466d33314fdf3097dcd7ac704de2ccc1024d18ca19877a42548063f5dbab57fb" + }, + "full_package": { + "command": "QWEN_TOKENIZER_PATH=/home/kanadaj/sglang-tuning/qwen-effort-alias-patch/tokenizer bash scripts/test_responses_compat.sh", + "suite_counts": { + "responses": 75, + "qwen_effort_alias": 14, + "package_cpu": 81 + }, + "suite_executions_total": 170, + "failures": 0, + "errors": 0, + "log": "pr5-merge-gate-green-full.log", + "log_sha256": "e2cb8985fedff808ff9ab4b3be07c1f47ef253307d622c9c52c275e170954909" + }, + "exact_image_reconstruction": { + "source_files": 4392, + "successful_full_tree_verifications": 2, + "log": "pr5-exact-image-reconstruction.log", + "log_sha256": "896d0b4ce6fdf0d9c561c6898fa4a00bdb13c608f0ffc3735f9ee398cb3efa86" + }, + "compile_diff_security": { + "compileall": "passed on reconstructed tree", + "focused_py_compile": "passed for sources and final fixture", + "git_diff_check": "passed", + "patch_apply_check": "passed against verified patch-0016 predecessor", + "added_line_security_findings": 0, + "generic_angle_split_present": false, + "qwen4_exp_in_patch0017": false, + "log": "pr5-compile-diff-security.log", + "log_sha256": "14159ffc0b334f3e3e13ea9997e4b6af4f648c92cfbaa459add6730ddf3f9965" + }, + "artifact_sha256": { + "tests/runtime_responses_compat.py": "a8bf6933dc433e7841b0715cea2ae43d7a9424c98327a33bdc1e05c04ad95d62", + "runtime/python/sglang/srt/entrypoints/openai/protocol.py": "0d4ab08ef507764b1a477d12ff63ca6a70c48151b1464881c29928a87e392165", + "runtime/python/sglang/srt/entrypoints/openai/serving_responses.py": "e65084c831bb3755bcef6a3288587582c065538857b58d09c8d2c2bc3ecf696c", + "patches/0017-responses-phase-order.patch": "2a4df18aaf0f1d15207ea2eed70f60bdb75a4bfcaa3c053a89ad33b859e27057", + "provenance/responses-phase-order-runtime-files.json": "1fc662bc6553af87a0b79f2857c910de02b8aaebb0f96fd6ac11674657dbb903" + }, + "final_tested_source_sha256": "e65084c831bb3755bcef6a3288587582c065538857b58d09c8d2c2bc3ecf696c", + "followup_red": { + "manifest": "pr5-followup-red.json", + "log": "pr5-followup-red.log", + "test_methods_run": 69, + "failing_subtests": 18 + }, + "followup2_red": { + "commit": "76f04a2d6a5b82a9ffd7cb1e101a022cff790545", + "manifest": "pr5-followup2-red.json", + "manifest_sha256": "c1186ce38b47a48faa7dfd0e1c0abd52e0bfd29e9687a8277f5bf65bd64e208e", + "log": "pr5-followup2-red.log", + "log_sha256": "a10bc67cb2203c425b5e260d20b7f6b96d018300360408babf3235fb745a6a74", + "test_methods_run": 2, + "failing_subtests": 3 + }, + "followup3_red": { + "commit": "1cdf3838b38089fbcf3884662a6b30d2de6c9627", + "manifest": "pr5-followup3-red.json", + "manifest_sha256": "0ff207cda0182a1f020c9975d504322b2e099c027332fda72469555da7bf081d", + "log": "pr5-followup3-red.log", + "log_sha256": "f17a5afcb1b675f2691bf9dbe2e18c465af78416d3ca4e53d0c583c6cb1a8dfa", + "test_methods_run": 1, + "failing_subtests": 4 + }, + "followup4_red": { + "commit": "7fe50de3595dad2a6425f54c23f59cb46e8db409", + "manifest": "pr5-followup4-red.json", + "manifest_sha256": "744bbe990580c7c5faf736b01c2e6704c345ca7508d17d80c176ca84cb299356", + "log": "pr5-followup4-red.log", + "log_sha256": "bdde78b1e45273d083fb14148bf180536816815c583d5a39ae31f17e96b073be", + "test_methods_run": 2, + "failing_subtests": 5 + }, + "followup5_red": { + "commit": "8b33799e4b21ef54c8a39250b692cd3a60b3c44b", + "manifest": "pr5-followup5-red.json", + "manifest_sha256": "e4e6541d1fe35cc74e1bf86ac4331b3d64db92b7997ed54412fa59e08377cbce", + "log": "pr5-followup5-red.log", + "log_sha256": "9e9774959574a801f33723dacb6a3328c42fce90afec54483a329c795c3f6504", + "test_methods_run": 1, + "failing_subtests": 4 + }, + "targeted_final": { + "command": "exact pinned image, read-only/no-network CPU runner: two named MockHTTPTest methods", + "tests_run": 2, + "failures": 0, + "errors": 0, + "log": "pr5-final-targeted-green.log", + "log_sha256": "1a423b7e0d69b3af65ccee9c99cbf3413ab37df5348a2318b788fdbbc8e13f8b" + }, + "followup6_red": { + "commit": "a42cf78b1e16642b0baaba276d5bde2a0bae8238", + "manifest": "pr5-followup6-red.json", + "manifest_sha256": "a6462211dba15a969afec8cefe33844b35de816300c0ea621c9ee043b67bd43b", + "log": "pr5-followup6-red.log", + "log_sha256": "9cd9dd70b7642de394f52d763d6397eb053d521423128937c5e4546af555b703", + "test_methods_run": 2, + "failing_subtests": 3 + } +} diff --git a/provenance/responses-phase-order-runtime-files.json b/provenance/responses-phase-order-runtime-files.json index 30937ea..1b52e1a 100644 --- a/provenance/responses-phase-order-runtime-files.json +++ b/provenance/responses-phase-order-runtime-files.json @@ -2488,7 +2488,7 @@ "python/sglang/srt/entrypoints/openai/serving_completions.py": "67f08075f21481b03e246327c7453f57ac001d0f3e78f5a9247caa553e1942e3", "python/sglang/srt/entrypoints/openai/serving_embedding.py": "cf1b283df88e1286b7f803f2173bf89499c65e25c93462bc299b2c64539d77b8", "python/sglang/srt/entrypoints/openai/serving_rerank.py": "5242cd42c8ccba74fbdf13e2c7eee63b5551e3d6bef09933aba213d690cb3329", - "python/sglang/srt/entrypoints/openai/serving_responses.py": "a0862c742ff1d8586808c4cbf077e8897d26b2497e0088af44f0f59868908748", + "python/sglang/srt/entrypoints/openai/serving_responses.py": "e65084c831bb3755bcef6a3288587582c065538857b58d09c8d2c2bc3ecf696c", "python/sglang/srt/entrypoints/openai/serving_score.py": "203748c564cd979d03d54dee44140c63caef59490d1ca508ccb1aca3f69ffccd", "python/sglang/srt/entrypoints/openai/serving_tokenize.py": "f1791dbe89245cf80f2ae3c3f052e944c0b602deaf45909a31d2e4aabfc95711", "python/sglang/srt/entrypoints/openai/serving_transcription.py": "0f15eac62ea22d5cd531f19e9419a5db61f6a3109a25f0e6d87e84d215c4128d", diff --git a/provenance/responses-phase-order.json b/provenance/responses-phase-order.json index 089375e..9d1067f 100644 --- a/provenance/responses-phase-order.json +++ b/provenance/responses-phase-order.json @@ -3,7 +3,7 @@ "base_main_commit": "de9abbe3d10c0510ac7eba898fcf721b6a73a41d", "predecessor_profile": "responses-compat", "patch": "0017-responses-phase-order.patch", - "patch_sha256": "194a4d818cbf1484565a7c52f31480476046d21d4fd6488c4afdb27c8fc5e7e2", + "patch_sha256": "2a4df18aaf0f1d15207ea2eed70f60bdb75a4bfcaa3c053a89ad33b859e27057", "files": { "python/sglang/srt/entrypoints/openai/protocol.py": { "before": "fbc60d3206612f408d93f786b18446ab96c258ff60bf1f1c4cf0e36e3c88eca1", @@ -11,17 +11,96 @@ }, "python/sglang/srt/entrypoints/openai/serving_responses.py": { "before": "d46f648b557db07a430869471fcf4d7a898d50f99e495efd5eb01911c428f215", - "after": "a0862c742ff1d8586808c4cbf077e8897d26b2497e0088af44f0f59868908748" + "after": "e65084c831bb3755bcef6a3288587582c065538857b58d09c8d2c2bc3ecf696c" } }, "source_files_before": 4392, "source_files_after": 4392, "inventory": "responses-phase-order-runtime-files.json", - "inventory_sha256": "c0fa153a33b23a25e7b97ec432c518afb7b49dc8391f971138afda14f30c9759", + "inventory_sha256": "1fc662bc6553af87a0b79f2857c910de02b8aaebb0f96fd6ac11674657dbb903", "scope": [ "Responses message phase serialization", - "Qwen reasoning, text, and tool replay ordering", - "Qwen streaming markup boundary ordering", - "Qwen nonstream ordered-item parity with streaming" - ] + "Qwen3.8 Flash-Next reasoning, text, and tool replay ordering", + "Recognized Qwen structural-marker boundary ordering", + "Typed Qwen nonstream ordered-item construction with usage and logprobs preservation", + "qwen4_exp negative control" + ], + "tdd_evidence": { + "reviewed_head": "ed43202a522bc2a09eb08ebdc89705afc355030e", + "red_commit": "df22281b6d35fc04f802a9384b22297c0857c8cd", + "red": { + "manifest": "pr5-merge-gate-red.json", + "manifest_sha256": "ec0a6619b786aec7b2564f800b99d9eea1e710b9a376ba36aa736cf90051293a", + "log": "pr5-merge-gate-red.log", + "log_sha256": "334ded3fd795f667a6399d96ba80adbee07f968564e9dc898dd9e691dddcf1ab", + "tests_run": 65, + "expected_failures": 4 + }, + "green": { + "manifest": "pr5-merge-gate-green.json", + "manifest_sha256": "5b57022d1f555a855ee77d6afaa4c24f5e7a7e338571bd3ba0cb603006cf098a", + "suite_counts": [ + 75, + 14, + 81 + ], + "failures": 0, + "targeted_tests": 2, + "suite_executions_total": 170 + }, + "followup_red": { + "commit": "6968c13f44b251feb86bd7d179d3b483ed434a49", + "manifest": "pr5-followup-red.json", + "manifest_sha256": "a0bc67f750e0cf9bff31a90fcaa0d3151f17933e08745603daa1ea0f99f5069f", + "log": "pr5-followup-red.log", + "log_sha256": "cdc9d5bf5ad163b9f2c869936258e1b97f418a838a36cde30f56c1cde7b75e17", + "test_methods_run": 69, + "failing_subtests": 18 + }, + "followup2_red": { + "commit": "76f04a2d6a5b82a9ffd7cb1e101a022cff790545", + "manifest": "pr5-followup2-red.json", + "manifest_sha256": "c1186ce38b47a48faa7dfd0e1c0abd52e0bfd29e9687a8277f5bf65bd64e208e", + "log": "pr5-followup2-red.log", + "log_sha256": "a10bc67cb2203c425b5e260d20b7f6b96d018300360408babf3235fb745a6a74", + "test_methods_run": 2, + "failing_subtests": 3 + }, + "followup3_red": { + "commit": "1cdf3838b38089fbcf3884662a6b30d2de6c9627", + "manifest": "pr5-followup3-red.json", + "manifest_sha256": "0ff207cda0182a1f020c9975d504322b2e099c027332fda72469555da7bf081d", + "log": "pr5-followup3-red.log", + "log_sha256": "f17a5afcb1b675f2691bf9dbe2e18c465af78416d3ca4e53d0c583c6cb1a8dfa", + "test_methods_run": 1, + "failing_subtests": 4 + }, + "followup4_red": { + "commit": "7fe50de3595dad2a6425f54c23f59cb46e8db409", + "manifest": "pr5-followup4-red.json", + "manifest_sha256": "744bbe990580c7c5faf736b01c2e6704c345ca7508d17d80c176ca84cb299356", + "log": "pr5-followup4-red.log", + "log_sha256": "bdde78b1e45273d083fb14148bf180536816815c583d5a39ae31f17e96b073be", + "test_methods_run": 2, + "failing_subtests": 5 + }, + "followup5_red": { + "commit": "8b33799e4b21ef54c8a39250b692cd3a60b3c44b", + "manifest": "pr5-followup5-red.json", + "manifest_sha256": "e4e6541d1fe35cc74e1bf86ac4331b3d64db92b7997ed54412fa59e08377cbce", + "log": "pr5-followup5-red.log", + "log_sha256": "9e9774959574a801f33723dacb6a3328c42fce90afec54483a329c795c3f6504", + "test_methods_run": 1, + "failing_subtests": 4 + }, + "followup6_red": { + "commit": "a42cf78b1e16642b0baaba276d5bde2a0bae8238", + "manifest": "pr5-followup6-red.json", + "manifest_sha256": "a6462211dba15a969afec8cefe33844b35de816300c0ea621c9ee043b67bd43b", + "log": "pr5-followup6-red.log", + "log_sha256": "9cd9dd70b7642de394f52d763d6397eb053d521423128937c5e4546af555b703", + "test_methods_run": 2, + "failing_subtests": 3 + } + } } diff --git a/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py b/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py index 49881f0..844e011 100644 --- a/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/runtime/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -143,6 +143,67 @@ def _should_emit_normal_text_as_message( return True +_QWEN_STRUCTURAL_MARKER_RE = re.compile( + r"(||||" + r"\r\n]+>||" + r"\r\n]+>|)" +) +_QWEN_FIXED_STRUCTURAL_MARKERS = ( + "", + "", + "", + "", + "", + "", +) +_QWEN_DYNAMIC_STRUCTURAL_PREFIXES = ("\r\n]", text[1:])) + for prefix in _QWEN_DYNAMIC_STRUCTURAL_PREFIXES + ) + + +class _QwenStructuralMarkerBuffer: + """Keep only possible split control markers between engine chunks.""" + + def __init__(self) -> None: + self.pending = "" + + def feed(self, text: str, *, final: bool) -> list[str]: + text = self.pending + text + self.pending = "" + parts: list[str] = [] + cursor = 0 + for match in _QWEN_STRUCTURAL_MARKER_RE.finditer(text): + if match.start() > cursor: + parts.append(text[cursor : match.start()]) + parts.append(match.group(0)) + cursor = match.end() + + remainder = text[cursor:] + if not final: + candidate_start = remainder.rfind("<") + if candidate_start >= 0 and _is_qwen_structural_marker_prefix( + remainder[candidate_start:] + ): + self.pending = remainder[candidate_start:] + remainder = remainder[:candidate_start] + if remainder: + parts.append(remainder) + return parts or ([""] if final else []) + + +def _split_qwen_structural_markers(text: str) -> list[str]: + """Split only Qwen parser control markers, not arbitrary angle brackets.""" + return _QwenStructuralMarkerBuffer().feed(text, final=True) + + class OpenAIServingResponses(OpenAIServingChat): """Handler for /v1/responses requests""" @@ -742,54 +803,54 @@ async def responses_full_generator( final_text = final_res["text"] model_type = self.tokenizer_manager.model_config.hf_config.model_type - leading_text, think_marker, _ = final_text.partition("") + leading_text, think_marker, trailing_text = final_text.partition("") + requires_tool_output = request.tool_choice == "required" or isinstance( + request.tool_choice, dict + ) + ordered_tool_boundary = ( + self.tool_call_parser == "qwen3_coder" + and request.tool_choice != "none" + and re.search( + r"\s*\s*\S", final_text, re.DOTALL + ) + ) + ordered_reasoning_boundary = ( + self.reasoning_parser in {"qwen3", "qwen3-thinking"} + and not ( + requires_tool_output and self.tool_call_parser != "qwen3_coder" + ) + and think_marker + and (leading_text.strip() or "" in trailing_text) + ) needs_ordered_qwen_parse = ( status == "completed" and model_type - in {"qwen3_8_flash_next", "qwen3_8_flash_next_text", "qwen4_exp"} - and ( - re.search( - r"\s*\s*\S", final_text, re.DOTALL - ) - or (think_marker and leading_text.strip()) - ) + in {"qwen3_8_flash_next", "qwen3_8_flash_next_text"} + and (ordered_tool_boundary or ordered_reasoning_boundary) ) - if needs_ordered_qwen_parse: - async def final_result(): - yield final_res - - terminal_response = None - async for frame in self.responses_stream_generator_non_harmony( - request, - sampling_params, - final_result(), - model_name, - tokenizer, - request_metadata, - created_time=created_time, - require_reasoning=require_reasoning, - ): - event = json.loads(frame.split("data: ", 1)[1]) - if event.get("type") == "response.completed": - terminal_response = event["response"] - if terminal_response is None: - raise ValueError("Ordered Qwen output did not complete") - terminal_response["tools"] = request.model_dump()["tools"] - return ResponsesResponse.model_validate(terminal_response) - output_logprobs = ( _build_output_text_logprobs(meta_info) if request.is_include_output_logprobs() and isinstance(meta_info, dict) else None ) - output = self._make_response_output_items( - request, - final_res["text"], - tokenizer, - output_logprobs=output_logprobs, - require_reasoning=require_reasoning, - status=status, - ) + if needs_ordered_qwen_parse: + output = self._make_qwen_ordered_output_items( + request, + tokenizer, + final_text, + output_logprobs=output_logprobs, + require_reasoning=require_reasoning, + status=status, + ) + else: + output = self._make_response_output_items( + request, + final_text, + tokenizer, + output_logprobs=output_logprobs, + require_reasoning=require_reasoning, + status=status, + ) if meta_info is not None: num_prompt_tokens = meta_info.get("prompt_tokens", 0) @@ -930,7 +991,13 @@ def _make_response_output_items( status: str = "completed", ): chat_tools = self._response_tools_to_chat_tools(request) - if self.reasoning_parser: + is_required = request.tool_choice == "required" or isinstance( + request.tool_choice, dict + ) + uses_required_json = ( + bool(chat_tools) and is_required and self.tool_call_parser is None + ) + if self.reasoning_parser and not uses_required_json: reasoning_parser = ReasoningParser( model_type=self.reasoning_parser, stream_reasoning=False, @@ -978,7 +1045,6 @@ def _make_response_output_items( ) output_items.append(reasoning_item) - is_required = request.tool_choice == "required" or isinstance(request.tool_choice, dict) if status != "completed" and chat_tools and is_required: return output_items tool_call_items: list[ResponseFunctionToolCall] = [] @@ -1055,6 +1121,253 @@ def _make_response_output_items( output_items.extend(tool_call_items) return output_items + def _make_qwen_ordered_output_items( + self, + request: ResponsesRequest, + tokenizer: Any, + final_output: str, + output_logprobs: Optional[list] = None, + *, + require_reasoning: bool, + status: str, + ) -> list: + """Parse completed Qwen structural markers into typed items in wire order.""" + chat_tools = self._response_tools_to_chat_tools(request) + tool_parser: Optional[FunctionCallParser] = None + if chat_tools and self.tool_call_parser and request.tool_choice != "none": + tool_parser = FunctionCallParser( + chat_tools, + self.tool_call_parser, + tokenizer=self.tokenizer_manager.tokenizer, + ) + assert tool_parser is not None + if hasattr(tool_parser.detector, "preserve_raw_input_tools"): + tool_parser.detector.preserve_raw_input_tools = ( + request._custom_tool_names + ) + + def new_reasoning_parser() -> ReasoningParser: + return ReasoningParser( + model_type=self.reasoning_parser, + stream_reasoning=True, + force_reasoning=( + self.template_manager.force_reasoning or require_reasoning + ), + request=request, + tokenizer=tokenizer, + tool_call_parser_active=tool_parser is not None, + ) + + reasoning_parser_obj: Optional[ReasoningParser] = ( + new_reasoning_parser() if self.reasoning_parser else None + ) + reasoning_block_closed = False + reasoning_block_started = False + inside_tool_call = False + + output_items: list = [] + message_text = "" + message_logprobs: list[Logprob] = [] + reasoning_text = "" + tool_states: dict[int, dict[str, str]] = {} + wants_summary = self._wants_reasoning_summary(request) + output_logprob_index = 0 + + def take_part_logprobs(part: str) -> list[Logprob]: + """Consume logprobs only when their tokens exactly cover this part.""" + nonlocal output_logprob_index + if output_logprobs is None or not part: + return [] + start = output_logprob_index + text = "" + entries: list[Logprob] = [] + while output_logprob_index < len(output_logprobs): + entry = output_logprobs[output_logprob_index] + candidate = text + entry.token + if not part.startswith(candidate): + output_logprob_index = start + return [] + text = candidate + entries.append(entry) + output_logprob_index += 1 + if text == part: + return entries + output_logprob_index = start + return [] + + def close_message(phase: Any) -> None: + nonlocal message_text, message_logprobs + if not message_text: + return + output_items.append( + ResponseOutputMessage( + id=f"msg_{random_uuid()}", + type="message", + role="assistant", + content=[ + ResponseOutputText( + type="output_text", + text=message_text, + annotations=[], + logprobs=( + message_logprobs + if output_logprobs is not None + else None + ), + ) + ], + status="completed", + phase=phase, + ) + ) + message_text = "" + message_logprobs = [] + + def close_reasoning() -> None: + nonlocal reasoning_text + if not reasoning_text: + return + output_items.append( + ResponseReasoningItem( + id=f"rs_{random_uuid()}", + type="reasoning", + summary=( + [ + ResponseReasoningSummary( + type="summary_text", text=reasoning_text + ) + ] + if wants_summary + else [] + ), + content=[ + ResponseReasoningTextContent( + type="reasoning_text", text=reasoning_text + ) + ], + status="completed", + ) + ) + reasoning_text = "" + + def close_tools(except_index: Optional[int] = None) -> None: + for tool_index in list(tool_states): + if tool_index == except_index: + continue + state = tool_states.pop(tool_index) + output_items.append( + ResponseFunctionToolCall( + arguments=state["arguments"], + call_id=state["call_id"], + name=state["name"], + type="function_call", + id=state["item_id"], + status="completed", + ) + ) + + def emit_calls(calls: list[ToolCallItem]) -> None: + if calls: + close_reasoning() + close_message("commentary") + for call in calls: + state = tool_states.get(call.tool_index) + if state is None: + close_tools() + state = { + "item_id": f"fc_{random_uuid()[:8]}", + "call_id": f"call_{random_uuid()[:24]}", + "name": call.name or "", + "arguments": "", + } + tool_states[call.tool_index] = state + elif call.name: + state["name"] = call.name + if call.parameters: + state["arguments"] += call.parameters + + def consume( + normal_text: str, + calls: list[ToolCallItem], + normal_logprobs: Optional[list[Logprob]] = None, + ) -> None: + nonlocal message_text, message_logprobs + continuing = [ + call for call in calls if call.tool_index in tool_states + ] + opening = [ + call for call in calls if call.tool_index not in tool_states + ] + emit_calls(continuing) + if normal_text and _should_emit_normal_text_as_message( + normal_text, + any_tool_call_in_progress=bool(tool_states), + ): + close_reasoning() + close_tools() + message_text += normal_text + message_logprobs.extend(normal_logprobs or []) + emit_calls(opening) + + for part in _split_qwen_structural_markers(final_output): + part_logprobs = take_part_logprobs(part) + entering_tool_call = tool_parser is not None and part == "" + if ( + part == "" + and not inside_tool_call + and reasoning_block_closed + and reasoning_parser_obj is not None + ): + close_reasoning() + reasoning_parser_obj = new_reasoning_parser() + reasoning_block_closed = False + reasoning_block_started = False + if part == "" and not inside_tool_call: + reasoning_block_started = True + if reasoning_parser_obj is not None and not inside_tool_call: + reasoning_chunk, normal = reasoning_parser_obj.parse_stream_chunk(part) + else: + reasoning_chunk, normal = None, part + if part == "" and not inside_tool_call: + reasoning_block_closed = True + reasoning_block_started = False + if reasoning_chunk: + close_message("commentary") + close_tools() + reasoning_text += reasoning_chunk + if entering_tool_call and (reasoning_block_started or reasoning_text): + reasoning_block_closed = True + reasoning_block_started = False + if entering_tool_call: + inside_tool_call = True + if tool_parser is not None: + normal_text, calls = tool_parser.parse_stream_chunk(normal) + consume(normal_text or "", list(calls), part_logprobs) + else: + consume(normal or "", [], part_logprobs) + if tool_parser is not None and part == "": + inside_tool_call = False + + if reasoning_parser_obj is not None: + end_reasoning, end_normal = reasoning_parser_obj.parse_stream_end() + if end_reasoning: + close_message("commentary") + reasoning_text += end_reasoning + else: + end_normal = "" + if tool_parser is not None: + normal_text, calls = tool_parser.parse_stream_chunk(end_normal or "") + end_text, end_calls = tool_parser.parse_stream_end() + consume((normal_text or "") + end_text, list(calls) + list(end_calls)) + else: + consume(end_normal or "", []) + + close_reasoning() + close_message("final_answer") + if status == "completed": + close_tools() + return output_items + def _make_response_output_items_with_harmony( self, context: HarmonyContext, @@ -1403,7 +1716,6 @@ def _construct_input_messages( is_qwen = self.tokenizer_manager.model_config.hf_config.model_type in { "qwen3_8_flash_next", "qwen3_8_flash_next_text", - "qwen4_exp", } messages = self._merge_consecutive_assistant_messages( messages, @@ -2158,9 +2470,8 @@ def _sanitize_response_dict(d: dict) -> dict: ) if hasattr(tool_parser.detector, "preserve_raw_input_tools"): tool_parser.detector.preserve_raw_input_tools = request._custom_tool_names - reasoning_parser_obj: Optional[ReasoningParser] = None - if self.reasoning_parser: - reasoning_parser_obj = ReasoningParser( + def new_reasoning_parser() -> ReasoningParser: + return ReasoningParser( model_type=self.reasoning_parser, stream_reasoning=True, # A template that prefills forces the parser open even @@ -2173,15 +2484,25 @@ def _sanitize_response_dict(d: dict) -> dict: tool_call_parser_active=isinstance(tool_parser, FunctionCallParser), ) + reasoning_parser_obj: Optional[ReasoningParser] = ( + new_reasoning_parser() + if self.reasoning_parser and not isinstance(tool_parser, JsonArrayParser) + else None + ) + reasoning_block_closed = False + reasoning_block_started = False + inside_tool_call = False + # These parsers return separate text and call collections. Feed Qwen # markup boundaries separately so their original order remains visible. split_qwen_markup = ( self.tokenizer_manager.model_config.hf_config.model_type - in {"qwen3_8_flash_next", "qwen3_8_flash_next_text", "qwen4_exp"} + in {"qwen3_8_flash_next", "qwen3_8_flash_next_text"} and self.reasoning_parser in {None, "qwen3", "qwen3-thinking"} and self.tool_call_parser in {None, "qwen3_coder"} and (reasoning_parser_obj is not None or tool_parser is not None) ) + marker_splitter = _QwenStructuralMarkerBuffer() if split_qwen_markup else None current_output_index = -1 reasoning_state = { @@ -2429,16 +2750,42 @@ def _close_tool_call_state(tool_index: int): flushed = flushed or flush parts = ( - [part for part in re.split(r"(?=<)|(?<=>)", delta) if part] - or [""] - if split_qwen_markup + marker_splitter.feed( + delta, + final=finish_reason is not None, + ) + if marker_splitter is not None else [delta] ) flush_chunk = flush for part_index, delta in enumerate(parts): # Flush parser state once, after the terminal piece. flush = flush_chunk and part_index == len(parts) - 1 - if reasoning_parser_obj is not None: + structural_part = delta + entering_tool_call = ( + marker_splitter is not None + and tool_parser is not None + and structural_part == "" + ) + if ( + marker_splitter is not None + and delta == "" + and not inside_tool_call + and reasoning_block_closed + and reasoning_parser_obj is not None + ): + for ev in _close_reasoning_item(): + yield ev + reasoning_parser_obj = new_reasoning_parser() + reasoning_block_closed = False + reasoning_block_started = False + if ( + marker_splitter is not None + and structural_part == "" + and not inside_tool_call + ): + reasoning_block_started = True + if reasoning_parser_obj is not None and not inside_tool_call: reasoning_chunk, delta = reasoning_parser_obj.parse_stream_chunk( delta ) @@ -2452,11 +2799,21 @@ def _close_tool_call_state(tool_index: int): delta = (delta or "") + end_normal else: reasoning_chunk = None + if ( + marker_splitter is not None + and structural_part == "" + and not inside_tool_call + ): + reasoning_block_closed = True + reasoning_block_started = False if reasoning_chunk: if message_state["open"]: for ev in _close_message_item(phase="commentary"): yield ev + for tool_index in list(tool_call_states): + for ev in _close_tool_call_state(tool_index): + yield ev if not reasoning_state["open"]: item_id = _open_reasoning_item() yield _send_event( @@ -2512,6 +2869,14 @@ def _close_tool_call_state(tool_index: int): sequence_number=-1, ) ) + if entering_tool_call and ( + reasoning_block_started or reasoning_state["open"] + ): + reasoning_block_closed = True + reasoning_block_started = False + + if entering_tool_call: + inside_tool_call = True if not delta and not flush: continue @@ -2520,10 +2885,26 @@ def _close_tool_call_state(tool_index: int): required_buffer += delta normal_text, tool_calls = "", [] if flush and required_buffer.strip(): + try: + validated_calls = list( + validated_json_calls( + required_buffer, + {tool.function.name for tool in chat_tools}, + ) + ) + except ValueError: + # Public Responses validation below emits the + # established streaming error for malformed or + # unknown required output. + validated_calls = [] tool_calls = [ - ToolCallItem(tool_index=index, name=name, parameters=arguments) + ToolCallItem( + tool_index=index, + name=name, + parameters=arguments, + ) for index, (name, arguments) in enumerate( - validated_json_calls(required_buffer, {tool.function.name for tool in chat_tools}) + validated_calls ) ] elif tool_parser is not None: @@ -2681,6 +3062,12 @@ def _is_continuing(call): yield ev for ev in _emit_tool_calls(opening): yield ev + if ( + marker_splitter is not None + and tool_parser is not None + and structural_part == "" + ): + inside_tool_call = False except Exception: logger.exception("Error while streaming /v1/responses") failed = _sanitize_response_dict( diff --git a/tests/runtime_responses_compat.py b/tests/runtime_responses_compat.py index 36f1ac9..de50814 100644 --- a/tests/runtime_responses_compat.py +++ b/tests/runtime_responses_compat.py @@ -339,17 +339,25 @@ def test_qwen_ordered_nonstream_preserves_requested_logprobs(self): async def generate(request, *args, **kwargs): yield { 'text': raw, - 'output_ids': [1, 2], + 'output_ids': [1, 2, 3, 4, 5, 6], 'meta_info': { 'prompt_tokens': 10, - 'completion_tokens': 2, + 'completion_tokens': 6, 'output_token_logprobs': [ (-0.25, 1, 'Checking.'), - (-0.5, 2, 'Final answer.'), + (-0.1, 2, ''), + (-0.1, 3, ''), + (-0.1, 4, ''), + (-0.1, 5, ''), + (-0.5, 6, 'Final answer.'), ], 'output_top_logprobs': [ - [(-0.25, 1, 'Checking.'), (-1.0, 3, 'Inspecting.')], - [(-0.5, 2, 'Final answer.')], + [(-0.25, 1, 'Checking.'), (-1.0, 7, 'Inspecting.')], + [(-0.1, 2, '')], + [(-0.1, 3, '')], + [(-0.1, 4, '')], + [(-0.1, 5, '')], + [(-0.5, 6, 'Final answer.')], ], 'finish_reason': {'type': 'stop'}, }, From 179cbb49acaf57af32268506d31c71e04eea95c8 Mon Sep 17 00:00:00 2001 From: ktsaou <2662304+ktsaou@users.noreply.github.com> Date: Mon, 14 Sep 2026 09:24:41 +0000 Subject: [PATCH 13/20] fix(qwen): enable release multimodal processor paths --- Dockerfile.qwen-multimodal-alias | 15 + README.md | 6 +- docs/qwen-multimodal-alias.md | 52 + ...018-qwen-flash-next-multimodal-alias.patch | 34 + patches/series.qwen-multimodal-alias | 3 + provenance/qwen-multimodal-alias.json | 22 + .../srt/multimodal/processors/qwen_vl.py | 916 ++++++++++++++++++ scripts/test_qwen_multimodal_alias.sh | 19 + scripts/verify_qwen_multimodal_alias.py | 82 ++ tests/runtime_qwen_multimodal_alias.py | 147 +++ tests/test_qwen_multimodal_packaging.py | 50 + 11 files changed, 1344 insertions(+), 2 deletions(-) create mode 100644 Dockerfile.qwen-multimodal-alias create mode 100644 docs/qwen-multimodal-alias.md create mode 100644 patches/0018-qwen-flash-next-multimodal-alias.patch create mode 100644 patches/series.qwen-multimodal-alias create mode 100644 provenance/qwen-multimodal-alias.json create mode 100644 runtime/python/sglang/srt/multimodal/processors/qwen_vl.py create mode 100755 scripts/test_qwen_multimodal_alias.sh create mode 100755 scripts/verify_qwen_multimodal_alias.py create mode 100644 tests/runtime_qwen_multimodal_alias.py create mode 100644 tests/test_qwen_multimodal_packaging.py diff --git a/Dockerfile.qwen-multimodal-alias b/Dockerfile.qwen-multimodal-alias new file mode 100644 index 0000000..bb30f8f --- /dev/null +++ b/Dockerfile.qwen-multimodal-alias @@ -0,0 +1,15 @@ +# Qwen Flash-Next API and multimodal compatibility overlay. +# All model paths, serving arguments, and runtime settings remain external. +FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 +ARG SOURCE_REVISION +LABEL org.opencontainers.image.source="https://github.com/kanadaj/sglang" \ + org.opencontainers.image.revision="${SOURCE_REVISION}" +COPY runtime/python/sglang/srt/entrypoints/openai/serving_chat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py +COPY runtime/python/sglang/srt/entrypoints/openai/protocol.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py +COPY runtime/python/sglang/srt/entrypoints/openai/serving_responses.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py +COPY runtime/python/sglang/srt/entrypoints/openai/responses_compat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py +COPY runtime/python/sglang/srt/function_call/qwen3_coder_detector.py /sgl-workspace/sglang/python/sglang/srt/function_call/qwen3_coder_detector.py +COPY runtime/python/sglang/srt/multimodal/processors/qwen_vl.py /sgl-workspace/sglang/python/sglang/srt/multimodal/processors/qwen_vl.py +RUN python3 -B -c 'import pathlib; p=pathlib.Path("/sgl-workspace/sglang/python/sglang/srt"); files=[p/"entrypoints/openai"/n for n in ("serving_chat.py", "protocol.py", "serving_responses.py", "responses_compat.py")]+[p/"function_call/qwen3_coder_detector.py", p/"multimodal/processors/qwen_vl.py"]; [compile(f.read_bytes(), str(f), "exec") for f in files]' +ENTRYPOINT ["python3", "-m", "sglang.launch_server"] +CMD ["--help"] diff --git a/README.md b/README.md index 7e6b0cd..e33e21f 100644 --- a/README.md +++ b/README.md @@ -5,8 +5,10 @@ adds separately attested boundary and streaming/nonstream ordering patches after effort-alias profile, including its `minimal` → `low` alias. The ordered nonstream path constructs typed output directly and retains usage details and requested logprobs; structural splitting is limited to recognized Qwen markers and the loaded -`qwen3_8_flash_next` / `_text` model types. Historical production -profiles below are unchanged; no deployment is implied. +`qwen3_8_flash_next` / `_text` model types. The cumulative +[Qwen Flash-Next multimodal alias profile](docs/qwen-multimodal-alias.md) additionally +restores four existing Qwen VL processor paths under the release model type. +Historical production profiles below are unchanged; no deployment is implied. Publishable source and deployment package for the locally accepted Qwen3.8 Flash-Next LIL NVFP4 stack. **No model weights, container archives, credentials, diff --git a/docs/qwen-multimodal-alias.md b/docs/qwen-multimodal-alias.md new file mode 100644 index 0000000..cbea3a2 --- /dev/null +++ b/docs/qwen-multimodal-alias.md @@ -0,0 +1,52 @@ +# Qwen Flash-Next multimodal aliases — CPU candidate only + +The release checkpoint reports `hf_config.model_type=qwen3_8_flash_next`, while +the shared Qwen VL processor's equivalent behavior is registered under the +development name `qwen4_exp`. The missing release alias disables four existing +paths: concurrent preprocessing policy, preprocessed video metadata, timestamp +token construction, and the image-only mRoPE fast path. + +This profile adds the release model type to those four existing allowlists. It +does not add a new processor, change sampling, reorder media, modify model +weights, or affect text-only `qwen3_8_flash_next_text` checkpoints. Other model +types keep their existing behavior. + +## Composition + +Patch `0018-qwen-flash-next-multimodal-alias.patch` applies after the existing +Responses compatibility profile. `Dockerfile.qwen-multimodal-alias` includes +the five existing API overlay files and the resulting Qwen VL processor file. +All serving arguments and model paths remain external. + +## CPU validation + +Use a local directory containing the release checkpoint's `config.json`. The +runner resolves and mounts that file directly, so Hugging Face snapshot symlinks +remain valid: + +```bash +QWEN_MODEL_PATH=/absolute/release/config-directory \ + bash scripts/test_qwen_multimodal_alias.sh +python3 scripts/verify_qwen_multimodal_alias.py +``` + +The runtime test compares `qwen3_8_flash_next` with the already-registered +`qwen4_exp` behavior. It covers worker policy, video metadata and frame-sampling +flags, timestamp token positions and embedding slices, and image-only mRoPE +positions. The runner uses a read-only, network-disabled, GPU-disabled container. + +For a complete source reconstruction, export `python/sglang` from the exact base +image into `TREE`, then run: + +```bash +python3 scripts/verify_qwen_multimodal_alias.py --tree TREE --from-image +python3 scripts/verify_qwen_multimodal_alias.py --tree TREE +``` + +## Limits + +CPU equality with the registered processor path does not establish semantic +video accuracy. Historical live testing accepted image inputs but still +misordered events in short four-frame chronology cases. That video-ordering +issue remains open; this patch only restores the processor behavior already +used by the equivalent development model type. diff --git a/patches/0018-qwen-flash-next-multimodal-alias.patch b/patches/0018-qwen-flash-next-multimodal-alias.patch new file mode 100644 index 0000000..43820c0 --- /dev/null +++ b/patches/0018-qwen-flash-next-multimodal-alias.patch @@ -0,0 +1,34 @@ +--- a/python/sglang/srt/multimodal/processors/qwen_vl.py ++++ b/python/sglang/srt/multimodal/processors/qwen_vl.py +@@ -314,6 +314,7 @@ + "qwen3_5", + "qwen3_5_moe", + "qwen4_exp", ++ "qwen3_8_flash_next", + "intern_s2_preview", + "interns2_mobius", + ): +@@ -525,6 +526,7 @@ + "qwen3_5", + "qwen3_5_moe", + "qwen4_exp", ++ "qwen3_8_flash_next", + "intern_s2_preview", + "interns2_mobius", + ): +@@ -662,6 +664,7 @@ + "qwen3_5", + "qwen3_5_moe", + "qwen4_exp", ++ "qwen3_8_flash_next", + "intern_s2_preview", + ] + and video_timestamps is not None +@@ -771,6 +774,7 @@ + "qwen3_5", + "qwen3_5_moe", + "qwen4_exp", ++ "qwen3_8_flash_next", + "intern_s2_preview", + "interns2_mobius", + ): diff --git a/patches/series.qwen-multimodal-alias b/patches/series.qwen-multimodal-alias new file mode 100644 index 0000000..2243142 --- /dev/null +++ b/patches/series.qwen-multimodal-alias @@ -0,0 +1,3 @@ +0015-qwen-flash-next-effort-alias.patch +0016-responses-namespace-custom-boundary.patch +0018-qwen-flash-next-multimodal-alias.patch diff --git a/provenance/qwen-multimodal-alias.json b/provenance/qwen-multimodal-alias.json new file mode 100644 index 0000000..9692978 --- /dev/null +++ b/provenance/qwen-multimodal-alias.json @@ -0,0 +1,22 @@ +{ + "status": "CPU-tested candidate only; not built, published, or deployed", + "base_git_commit": "93463c3466b0de9d21776fbeff95657285df8269", + "base_profile": "responses-compat-candidate", + "base_image": "kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", + "base_inventory_sha256": "e574ce136e79576c3970da7f479b729b21d18ef8e4fe3e49ae3a5fd521866138", + "patch": "0018-qwen-flash-next-multimodal-alias.patch", + "patch_sha256": "d04808b386903db5def8d309df4d0570cc007b93a45befb41b688f2178898daa", + "files": { + "python/sglang/srt/multimodal/processors/qwen_vl.py": { + "before": "7b4dc28f8aef74f8a8a26516d639b0abf4ae91ce5c5f1c863edf996868283035", + "after": "b47003e1f0840a057519adff46fc72a9318a61e2eb3ef8cedfa9eab19e98b7f7" + } + }, + "source_files": 4392, + "result_inventory_sha256": "3735872b9eb7f4eb2aef99d9a56abc58ac52291cbec7e99ac3c889b6008eee13", + "historical_live_evidence": { + "image_cases_passed": 16, + "video_limitation": "Short four-frame video chronology remained wrong in observed cases.", + "scope": "Earlier API12 runtime evidence; not a fresh deployment or semantic video qualification." + } +} diff --git a/runtime/python/sglang/srt/multimodal/processors/qwen_vl.py b/runtime/python/sglang/srt/multimodal/processors/qwen_vl.py new file mode 100644 index 0000000..f3e1f68 --- /dev/null +++ b/runtime/python/sglang/srt/multimodal/processors/qwen_vl.py @@ -0,0 +1,916 @@ +import math +import os +import re +import time +from typing import List, Optional, Union + +import numpy as np +import torch +import torchvision +from PIL import Image +from torchvision.transforms import InterpolationMode + +from sglang.srt.environ import envs +from sglang.srt.layers.rotary_embedding import MRotaryEmbedding +from sglang.srt.managers.schedule_batch import ( + Modality, + MultimodalDataItem, + MultimodalProcessorOutput, +) +from sglang.srt.models.interns2_mobius import ( + InternS2MobiusForConditionalGeneration, +) +from sglang.srt.models.interns2preview import InternS2PreviewForConditionalGeneration +from sglang.srt.models.qwen2_5_vl import Qwen2_5_VLForConditionalGeneration +from sglang.srt.models.qwen2_vl import Qwen2VLForConditionalGeneration +from sglang.srt.models.qwen3_5 import ( + Qwen3_5ForConditionalGeneration, + Qwen3_5MoeForConditionalGeneration, +) +from sglang.srt.models.qwen3_5_mtp import Qwen3_5ForCausalLMMTP +from sglang.srt.models.qwen3_omni_moe import Qwen3OmniMoeForConditionalGeneration +from sglang.srt.models.qwen4_exp import Qwen4ExpForConditionalGeneration +from sglang.srt.models.qwen3_vl import Qwen3VLForConditionalGeneration +from sglang.srt.models.qwen3_vl_moe import Qwen3VLMoeForConditionalGeneration +from sglang.srt.multimodal.processors.base_processor import ( + BaseMultimodalProcessor as SGLangBaseProcessor, +) +from sglang.srt.multimodal.processors.base_processor import ( + MultimodalSpecialTokens, +) +from sglang.srt.multimodal.transport.cuda_ipc import ( + DEFER_CUDA_IPC_FEATURE_RECONSTRUCTION_KEY, +) +from sglang.srt.utils import cpu_has_amx_support, is_cpu +from sglang.srt.utils.video_decoder import VideoDecoderWrapper +from sglang.utils import logger + +IMAGE_FACTOR = 28 +MIN_PIXELS = 4 * 28 * 28 +MAX_PIXELS = envs.SGLANG_IMAGE_MAX_PIXELS.get() +MAX_RATIO = 200 +RESIZE_RESAMPLE = getattr(Image, envs.SGLANG_RESIZE_RESAMPLE.get(), None) +if envs.SGLANG_RESIZE_RESAMPLE.is_set() and RESIZE_RESAMPLE is None: + logger.warning( + f"Invalid RESIZE_RESAMPLE value: '{envs.SGLANG_RESIZE_RESAMPLE.get()}'. " + f"Ignoring and using default." + ) +VIDEO_TOTAL_PIXELS = int( + float(os.environ.get("VIDEO_MAX_PIXELS", 128000 * 28 * 28 * 0.9)) +) + +VIDEO_MIN_PIXELS = 128 * 28 * 28 +VIDEO_MAX_PIXELS = 768 * 28 * 28 +FRAME_FACTOR = 2 +FPS = 2.0 +FPS_MIN_FRAMES = 4 +FPS_MAX_FRAMES = 768 + +QWEN_VIDEO_PREPROCESS_CONFIG_KEYS = frozenset( + { + "fps", + "nframes", + "min_frames", + "max_frames", + "min_pixels", + "max_pixels", + "total_pixels", + "resized_height", + "resized_width", + } +) + + +def _get_processor_video_config(video_config, video_metadata): + if video_metadata and all(metadata is not None for metadata in video_metadata): + return { + key: value + for key, value in video_config.items() + if key not in QWEN_VIDEO_PREPROCESS_CONFIG_KEYS + } + return None + + +_is_cpu_amx_available = cpu_has_amx_support() +_is_cpu = is_cpu() +if _is_cpu and _is_cpu_amx_available: + try: + import transformers + + from sglang.srt.layers.amx_utils import fast_preprocess_cpu + + transformers.models.qwen2_vl.image_processing_qwen2_vl_fast.Qwen2VLImageProcessorFast._preprocess = ( + fast_preprocess_cpu + ) + except Exception as e: + logger.warning( + f"Failed to hack Qwen2VLImageProcessorFast with AMX optimization: {e}" + ) + + +def smart_resize( + height: int, + width: int, + factor: int = IMAGE_FACTOR, + min_pixels: int = MIN_PIXELS, + max_pixels: int = MAX_PIXELS, +) -> tuple[int, int]: + """ + Rescales the image so that the following conditions are met: + + 1. Both dimensions (height and width) are divisible by 'factor'. + + 2. The total number of pixels is within the range ['min_pixels', 'max_pixels']. + + 3. The aspect ratio of the image is maintained as closely as possible. + """ + if max(height, width) / min(height, width) > MAX_RATIO: + raise ValueError( + f"absolute aspect ratio must be smaller than {MAX_RATIO}, got {max(height, width) / min(height, width)}" + ) + h_bar = max(factor, round_by_factor(height, factor)) + w_bar = max(factor, round_by_factor(width, factor)) + if h_bar * w_bar > max_pixels: + beta = math.sqrt((height * width) / max_pixels) + h_bar = floor_by_factor(height / beta, factor) + w_bar = floor_by_factor(width / beta, factor) + elif h_bar * w_bar < min_pixels: + beta = math.sqrt(min_pixels / (height * width)) + h_bar = ceil_by_factor(height * beta, factor) + w_bar = ceil_by_factor(width * beta, factor) + return h_bar, w_bar + + +def round_by_factor(number: int, factor: int) -> int: + """Returns the closest integer to 'number' that is divisible by 'factor'.""" + return round(number / factor) * factor + + +def ceil_by_factor(number: int, factor: int) -> int: + """Returns the smallest integer greater than or equal to 'number' that is divisible by 'factor'.""" + return math.ceil(number / factor) * factor + + +def floor_by_factor(number: int, factor: int) -> int: + """Returns the largest integer less than or equal to 'number' that is divisible by 'factor'.""" + return math.floor(number / factor) * factor + + +def smart_nframes( + ele: dict, + total_frames: int, + video_fps: int | float, +) -> int: + """calculate the number of frames for video used for model inputs. + + Args: + ele (dict): a dict contains the configuration of video. + support either `fps` or `nframes`: + - nframes: the number of frames to extract for model inputs. + - fps: the fps to extract frames for model inputs. + - min_frames: the minimum number of frames of the video, only used when fps is provided. + - max_frames: the maximum number of frames of the video, only used when fps is provided. + total_frames (int): the original total number of frames of the video. + video_fps (int | float): the original fps of the video. + + Raises: + ValueError: nframes should in interval [FRAME_FACTOR, total_frames]. + + Returns: + int: the number of frames for video used for model inputs. + """ + assert not ( + "fps" in ele and "nframes" in ele + ), "Only accept either `fps` or `nframes`" + if "nframes" in ele: + nframes = round_by_factor(ele["nframes"], FRAME_FACTOR) + else: + fps = ele.get("fps", FPS) + min_frames = ceil_by_factor(ele.get("min_frames", FPS_MIN_FRAMES), FRAME_FACTOR) + max_frames = floor_by_factor( + ele.get("max_frames", min(FPS_MAX_FRAMES, total_frames)), FRAME_FACTOR + ) + nframes = total_frames / video_fps * fps + if nframes > total_frames: + logger.warning( + f"smart_nframes: nframes[{nframes}] > total_frames[{total_frames}]" + ) + nframes = min(min(max(nframes, min_frames), max_frames), total_frames) + nframes = floor_by_factor(nframes, FRAME_FACTOR) + if not (FRAME_FACTOR <= nframes and nframes <= total_frames): + raise ValueError( + f"nframes should in interval [{FRAME_FACTOR}, {total_frames}], but got {nframes}." + ) + return nframes + + +# process video, qwen-specific +async def preprocess_video( + vr, + image_factor: int = IMAGE_FACTOR, + video_config: dict = {}, +) -> torch.Tensor: + # preprocessed video + is_video_obj = isinstance(vr, VideoDecoderWrapper) + if not is_video_obj: + return vr, None + entry_time = time.perf_counter() + + total_frames, video_fps = len(vr), vr.avg_fps + + nframes = smart_nframes( + video_config, total_frames=total_frames, video_fps=video_fps + ) + idx = np.linspace(0, total_frames - 1, num=nframes, dtype=np.int64) + idx = np.unique(idx) + + video = vr.get_frames_as_tensor(idx.tolist()) + + video = video.permute(0, 3, 1, 2) # NHWC -> TCHW + + nframes, _, height, width = video.shape + min_pixels = video_config.get("min_pixels", VIDEO_MIN_PIXELS) + total_pixels = video_config.get("total_pixels", VIDEO_TOTAL_PIXELS) + max_pixels = max( + min( + video_config.get("max_pixels", VIDEO_MAX_PIXELS), + total_pixels / nframes * FRAME_FACTOR, + ), + int(min_pixels * 1.05), + ) + + get_batch_time = time.perf_counter() + + max_pixels_supposed = video_config.get("max_pixels", max_pixels) + + if max_pixels_supposed > max_pixels: + logger.warning( + f"The given max_pixels[{max_pixels_supposed}] exceeds limit[{max_pixels}]." + ) + max_pixels = min(max_pixels_supposed, max_pixels) + if "resized_height" in video_config and "resized_width" in video_config: + resized_height, resized_width = smart_resize( + video_config["resized_height"], + video_config["resized_width"], + factor=image_factor, + ) + else: + resized_height, resized_width = smart_resize( + height, + width, + factor=image_factor, + min_pixels=min_pixels, + max_pixels=max_pixels, + ) + smart_resize_time = time.perf_counter() + video = torchvision.transforms.functional.resize( + video, + [resized_height, resized_width], + interpolation=InterpolationMode.BILINEAR, + ) + video = video.pin_memory() + video_metadata = { + "fps": video_fps, + "duration": total_frames / video_fps, + "total_num_frames": total_frames, + "frames_indices": idx, + "video_backend": "torchvision", + } + torchvision_resize_time = time.perf_counter() + logger.debug( + f"[preprocess_video Perf], " + f"get_batch_time: {(get_batch_time - entry_time) * 1000:.2f} ms, " + f"smart_resize_time: {(smart_resize_time - get_batch_time) * 1000:.2f} ms, " + f"torchvision_resize_time: {(torchvision_resize_time - smart_resize_time) * 1000:.2f} ms, " + f"total_time: {(torchvision_resize_time - entry_time) * 1000:.2f} ms" + ) + return video, video_metadata + + +# Compatible with Qwen-VL & Qwen-Omni Series +class QwenVLImageProcessor(SGLangBaseProcessor): + supports_transformers_backend = True + models = [ + Qwen2VLForConditionalGeneration, + Qwen2_5_VLForConditionalGeneration, + Qwen3VLForConditionalGeneration, + Qwen3VLMoeForConditionalGeneration, + Qwen3_5ForConditionalGeneration, + Qwen3_5MoeForConditionalGeneration, + Qwen3_5ForCausalLMMTP, + InternS2PreviewForConditionalGeneration, + InternS2MobiusForConditionalGeneration, + Qwen3OmniMoeForConditionalGeneration, + Qwen4ExpForConditionalGeneration, + ] + + def __init__(self, hf_config, server_args, _processor, *args, **kwargs): + self.model_type = hf_config.model_type + if self.model_type in ( + "qwen2_vl", + "qwen2_5_vl", + "qwen3_vl", + "qwen3_vl_moe", + "qwen3_5", + "qwen3_5_moe", + "qwen4_exp", + "qwen3_8_flash_next", + "intern_s2_preview", + "interns2_mobius", + ): + # Two workers overlap CPU preprocessing without over-fragmenting + # burst arrivals into smaller GPU prefill batches. Higher counts can + # improve short-output TTFT, but regress long-output throughput on + # Blackwell when requests reach the scheduler too far apart. + self.auto_mm_processor_worker_num = 2 + self.auto_mm_io_worker_num = 16 + self.supports_mm_processor_concurrency = True + if hf_config.model_type == "qwen3_omni_moe": + hf_config = hf_config.thinker_config + + super().__init__(hf_config, server_args, _processor, *args, **kwargs) + + self.IM_START_TOKEN_ID = hf_config.vision_start_token_id + self.IM_END_TOKEN_ID = hf_config.vision_end_token_id + self.IM_TOKEN_ID = hf_config.image_token_id + self.VIDEO_TOKEN_ID = hf_config.video_token_id + + self.vision_start_token_id = hf_config.vision_start_token_id + self.vision_end_token_id = getattr(hf_config, "vision_end_token_id", None) + + self.audio_start_token_id = getattr(hf_config, "audio_start_token_id", None) + self.audio_token_id = getattr(hf_config, "audio_token_id", None) + + self._spatial_merge_size = self.hf_config.vision_config.spatial_merge_size + self._tokens_per_second = getattr( + self.hf_config.vision_config, "tokens_per_second", None + ) + + self.mm_tokens = MultimodalSpecialTokens( + image_token="<|vision_start|><|image_pad|><|vision_end|>", + image_token_id=hf_config.image_token_id, + # The regex that matches expanded image tokens. + image_token_regex=re.compile( + r"<\|vision_start\|>(?:<\|image_pad\|>)+<\|vision_end\|>" + ), + video_token_id=self.VIDEO_TOKEN_ID, + audio_token_id=self.audio_token_id, + ).build(_processor) + + @property + def spatial_merge_size(self): + return self._spatial_merge_size + + def build_input_ids_with_timestamps( + self, prompt, embeddings, img_grid_thw, video_grid_thw, video_timestamps + ): + """ + Build input_ids with timestamps for qwen3_vl models. + """ + if not isinstance(prompt, list): + prompt = self._processor.tokenizer.encode(prompt) + + img_token_id = getattr(self, "IM_TOKEN_ID", None) + video_token_id = getattr(self, "VIDEO_TOKEN_ID", None) + spatial_merge_size = self.spatial_merge_size + vision_start_token_id = getattr(self, "vision_start_token_id", None) + vision_end_token_id = getattr(self, "vision_end_token_id", None) + + input_ids = [] + offsets = [] + modality_list = [] + cur_idx = 0 + + vision_start_indices = [] + for i in range(len(prompt) - 1): + if img_token_id is not None and prompt[i + 1] == img_token_id: + vision_start_indices.append((i, Modality.IMAGE)) + elif video_token_id is not None and prompt[i + 1] == video_token_id: + vision_start_indices.append((i, Modality.VIDEO)) + + img_idx = 0 + video_idx = 0 + for mm_start_idx, modality in vision_start_indices: + modality_list.append(modality) + video_tokens = None + if modality == Modality.IMAGE: + mm_token_num = img_grid_thw[img_idx].prod() // (spatial_merge_size**2) + mm_token_id = img_token_id + img_idx += 1 + elif modality == Modality.VIDEO: + curr_timestamps = video_timestamps[video_idx] + num_frames = video_grid_thw[video_idx][0] + frame_seqlen = video_grid_thw[video_idx][1:].prod().item() // ( + spatial_merge_size**2 + ) + video_tokens = [] + _current_offset = len(input_ids) + mm_start_idx + 1 - cur_idx + # take single frame as one mm_item + for frame_idx in range(num_frames): + if frame_idx > 0: + modality_list.append(Modality.VIDEO) + curr_time = curr_timestamps[frame_idx] + timestamp_text = f"<{curr_time:.1f} seconds>" + timestamp_tokens = self._processor.tokenizer.encode( + timestamp_text, add_special_tokens=False + ) + video_tokens.extend(timestamp_tokens) + _current_offset += len(timestamp_tokens) + if vision_start_token_id is not None: + video_tokens.append(vision_start_token_id) + _current_offset += 1 + video_tokens.extend([video_token_id] * frame_seqlen) + if vision_end_token_id is not None: + video_tokens.append(vision_end_token_id) + offsets.append( + (_current_offset, _current_offset + frame_seqlen - 1) + ) + _current_offset += ( + frame_seqlen + 1 + if vision_end_token_id is not None + else frame_seqlen + ) # for vision_end_token_id + mm_token_num = len(video_tokens) + mm_token_id = None + video_idx += 1 + else: + logger.warning( + f"{modality} modality is not supported for qwen3_vl models with timestamps." + ) + continue + assert cur_idx <= mm_start_idx + input_ids.extend(prompt[cur_idx : mm_start_idx + 1]) + if modality == Modality.VIDEO: + input_ids.extend(video_tokens) + else: + mm_offset_start = len(input_ids) + input_ids.extend([mm_token_id] * mm_token_num) + offsets.append((mm_offset_start, len(input_ids) - 1)) + cur_idx = mm_start_idx + 2 # jump to vision_end_id + else: + input_ids.extend(prompt[cur_idx:]) + + return input_ids, offsets, modality_list + + def compute_mrope_positions(self, input_ids, mm_items): + image_grid_thw = self._concat_mm_item_grid( + mm_items, "image_grid_thw", Modality.IMAGE + ) + video_grid_thw = self._concat_mm_item_grid( + mm_items, "video_grid_thw", Modality.VIDEO + ) + + input_ids_tensor = torch.tensor(input_ids, dtype=torch.long).unsqueeze(0) + mrope_positions, mrope_position_delta = MRotaryEmbedding.get_rope_index( + spatial_merge_size=self._spatial_merge_size, + image_token_id=self.mm_tokens.image_token_id, + video_token_id=self.mm_tokens.video_token_id, + vision_start_token_id=self.vision_start_token_id, + model_type=self.model_type, + tokens_per_second=self._tokens_per_second, + input_ids=input_ids_tensor, + image_grid_thw=image_grid_thw, + video_grid_thw=video_grid_thw, + ) + return mrope_positions.squeeze(1), mrope_position_delta + + @staticmethod + def _get_processor_output_value(ret, key): + if ret is None: + return None + return ret.get(key) if hasattr(ret, "get") else getattr(ret, key, None) + + def _get_precomputed_mrope_from_output(self, ret): + mrope_positions = self._get_processor_output_value(ret, "mrope_positions") + mrope_position_delta = self._get_processor_output_value( + ret, "mrope_position_delta" + ) + if mrope_positions is None or mrope_position_delta is None: + return None + + mrope_positions = torch.as_tensor(mrope_positions) + if mrope_positions.ndim == 3: + if mrope_positions.shape[1] != 1: + return None + mrope_positions = mrope_positions.squeeze(1) + if mrope_positions.ndim != 2 or mrope_positions.shape[0] != 3: + return None + + mrope_position_delta = torch.as_tensor(mrope_position_delta) + if mrope_position_delta.ndim <= 1: + mrope_position_delta = mrope_position_delta.reshape(-1, 1) + return mrope_positions, mrope_position_delta + + @staticmethod + def _as_grid_batch(value): + if value is None: + return None + if isinstance(value, torch.Tensor): + return value.unsqueeze(0) if value.ndim == 1 else value + tensor = torch.as_tensor(value, dtype=torch.long) + return tensor.unsqueeze(0) if tensor.ndim == 1 else tensor + + def _compute_image_only_mrope_positions_from_offsets( + self, + input_len: int, + mm_items: List[MultimodalDataItem], + dtype: torch.dtype, + device: torch.device, + ) -> Optional[tuple[torch.Tensor, torch.Tensor]]: + """instead of calling get_rope_index, build mrope position from mm_items.offsets and image_grid_thw of each image + basically a simplified version of get_rope_index for image-only reqs + """ + if self.model_type not in ( + "qwen3_vl", + "qwen3_vl_moe", + "qwen3_5", + "qwen3_5_moe", + "qwen4_exp", + "qwen3_8_flash_next", + "intern_s2_preview", + "interns2_mobius", + ): + return None + + image_items = [item for item in mm_items if item.is_image()] + if not image_items or len(image_items) != len(mm_items): + return None + + spatial_merge_size = self._spatial_merge_size + sorted_items = sorted(image_items, key=lambda item: item.offsets[0][0]) + position_segments = [] + st = 0 + next_pos = 0 + + for item in sorted_items: + if item.offsets is None or len(item.offsets) != 1: + return None + + start, end = item.offsets[0] + if start < st or end >= input_len: + return None + + text_len = start - st + if text_len > 0: + position_segments.append( + torch.arange(text_len, dtype=dtype, device=device) + .view(1, -1) + .expand(3, -1) + + next_pos + ) + next_pos += text_len + + grid = self._as_grid_batch(item.model_specific_data.get("image_grid_thw")) + if grid is None or grid.shape[0] != 1: + return None + t, h, w = [int(x) for x in grid[0].tolist()] + llm_grid_t = t + llm_grid_h = h // spatial_merge_size + llm_grid_w = w // spatial_merge_size + num_image_tokens = llm_grid_t * llm_grid_h * llm_grid_w + if num_image_tokens != end - start + 1: + return None + + t_index = ( + torch.arange(llm_grid_t, dtype=dtype, device=device) + .view(-1, 1) + .expand(llm_grid_t, llm_grid_h * llm_grid_w) + .reshape(-1) + ) + h_index = ( + torch.arange(llm_grid_h, dtype=dtype, device=device) + .view(1, -1, 1) + .expand(llm_grid_t, llm_grid_h, llm_grid_w) + .reshape(-1) + ) + w_index = ( + torch.arange(llm_grid_w, dtype=dtype, device=device) + .view(1, 1, -1) + .expand(llm_grid_t, llm_grid_h, llm_grid_w) + .reshape(-1) + ) + position_segments.append( + torch.stack([t_index, h_index, w_index]) + next_pos + ) + next_pos += max(llm_grid_t, llm_grid_h, llm_grid_w) + st = end + 1 + + if st < input_len: + text_len = input_len - st + position_segments.append( + torch.arange(text_len, dtype=dtype, device=device) + .view(1, -1) + .expand(3, -1) + + next_pos + ) + + mrope_positions = torch.cat(position_segments, dim=1).unsqueeze(1) + mrope_position_delta = (mrope_positions.max() + 1 - input_len).reshape(1, 1) + return mrope_positions, mrope_position_delta + + @classmethod + def _concat_mm_item_grid(cls, mm_items: list[MultimodalDataItem], key, modality): + grids = [] + for item in mm_items: + if not item.is_modality(modality): + continue + grid = cls._as_grid_batch(item.model_specific_data.get(key)) + if grid is not None: + grids.append(grid) + if not grids: + return None + if len(grids) == 1: + return grids[0] + return torch.cat(grids, dim=0) + + @classmethod + def _get_grid_from_output_or_items( + cls, ret, mm_items, key, modality, input_data=None + ): + grid = cls._get_processor_output_value(ret, key) + if grid is None: + grid = cls._concat_mm_item_grid(mm_items, key, modality) + if grid is None and input_data and isinstance(input_data[0], dict): + grid = input_data[0].get(key) + return grid + + def get_mm_data(self, prompt, embeddings, **kwargs): + img_grid_thw = kwargs.get("img_grid_thw", None) + video_grid_thw = kwargs.get("video_grid_thw", None) + audio_feature_lens = kwargs.get("audio_feature_lens", None) + video_timestamps = kwargs.get("video_timestamps", None) + second_per_grid_ts = kwargs.get("second_per_grid_ts", None) + + audio_seq_lens = None + if audio_feature_lens is not None: + if self.model_type == "qwen3_omni_moe": + # apply _get_feat_extract_lengths to get seq_lens + input_lengths_leave = audio_feature_lens % 100 + feat_lengths = (input_lengths_leave - 1) // 2 + 1 + audio_seq_lens = ( + ((feat_lengths - 1) // 2 + 1 - 1) // 2 + + 1 + + (audio_feature_lens // 100) * 13 + ) + elif self.model_type == "qwen2_5_omni": + audio_seq_lens = (audio_feature_lens - 1) // 2 + 1 + audio_seq_lens = (audio_seq_lens - 2) // 2 + 1 + + if ( + self.model_type + in [ + "qwen3_vl", + "qwen3_vl_moe", + "qwen3_5", + "qwen3_5_moe", + "qwen4_exp", + "qwen3_8_flash_next", + "intern_s2_preview", + ] + and video_timestamps is not None + ): + input_ids, offsets, modality_list = self.build_input_ids_with_timestamps( + prompt, embeddings, img_grid_thw, video_grid_thw, video_timestamps + ) + else: + input_ids, offsets, modality_list = self.build_input_ids( + prompt, img_grid_thw, video_grid_thw, audio_seq_lens=audio_seq_lens + ) + assert all(isinstance(modality, Modality) for modality in modality_list) + + mrope_positions, mrope_position_delta = MRotaryEmbedding.get_rope_index( + spatial_merge_size=self._spatial_merge_size, + image_token_id=self.mm_tokens.image_token_id, + video_token_id=self.mm_tokens.video_token_id, + vision_start_token_id=self.vision_start_token_id, + model_type=self.model_type, + input_ids=torch.tensor(input_ids, dtype=torch.long).unsqueeze(0), + image_grid_thw=img_grid_thw, + video_grid_thw=video_grid_thw, + second_per_grid_ts=second_per_grid_ts, + use_audio_in_video=False, + audio_seqlens=( + audio_feature_lens if self.model_type == "qwen3_omni_moe" else None + ), + audio_token_id=getattr(self.hf_config, "audio_token_id", None), + audio_start_token_id=self.audio_start_token_id, + position_id_per_seconds=getattr( + self.hf_config, "position_id_per_seconds", None + ), + tokens_per_second=self._tokens_per_second, + ) + mrope_positions = mrope_positions.squeeze(1) + + mm_items = [] + consumed_per_modality = {} + + for modality, offset in zip(modality_list, offsets): + num_tokens = offset[1] - offset[0] + 1 + embedding_start = consumed_per_modality.get(modality, 0) + embedding_slice = embeddings[modality][ + embedding_start : embedding_start + num_tokens + ] + consumed_per_modality[modality] = embedding_start + num_tokens + mm_items.append( + MultimodalDataItem( + modality=modality, + offsets=[offset], + precomputed_embeddings=embedding_slice, + ) + ) + + return MultimodalProcessorOutput( + input_ids=input_ids, + mm_items=mm_items, + im_start_id=self.IM_START_TOKEN_ID, + im_end_id=self.IM_END_TOKEN_ID, + im_token_id=self.mm_tokens.image_token_id, + video_token_id=self.mm_tokens.video_token_id, + audio_token_id=self.mm_tokens.audio_token_id, + mrope_positions=mrope_positions, + mrope_position_delta=mrope_position_delta, + ) + + async def process_mm_data_async( + self, + image_data: List[Union[str, bytes]], + input_text, + request_obj, + *args, + **kwargs, + ): + entry_time = time.perf_counter() + base_output = await self.load_mm_data( + prompt=input_text, + image_data=image_data, + video_data=request_obj.video_data, + audio_data=request_obj.audio_data, + multimodal_tokens=self.mm_tokens, + ) + load_time = time.perf_counter() + rid = getattr(request_obj, "rid", "anonymous_rid") + + video_metadata = None + if base_output.videos and not isinstance(base_output.videos[0], dict): + videos_processed = [ + await preprocess_video(video, video_config=self.video_config) + for video in base_output.videos + ] + base_output.videos, video_metadata = map(list, zip(*videos_processed)) + + preprocess_time = time.perf_counter() + + processor_kwargs = {} + processor_video_config = _get_processor_video_config( + self.video_config, video_metadata + ) + if processor_video_config is not None: + processor_kwargs["processor_video_config"] = processor_video_config + + # NOTE: for qwen3-vl, video_meta need to be passed in, since do_sample_frames is already done in preprocess_video + if self.hf_config.model_type in ( + "qwen3_vl", + "qwen3_vl_moe", + "qwen3_5", + "qwen3_5_moe", + "qwen4_exp", + "qwen3_8_flash_next", + "intern_s2_preview", + "interns2_mobius", + ): + processor_kwargs.update( + video_metadata=video_metadata, + do_sample_frames=False, + ) + + mm_items, input_ids, ret = await self.process_and_combine_mm_data_async( + base_output, self.mm_tokens, **processor_kwargs + ) + + self._mark_dp_encoder_features_for_deferred_reconstruction(mm_items) + + audio_feature_lengths = None + + if self.model_type == "qwen3_omni_moe": + audio_item = next((mm for mm in mm_items if mm.is_audio()), None) + if audio_item: + audio_feature_lengths = torch.sum( + audio_item.feature_attention_mask, dim=1 + ) + + second_per_grid_ts = self._get_processor_output_value(ret, "second_per_grid_ts") + if second_per_grid_ts is None: + second_per_grid_ts = self._get_processor_output_value( + ret, "video_second_per_grid" + ) + + process_time = time.perf_counter() + + input_ids = input_ids.flatten() + base_input_ids = getattr(base_output, "input_ids", None) + if ( + isinstance(base_input_ids, list) + and len(base_input_ids) == input_ids.numel() + ): + # reuse preprocess input if it already carries list of input_ids + input_ids_list = base_input_ids + else: + input_ids_list = input_ids.tolist() + + # look for if padded_input_ids already exists before computing + padded_input_ids = self._get_processor_output_value(ret, "padded_input_ids") + if padded_input_ids is None: + padded_input_ids = MultimodalProcessorOutput.build_padded_input_ids( + input_ids_list, mm_items + ) + elif isinstance(padded_input_ids, torch.Tensor): + # reuse existing padded_input_ids + padded_input_ids = padded_input_ids.flatten().tolist() + else: + padded_input_ids = list(padded_input_ids) + + image_grid_thw = self._get_grid_from_output_or_items( + ret, mm_items, "image_grid_thw", Modality.IMAGE, image_data + ) + video_grid_thw = self._get_grid_from_output_or_items( + ret, + mm_items, + "video_grid_thw", + Modality.VIDEO, + request_obj.video_data, + ) + + mrope_result = self._get_precomputed_mrope_from_output(ret) + if mrope_result is None: + if ( + video_grid_thw is None + and second_per_grid_ts is None + and audio_feature_lengths is None + ): + mrope_result = self._compute_image_only_mrope_positions_from_offsets( + input_len=input_ids.numel(), + mm_items=mm_items, + dtype=input_ids.dtype, + device=input_ids.device, + ) + if mrope_result is None: + mrope_result = MRotaryEmbedding.get_rope_index( + spatial_merge_size=self._spatial_merge_size, + image_token_id=self.mm_tokens.image_token_id, + video_token_id=self.mm_tokens.video_token_id, + vision_start_token_id=self.vision_start_token_id, + model_type=self.model_type, + tokens_per_second=self._tokens_per_second, + # use the expanded token ids + input_ids=input_ids.unsqueeze(0), + image_grid_thw=image_grid_thw, + video_grid_thw=video_grid_thw, + second_per_grid_ts=second_per_grid_ts, + use_audio_in_video=False, + audio_seqlens=audio_feature_lengths, + audio_token_id=getattr(self.hf_config, "audio_token_id", None), + audio_start_token_id=self.audio_start_token_id, + position_id_per_seconds=getattr( + self.hf_config, "position_id_per_seconds", None + ), + ) + + mrope_positions, mrope_position_delta = mrope_result + if mrope_positions.ndim == 3: + mrope_positions = mrope_positions.squeeze(1) + get_rope_index_time = time.perf_counter() + logger.debug( + f"[QwenVLProcessor Perf] {rid=}, " + f"load_time: {(load_time - entry_time) * 1000:.2f} ms, " + f"preprocess_time: {(preprocess_time - load_time) * 1000:.2f} ms, " + f"process_time: {(process_time - preprocess_time) * 1000:.2f} ms, " + f"get_rope_index_time: {(get_rope_index_time - process_time) * 1000:.2f} ms, " + f"total_time: {(get_rope_index_time - entry_time) * 1000:.2f} ms" + ) + + return MultimodalProcessorOutput( + input_ids=input_ids_list, + padded_input_ids=padded_input_ids, + mm_items=mm_items, + im_start_id=self.vision_start_token_id, + im_end_id=self.vision_end_token_id, + im_token_id=self.mm_tokens.image_token_id, + video_token_id=self.mm_tokens.video_token_id, + audio_token_id=self.mm_tokens.audio_token_id, + mrope_positions=mrope_positions, + mrope_position_delta=mrope_position_delta, + ) + + def _mark_dp_encoder_features_for_deferred_reconstruction(self, mm_items): + if not ( + self.keep_mm_features_on_device + and self.server_args.mm_enable_dp_encoder + and self.model_type + in ("qwen3_vl", "qwen3_vl_moe", "qwen3_5", "qwen3_5_moe") + ): + return + for item in mm_items: + if item.is_image() or item.is_video(): + item.model_specific_data[DEFER_CUDA_IPC_FEATURE_RECONSTRUCTION_KEY] = ( + True + ) diff --git a/scripts/test_qwen_multimodal_alias.sh b/scripts/test_qwen_multimodal_alias.sh new file mode 100755 index 0000000..80931d9 --- /dev/null +++ b/scripts/test_qwen_multimodal_alias.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env bash +# CPU-only local validation; no build, GPU devices, network, or publication. +set -euo pipefail +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +: "${QWEN_MODEL_PATH:?Set to the release config directory documented in docs/qwen-multimodal-alias.md}" +CONFIG_PATH="$(realpath "$QWEN_MODEL_PATH/config.json")" +test -f "$CONFIG_PATH" +IMAGE='kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404' +python3 "$ROOT/scripts/verify_qwen_multimodal_alias.py" +docker image inspect "$IMAGE" >/dev/null +docker run --rm --pull never --network none --read-only --cap-drop all \ + --pids-limit 512 --memory 16g --user "$(id -u):$(id -g)" \ + --tmpfs /tmp:rw,exec,size=2g,uid="$(id -u)",gid="$(id -g)" \ + --tmpfs /home/ubuntu/.cache:rw,exec,size=1g,uid="$(id -u)",gid="$(id -g)" \ + -e CUDA_VISIBLE_DEVICES= -e OMP_NUM_THREADS=1 -e MKL_NUM_THREADS=1 \ + -e QWEN_CONFIG_PATH=/qwen-config.json \ + -v "$CONFIG_PATH:/qwen-config.json:ro" -v "$ROOT:/repo:ro" \ + -v "$ROOT/runtime/python/sglang/srt/multimodal/processors/qwen_vl.py:/sgl-workspace/sglang/python/sglang/srt/multimodal/processors/qwen_vl.py:ro" \ + --entrypoint python3 "$IMAGE" /repo/tests/runtime_qwen_multimodal_alias.py -v diff --git a/scripts/verify_qwen_multimodal_alias.py b/scripts/verify_qwen_multimodal_alias.py new file mode 100755 index 0000000..f4e3afd --- /dev/null +++ b/scripts/verify_qwen_multimodal_alias.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python3 +"""Verify the Qwen Flash-Next multimodal alias profile.""" +import argparse +import hashlib +import json +from pathlib import Path +import subprocess + +from verify_responses_compat import verify as verify_responses +from verify_responses_compat import package_records as responses_package_records + +ROOT = Path(__file__).resolve().parents[1] + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def package_records(): + manifest = json.loads((ROOT / "provenance/qwen-multimodal-alias.json").read_text()) + _, inventory = responses_package_records() + base_inventory = ROOT / "provenance/responses-compat-runtime-files.json" + if digest(base_inventory) != manifest["base_inventory_sha256"]: + raise ValueError("Base inventory digest mismatch") + for name, hashes in manifest["files"].items(): + if inventory.get(name) != hashes["before"]: + raise ValueError("Multimodal preimage mismatch: " + name) + if digest(ROOT / "runtime" / name) != hashes["after"]: + raise ValueError("Packaged runtime mismatch: " + name) + inventory[name] = hashes["after"] + patch = ROOT / "patches" / manifest["patch"] + if digest(patch) != manifest["patch_sha256"]: + raise ValueError("Multimodal patch hash mismatch") + series = (ROOT / "patches/series.qwen-multimodal-alias").read_text().splitlines() + if series != [ + "0015-qwen-flash-next-effort-alias.patch", + "0016-responses-namespace-custom-boundary.patch", + manifest["patch"], + ]: + raise ValueError("Multimodal patch order differs") + encoded = (json.dumps(dict(sorted(inventory.items())), indent=2) + "\n").encode() + if hashlib.sha256(encoded).hexdigest() != manifest["result_inventory_sha256"]: + raise ValueError("Result inventory digest mismatch") + return manifest, inventory + + +def verify(tree, apply=False, from_image=False): + manifest, inventory = package_records() + if apply or from_image: + verify_responses(tree, from_image=from_image) + patch = ROOT / "patches" / manifest["patch"] + subprocess.run(["git", "apply", "--check", str(patch)], cwd=tree, check=True) + subprocess.run(["git", "apply", str(patch)], cwd=tree, check=True) + actual = { + str(path.relative_to(tree)) + for path in (tree / "python/sglang").rglob("*") + if path.is_file() and "__pycache__" not in path.parts and path.suffix != ".pyc" + } + if actual != set(inventory): + raise ValueError("Full source inventory differs") + for name, expected in inventory.items(): + if digest(tree / name) != expected: + raise ValueError("Source hash mismatch: " + name) + return len(inventory) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--tree", type=Path) + actions = parser.add_mutually_exclusive_group() + actions.add_argument("--apply", action="store_true") + actions.add_argument("--from-image", action="store_true") + args = parser.parse_args() + if (args.apply or args.from_image) and args.tree is None: + parser.error("Application requires --tree") + count = ( + verify(args.tree.resolve(), args.apply, args.from_image) + if args.tree + else len(package_records()[1]) + ) + print(json.dumps({"profile": "qwen-multimodal-alias", "source_files": count, + "full_tree_verified": args.tree is not None})) diff --git a/tests/runtime_qwen_multimodal_alias.py b/tests/runtime_qwen_multimodal_alias.py new file mode 100644 index 0000000..edf073e --- /dev/null +++ b/tests/runtime_qwen_multimodal_alias.py @@ -0,0 +1,147 @@ +"""CPU regression for Qwen Flash-Next multimodal release aliases.""" +import asyncio +from copy import deepcopy +import json +import os +from pathlib import Path +from types import SimpleNamespace +import unittest +from unittest.mock import AsyncMock, patch + +import torch +from sglang.srt.configs.qwen4_exp import Qwen4ExpConfig +from sglang.srt.multimodal.processors import qwen_vl as qv + + +class Tokenizer: + def encode(self, text, **kwargs): + return [300 + ord(char) for char in text] + + +def processor(model_type): + config_path = Path(os.environ["QWEN_CONFIG_PATH"]) + config = Qwen4ExpConfig(**json.loads(config_path.read_text())) + assert config.model_type == "qwen3_8_flash_next" + config.model_type = model_type + + def initialize_base(instance, hf_config, *args, **kwargs): + instance.hf_config = hf_config + instance._processor = SimpleNamespace(tokenizer=Tokenizer()) + + with patch.object(qv.SGLangBaseProcessor, "__init__", initialize_base), patch.object( + qv.MultimodalSpecialTokens, "build", lambda instance, _: instance + ): + return qv.QwenVLImageProcessor(config, SimpleNamespace(), SimpleNamespace()) + + +class QwenMultimodalAliasTest(unittest.TestCase): + def test_release_processor_enables_existing_worker_policy(self): + for model_type in ("qwen4_exp", "qwen3_8_flash_next"): + with self.subTest(model_type=model_type): + instance = processor(model_type) + self.assertTrue(instance.supports_mm_processor_concurrency) + self.assertEqual(instance.auto_mm_processor_worker_num, 2) + self.assertEqual(instance.auto_mm_io_worker_num, 16) + + def test_preprocessed_video_preserves_metadata_and_sampling(self): + metadata = { + "fps": 4, + "total_num_frames": 32, + "duration": 8, + "frames_indices": list(range(0, 32, 2)), + } + frames = torch.zeros(16, 3, 32, 32) + + class ReachedProcessor(Exception): + pass + + for model_type in ("qwen4_exp", "qwen3_8_flash_next", "qwen2_vl"): + with self.subTest(model_type=model_type): + instance = processor(model_type) + instance.video_config = {"fps": 2} + instance.load_mm_data = AsyncMock( + return_value=SimpleNamespace(videos=[object()]) + ) + instance.process_and_combine_mm_data_async = AsyncMock( + side_effect=ReachedProcessor + ) + request = SimpleNamespace( + video_data=["synthetic"], audio_data=None, rid="video-test" + ) + with patch.object( + qv, "preprocess_video", AsyncMock(return_value=(frames, metadata)) + ): + with self.assertRaises(ReachedProcessor): + asyncio.run(instance.process_mm_data_async([], [1, 2], request)) + kwargs = instance.process_and_combine_mm_data_async.call_args.kwargs + if model_type == "qwen2_vl": + self.assertNotIn("video_metadata", kwargs) + self.assertNotIn("do_sample_frames", kwargs) + else: + self.assertEqual(kwargs["video_metadata"], [metadata]) + self.assertFalse(kwargs["do_sample_frames"]) + self.assertEqual(kwargs["processor_video_config"], {}) + + def test_video_timestamp_positions_and_embedding_slices_match(self): + reference = processor("qwen4_exp") + release = processor("qwen3_8_flash_next") + prompt = [ + 10, + reference.IM_START_TOKEN_ID, + reference.VIDEO_TOKEN_ID, + reference.IM_END_TOKEN_ID, + 11, + ] + embeddings = { + qv.Modality.VIDEO: torch.arange(32, dtype=torch.float32).reshape(16, 2) + } + kwargs = { + "video_grid_thw": torch.tensor([[4, 4, 4]]), + "video_timestamps": [[0.0, 2.0, 4.0, 6.0]], + } + expected = reference.get_mm_data(prompt, embeddings, **deepcopy(kwargs)) + actual = release.get_mm_data(prompt, embeddings, **deepcopy(kwargs)) + self.assertEqual(actual.input_ids, expected.input_ids) + self.assertEqual(len(actual.mm_items), len(expected.mm_items)) + self.assertEqual(len(actual.mm_items), 4) + self.assertTrue(torch.equal(actual.mrope_positions, expected.mrope_positions)) + self.assertTrue( + torch.equal(actual.mrope_position_delta, expected.mrope_position_delta) + ) + for index, (got, wanted) in enumerate(zip(actual.mm_items, expected.mm_items)): + self.assertEqual(got.offsets, wanted.offsets) + self.assertTrue( + torch.equal( + got.precomputed_embeddings, + embeddings[qv.Modality.VIDEO][index * 4 : (index + 1) * 4], + ) + ) + self.assertIn(Tokenizer().encode("<6.0 seconds>")[0], actual.input_ids) + + def test_image_offset_positions_match_registered_architecture(self): + item = qv.MultimodalDataItem( + modality=qv.Modality.IMAGE, + offsets=[(2, 5)], + model_specific_data={"image_grid_thw": torch.tensor([[1, 4, 4]])}, + ) + kwargs = { + "input_len": 8, + "mm_items": [item], + "dtype": torch.long, + "device": torch.device("cpu"), + } + expected = processor( + "qwen4_exp" + )._compute_image_only_mrope_positions_from_offsets(**kwargs) + actual = processor( + "qwen3_8_flash_next" + )._compute_image_only_mrope_positions_from_offsets(**kwargs) + self.assertIsNotNone(actual) + self.assertIsNotNone(expected) + self.assertTrue( + all(torch.equal(got, wanted) for got, wanted in zip(actual, expected)) + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_qwen_multimodal_packaging.py b/tests/test_qwen_multimodal_packaging.py new file mode 100644 index 0000000..27a0d6b --- /dev/null +++ b/tests/test_qwen_multimodal_packaging.py @@ -0,0 +1,50 @@ +"""Fail-closed packaging tests for the multimodal alias profile.""" +import importlib.util +from pathlib import Path +import sys +import unittest +from unittest.mock import patch + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "scripts")) +spec = importlib.util.spec_from_file_location( + "qwen_multimodal_verifier", ROOT / "scripts/verify_qwen_multimodal_alias.py" +) +verifier = importlib.util.module_from_spec(spec) +spec.loader.exec_module(verifier) + + +class QwenMultimodalPackagingTest(unittest.TestCase): + def test_manifest_chain_and_runtime_compile(self): + manifest, inventory = verifier.package_records() + self.assertEqual(len(inventory), 4392) + self.assertEqual( + list(manifest["files"]), + ["python/sglang/srt/multimodal/processors/qwen_vl.py"], + ) + for name in manifest["files"]: + compile((ROOT / "runtime" / name).read_bytes(), name, "exec") + + def test_runtime_drift_fails_closed(self): + original = verifier.digest + + def changed(path): + if path.name == "qwen_vl.py": + return "0" * 64 + return original(path) + + with patch.object(verifier, "digest", side_effect=changed): + with self.assertRaisesRegex(ValueError, "Packaged runtime mismatch"): + verifier.package_records() + + def test_patch_drift_fails_closed(self): + original = verifier.digest + + def changed(path): + if path.name.startswith("0018-"): + return "0" * 64 + return original(path) + + with patch.object(verifier, "digest", side_effect=changed): + with self.assertRaisesRegex(ValueError, "patch hash mismatch"): + verifier.package_records() From 84ec70a74a88750f8a5a4b4fa2e6a2b5674ead86 Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 14:36:37 +0100 Subject: [PATCH 14/20] fix(packaging): compose multimodal alias after responses --- Dockerfile.qwen-multimodal-alias | 6 +- docs/qwen-multimodal-alias.md | 50 +- patches/series.qwen-multimodal-alias | 1 + .../qwen-multimodal-alias-runtime-files.json | 4394 +++++++++++++++++ provenance/qwen-multimodal-alias.json | 15 +- scripts/verify_qwen_multimodal_alias.py | 17 +- tests/test_qwen_multimodal_packaging.py | 36 + 7 files changed, 4494 insertions(+), 25 deletions(-) create mode 100644 provenance/qwen-multimodal-alias-runtime-files.json diff --git a/Dockerfile.qwen-multimodal-alias b/Dockerfile.qwen-multimodal-alias index bb30f8f..79b0194 100644 --- a/Dockerfile.qwen-multimodal-alias +++ b/Dockerfile.qwen-multimodal-alias @@ -1,4 +1,4 @@ -# Qwen Flash-Next API and multimodal compatibility overlay. +# Cumulative CPU-only overlay: patches 0015, 0016, 0017, then 0018. # All model paths, serving arguments, and runtime settings remain external. FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 ARG SOURCE_REVISION @@ -10,6 +10,8 @@ COPY runtime/python/sglang/srt/entrypoints/openai/serving_responses.py /sgl-work COPY runtime/python/sglang/srt/entrypoints/openai/responses_compat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py COPY runtime/python/sglang/srt/function_call/qwen3_coder_detector.py /sgl-workspace/sglang/python/sglang/srt/function_call/qwen3_coder_detector.py COPY runtime/python/sglang/srt/multimodal/processors/qwen_vl.py /sgl-workspace/sglang/python/sglang/srt/multimodal/processors/qwen_vl.py -RUN python3 -B -c 'import pathlib; p=pathlib.Path("/sgl-workspace/sglang/python/sglang/srt"); files=[p/"entrypoints/openai"/n for n in ("serving_chat.py", "protocol.py", "serving_responses.py", "responses_compat.py")]+[p/"function_call/qwen3_coder_detector.py", p/"multimodal/processors/qwen_vl.py"]; [compile(f.read_bytes(), str(f), "exec") for f in files]' +COPY provenance/qwen-multimodal-alias-runtime-files.json /tmp/qwen-multimodal-alias-runtime-files.json +RUN python3 -B -c 'import hashlib,json,pathlib; root=pathlib.Path("/sgl-workspace/sglang"); expected=json.loads(pathlib.Path("/tmp/qwen-multimodal-alias-runtime-files.json").read_text()); actual={str(p.relative_to(root)) for p in (root/"python/sglang").rglob("*") if p.is_file() and "__pycache__" not in p.parts and p.suffix != ".pyc"}; assert actual == set(expected), (len(actual), len(expected)); bad=[n for n,h in expected.items() if hashlib.sha256((root/n).read_bytes()).hexdigest()!=h]; assert not bad, bad; files=[root/"python/sglang/srt/entrypoints/openai"/n for n in ("serving_chat.py", "protocol.py", "serving_responses.py", "responses_compat.py")]+[root/"python/sglang/srt/function_call/qwen3_coder_detector.py", root/"python/sglang/srt/multimodal/processors/qwen_vl.py"]; [compile(f.read_bytes(), str(f), "exec") for f in files]' \ + && rm /tmp/qwen-multimodal-alias-runtime-files.json ENTRYPOINT ["python3", "-m", "sglang.launch_server"] CMD ["--help"] diff --git a/docs/qwen-multimodal-alias.md b/docs/qwen-multimodal-alias.md index cbea3a2..9cc9860 100644 --- a/docs/qwen-multimodal-alias.md +++ b/docs/qwen-multimodal-alias.md @@ -9,15 +9,34 @@ token construction, and the image-only mRoPE fast path. This profile adds the release model type to those four existing allowlists. It does not add a new processor, change sampling, reorder media, modify model weights, or affect text-only `qwen3_8_flash_next_text` checkpoints. Other model -types keep their existing behavior. +types keep their existing behavior. The functional patch remains the reviewed +four-line allowlist change. ## Composition -Patch `0018-qwen-flash-next-multimodal-alias.patch` applies after the existing -Responses compatibility profile. `Dockerfile.qwen-multimodal-alias` includes -the five existing API overlay files and the resulting Qwen VL processor file. +This cumulative profile is based on main +`460545bf81f1ed24205232d9371e8eb1a02f3e46` and applies, in order: + +1. `0015-qwen-flash-next-effort-alias.patch` (`minimal` → `low`, and the existing + high aliases), +2. `0016-responses-namespace-custom-boundary.patch`, +3. `0017-responses-phase-order.patch`, and +4. `0018-qwen-flash-next-multimodal-alias.patch`. + +The first three patches are the current Responses phase/order predecessor +contract documented in [responses-compat.md](responses-compat.md). +`Dockerfile.qwen-multimodal-alias` overlays the resulting six runtime files: +`serving_chat.py`, `protocol.py`, `serving_responses.py`, `responses_compat.py`, +`qwen3_coder_detector.py`, and `qwen_vl.py`. Its build step checks the complete +4,392-file source inventory and hashes, then compiles all six overlay files, so +a successful build cannot silently contain the old Responses or effort source. All serving arguments and model paths remain external. +The cumulative inventory is +`provenance/qwen-multimodal-alias-runtime-files.json`; its identity and the +predecessor inventory, patch, and changed-file hashes are pinned in +`provenance/qwen-multimodal-alias.json`. + ## CPU validation Use a local directory containing the release checkpoint's `config.json`. The @@ -31,9 +50,10 @@ python3 scripts/verify_qwen_multimodal_alias.py ``` The runtime test compares `qwen3_8_flash_next` with the already-registered -`qwen4_exp` behavior. It covers worker policy, video metadata and frame-sampling -flags, timestamp token positions and embedding slices, and image-only mRoPE -positions. The runner uses a read-only, network-disabled, GPU-disabled container. +`qwen4_exp` behavior. Its four focused tests cover worker policy, video metadata +and frame-sampling flags, timestamp token positions and embedding slices, and +image-only mRoPE positions. The runner uses a read-only, network-disabled, +GPU-disabled container. For a complete source reconstruction, export `python/sglang` from the exact base image into `TREE`, then run: @@ -43,10 +63,16 @@ python3 scripts/verify_qwen_multimodal_alias.py --tree TREE --from-image python3 scripts/verify_qwen_multimodal_alias.py --tree TREE ``` +`--from-image` verifies the exact image source, applies 0015, 0016, 0017, and +0018 in that order, and checks all resulting paths and hashes. `--apply` instead +accepts a fully verified Responses phase/order predecessor tree and applies only +0018. + ## Limits -CPU equality with the registered processor path does not establish semantic -video accuracy. Historical live testing accepted image inputs but still -misordered events in short four-frame chronology cases. That video-ordering -issue remains open; this patch only restores the processor behavior already -used by the equivalent development model type. +These are source reconstruction and CPU structural tests. They are not a GPU +qualification and do not establish image or video semantic accuracy. Historical +live testing accepted image inputs but still misordered events in short +four-frame chronology cases. That video-ordering issue remains open; this patch +only restores the processor behavior already used by the equivalent development +model type. No image is published or deployed by this profile update. diff --git a/patches/series.qwen-multimodal-alias b/patches/series.qwen-multimodal-alias index 2243142..05c6b14 100644 --- a/patches/series.qwen-multimodal-alias +++ b/patches/series.qwen-multimodal-alias @@ -1,3 +1,4 @@ 0015-qwen-flash-next-effort-alias.patch 0016-responses-namespace-custom-boundary.patch +0017-responses-phase-order.patch 0018-qwen-flash-next-multimodal-alias.patch diff --git a/provenance/qwen-multimodal-alias-runtime-files.json b/provenance/qwen-multimodal-alias-runtime-files.json new file mode 100644 index 0000000..38e0ded --- /dev/null +++ b/provenance/qwen-multimodal-alias-runtime-files.json @@ -0,0 +1,4394 @@ +{ + "python/sglang/README.md": "becae5c300803f59e9b231a02b8a3bf93d71cc3b3456116fcd956da03721331b", + "python/sglang/__init__.py": "e54e5073b3d139f84b594bb23f7651a41a7c3d0148df980568928a070192ad5b", + "python/sglang/_mps_stub.py": "1cef5f18d926d6df10797de336d9548baca4278d2d0fba2f3a65280f45e11abe", + "python/sglang/_triton_stub.py": "2b6068eb75ee7e9a04fbf5539b6c05bedd24d8b54875c5e4576ba4661d628eae", + "python/sglang/_version.py": "ad6aabfc8c01600e574ad0d329b3740a975bf256d2cc9716d7145cb6843fb1a2", + "python/sglang/bench_offline_throughput.py": "fd5c5a9cdd91a19894916b85e2664c3fbdcdc32c3ec044bfd0cd9b0908cf167f", + "python/sglang/bench_one_batch.py": "2b062012b43493632ca6dbbb46aa783e235905c9da9cde94c23b6f6b3828ab55", + "python/sglang/bench_one_batch_server.py": "477b8710a3eb5d89d137344c6a45f839a6b3f2d73623f14b6aa9d8e44d9a03cb", + "python/sglang/bench_serving.py": "e2ed21f918212615d7aea997b858f8e7655c23923b968fa57a6b56559607bec7", + "python/sglang/benchmark/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/benchmark/bench_utils.py": "762496fd3514db0a5d73b48f16a5f981312355de0a04c5c4480cdbc0c8d8d0ec", + "python/sglang/benchmark/datasets/__init__.py": "2a3f8f837d621eea2e943d3b741777d15249b8dffa8af4e427492b75632eb8b6", + "python/sglang/benchmark/datasets/agentic_trace.py": "575d2580ca81f3cc267ad8f029efe0fb3a9ad3ca4db1a7e75db44402738f2a95", + "python/sglang/benchmark/datasets/common.py": "544b1b66c8be9cae6e870f3da337b8e3f356ec93ee9ea6c1ce700e1f55b3b442", + "python/sglang/benchmark/datasets/custom.py": "7f8460b6bfae2341d11270067620904f541315943ee94879d99cc227b4e2fc8e", + "python/sglang/benchmark/datasets/generated_shared_prefix.py": "80a581fdd819a159e1518fbfdabf1b62e3ecf6c6c65d4e8328276495f7e2e307", + "python/sglang/benchmark/datasets/image.py": "9ce6564aee48f9edc3b3aabf124e6ee55982891bcabef4700f774f8e254788c7", + "python/sglang/benchmark/datasets/longbench_v2.py": "44dc153dc559c3b968459e9b072b01113e7513720a11323f68754af9dbfbfec3", + "python/sglang/benchmark/datasets/mmmu.py": "a2c6ef7d4b77b884e3ca04e64fd01449985ea4a60544f437905734e20d924fa1", + "python/sglang/benchmark/datasets/mooncake.py": "dcdf06f19b0c06fde742f1bd36dadf0b69aafc07f5361ed84c447a47741db1ab", + "python/sglang/benchmark/datasets/openai_dataset.py": "ecee9f2971e916201c88657aca08e9d28efc0fefc3e10bb8f493c6d191cfed8c", + "python/sglang/benchmark/datasets/random.py": "a1242f133dfc3d4c5d30a396cedb5351e6d6b447a632091eaf6e6c403beada7c", + "python/sglang/benchmark/datasets/sharegpt.py": "1803646354f3a54f9ae87db0ad6235e7689038ff00303601aa84657075d929f4", + "python/sglang/benchmark/datasets/speed_bench.py": "b3d6962624838e7c4f3547414c84cb6e253e76b7d1be6dfa037e1b14d5b40c1b", + "python/sglang/benchmark/dspark_sps_profiler.py": "f8820ba461c7c0956a1e1a787e45de8c09f025e46ac2ae9d4d1d22f4076a1911", + "python/sglang/benchmark/dspark_sts_fit.py": "0c368ce43608db0134fabc8a75a16e86529df28b8c06aaec1d6ac146fcad5f1f", + "python/sglang/benchmark/endpoint.py": "23dc79ce3b56e3544e1b4efe535fd3ecb7fe9aa2bc2bb3ac77b741ea8f3ad843", + "python/sglang/benchmark/offline_throughput.py": "deb4dc80a68b92490775e27fc5913dfbe15e287c601b29ef082204f14f5ae252", + "python/sglang/benchmark/one_batch.py": "9e1fa97baaada1c02ba1bc03e61815146487dc5c611aa0a4f67712f69305cef5", + "python/sglang/benchmark/one_batch_server.py": "eec8240f8b34f973ced70734d9ce2b061ef8d875c87a032d871a7dab0df1b631", + "python/sglang/benchmark/serving.py": "0d65ec5e4490eaf5bc999cd11f045688b05ff6a040b6fabc4e5e60faf134e574", + "python/sglang/benchmark/utils.py": "c9a04dc801f0c0fd0497a0d1e358af2eaa9ae182c6ff6c829f01e8ced281a4a3", + "python/sglang/check_env.py": "afa60d7ea0f828469f861e8bfbc75fa07b373f6afaf7b7a9ece0793f07b9cc8b", + "python/sglang/cli/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/cli/generate.py": "655cdb99f497106f44f2b2bb17d094ecab91675d580a5b1180dcd167ca82e9ff", + "python/sglang/cli/killall.py": "c5cecb6ee74a649a472395ed8788e466ed26b0cdb2e06be49749788be327b561", + "python/sglang/cli/main.py": "0c371f7878d50444540d191aba82674322ebce2b61ad9f0da74cbbc3a84f4210", + "python/sglang/cli/serve.py": "75f8a6166bc38cd28c3085ea1d72cad4cd5aacd0ebd0b515ac39d1d817114f84", + "python/sglang/cli/serve_backends.py": "94c2793bfa5b3d3d509c1be48142630334771c4f10605d943aba97faa031113c", + "python/sglang/cli/utils.py": "cfab1d29aba4202d56d868959a5309fc51192e39b8f40b7aa882c2c87e3c0ce3", + "python/sglang/compile_deep_gemm.py": "b3553a22fe846987c4a2193b6c1186cd27849b8473fcf61696a789bfd816af9a", + "python/sglang/eval/llama3_eval.py": "c11ee8dea86b1f1a02fb520246e88072f38e22e2b847e484e1403d8510d25039", + "python/sglang/eval/loogle_eval.py": "f820b6b36921e6a5280eb1d19105640bf8cdbc180da235db7f8e7a9f2e6cefcb", + "python/sglang/global_config.py": "6d5a542ff80c480d05c0997ccbcb4fe4221aeddd3cde8e8371a93ec91cadcc6c", + "python/sglang/kernel_api_logging.py": "d3cfbaa939422f47b84b96a8878a98b178a7182a79656440c08938804517c4f7", + "python/sglang/kernels/README.md": "500616add2ba819eecbbcfdb8a4044b7d8eaf470d3461a921e9465aed52952a6", + "python/sglang/kernels/__init__.py": "8699543ca891f901b829d318d14314ce516a03a5814e27db02ecf09b49250faa", + "python/sglang/kernels/aot/.clang-format": "dc2a6c4be9a0951daedae7d3ba0955f2062b4f05ae165d812d1e8d3706ef6c15", + "python/sglang/kernels/aot/CMakeLists.txt": "273212caf91c528959e906df6750f004909bff0ed0d0214ef72d35918acab455", + "python/sglang/kernels/aot/Dockerfile": "fd49e7c9f12b9d3f7f96326ceb0c0b9eb1ad61163baa776b187918f99e6da535", + "python/sglang/kernels/aot/LICENSE": "1495e1e757ef4d0925a2350563cf5754bb23c51701a8ec4fb3c5cdcbedae6747", + "python/sglang/kernels/aot/Makefile": "b14809f758c33ee5814ed43da37a43e1b7135237a5251eb16fff0ca35cae7c4e", + "python/sglang/kernels/aot/README.md": "af8c7784ed9197eb548433af7587d37b180e708f0a17e13ce7c8bf10522faae2", + "python/sglang/kernels/aot/THIRDPARTYNOTICES.txt": "2e44e480eb9e4e9e1b98ea2c442a5fa5186ffaec9f9d8b178ec8e6617a05cfa8", + "python/sglang/kernels/aot/analyze_whl_kernel_sizes.py": "75aab9c50021e74f1827487831f1813bcd25c7126f032dc1e29874fdbb5ce125", + "python/sglang/kernels/aot/benchmark/bench_activation.py": "c421f2c2166e467069022af4bee9a7cccbb05e023363100099e4b277022a9388", + "python/sglang/kernels/aot/benchmark/bench_amd_deterministic_allreduce.py": "7e51006df02e58c9427f1009ed617374570efde5dcb596023bcce12785417be9", + "python/sglang/kernels/aot/benchmark/bench_awq_dequant.py": "6e0e965ddc33288cc801446c70e396421d0b6596f92f518e73af9bfb54b42ae3", + "python/sglang/kernels/aot/benchmark/bench_cutlass_mla.py": "cc5d29c56a25a40de5d95d3060e49ccf147b60c48df091ef1381249bc0d42479", + "python/sglang/kernels/aot/benchmark/bench_dsv4_norm_rope.py": "eca51f60e7caec0c32c429522b601ac56badee4e345bc7d85183775a5b62e744", + "python/sglang/kernels/aot/benchmark/bench_es_fp8_blockwise_grouped_gemm.py": "97383c2a26b99b4446aa099b69cd875e44d97ae8dba37ea8e2393a438515f737", + "python/sglang/kernels/aot/benchmark/bench_fp4_gemm.py": "8bf0ac09f60477662dae78313ed271c3dcce0a6c3a3b387554363de2e020284b", + "python/sglang/kernels/aot/benchmark/bench_fp8_blockwise_group_gemm.py": "03d043f711116afbf9247b0b02ec2fc9c6059f3786cbb8746fab55d030dbca25", + "python/sglang/kernels/aot/benchmark/bench_fp8_gemm.py": "73e7fbdd165efef169a2fe326ec16442f689976b444868c88ae27918d37f1317", + "python/sglang/kernels/aot/benchmark/bench_fp8_gemm_swap_ab.py": "5ee968be1921ce842ca624c0c58f0a65cf65d5ff4a9291f9f39e077d8afb84e7", + "python/sglang/kernels/aot/benchmark/bench_int8_gemm.py": "3c4f10853558afa793da791d1ee8691c62d5954fcd0f8cc3bcaeb33d8abc8f16", + "python/sglang/kernels/aot/benchmark/bench_moe_align_block_size.py": "8386b345ef536ee203566658249e82f4293fbe35e71b0ca58ad3e4623452a236", + "python/sglang/kernels/aot/benchmark/bench_moe_ep_post_reorder.py": "5d4f2896563650f3bb05a735d6101940856d3339de00812a9d1da66be02fcaca", + "python/sglang/kernels/aot/benchmark/bench_moe_topk_sigmoid.py": "73305c4e56d22fcd4a5debf1ce4c3f5a17aaecd24251a406243574a2babe9a91", + "python/sglang/kernels/aot/benchmark/bench_moe_topk_softmax.py": "254dc1895ba409fa1ff86f1381ebdb4001a488b441f0b3faf810a435268d50c4", + "python/sglang/kernels/aot/benchmark/bench_mrope.py": "a0774041acb66396d3e188cd8cf358c31ab2cdb19f5bec4554b581b5e3f2a472", + "python/sglang/kernels/aot/benchmark/bench_per_tensor_quant_fp8.py": "839732b35aeeaa36048b381295dfd5b06fa0f636407156fce33a43e270fac9ee", + "python/sglang/kernels/aot/benchmark/bench_per_token_group_quant_8bit.py": "5e655449992ce2975a5405c02ebafffadde9e7a32bbd80f17860df4e10f91d84", + "python/sglang/kernels/aot/benchmark/bench_rmsnorm.py": "4cb3c391b21d2780d9f9599092f276d3eeeb404a8b80ebe32f529f43e6dd2b0d", + "python/sglang/kernels/aot/benchmark/bench_rotary_embedding.py": "c31671792065aa7c4ff2fb8bffb48aec3bfbed58fb4a3cf210736899942ebf71", + "python/sglang/kernels/aot/benchmark/bench_sum_scale.py": "7c88fb44db929f77f507d5d27bd3b03ec27e6c5381528c7c376fe6f70fb7dca8", + "python/sglang/kernels/aot/benchmark/bench_top_k_top_p_sampling.py": "6c2015fbb141f89ba069cfe414c15355b8cbb8a68ed0f83f8de9aca8263befee", + "python/sglang/kernels/aot/build.sh": "b7019fba7e02354680e198c5f314442f61a3f8a77a5bc783e72403c5b5dac63b", + "python/sglang/kernels/aot/cmake/flashmla.cmake": "f8a31f77098c2e2e0dd6c478a3e4cc426825d3f51f8e8615b93266cd81d6c15d", + "python/sglang/kernels/aot/cmake/utils.cmake": "a4edb2f627936c18683b336ac8459f767c2abfabf84eda3e5d2a1dbf7e4edc25", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce.cu": "12b0101f40b045085a039e3ac4185e3d83547da8007c2a2a09d4d0b59c6785a1", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce.cuh": "1b9bbffb6592b5092caf83152d7277f8f8b935ea68ad3f73c4e88646503a2fb7", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce.hip": "bb461ec96c6a7e2b5dc26cdcd19e4a28452d100faae0be93653ff4cb501f8e62", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce_hip.cuh": "36a162c91ee3b302905936b337f195766c47bfc57365d0d9d264301758c6eb97", + "python/sglang/kernels/aot/csrc/allreduce/deterministic_all_reduce.hip": "5653edd5d3aa9e561ed64494ce6fb082164f62ae8652f681060dbf734b7fe66a", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce.cu": "3ad95ce83a50c546688b82fcb24038afbca9cfbedc62485e71eea2ee044d93f3", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce.cuh": "7dece95138d7d4494459ae346a3df7bcba33def4af3186ad34c6056f98331769", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce.h": "9a522ee8118418abaa414e637ad7d8913b89a8cd10c172096696bb8a24c49faf", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce_base.h": "f2f8b90c1bf6c2a02deb68c0b87899ef552252fa27d173b590b863b1102966d2", + "python/sglang/kernels/aot/csrc/attention/cutlass_mla_kernel.cu": "d22ff738ffd4e814fd0215f928385aaa959b121595ace21e55d22d2884694606", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/device/sm100_mla.hpp": "f411088638eab8ee0d22d7160779fe0c0830006c0184e09d3298d140df0bdbd2", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/kernel/sm100_fmha_mla_reduction.hpp": "01b0d650bbbf16b0d150ea634e5a4e92dbfd37d0a442a9b88701f15c1a32b929", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/kernel/sm100_fmha_mla_tma_warpspecialized.hpp": "644c75a7cb55eed77ee85b8b05cd784dd8aa9e80b9944e640e40a231a7f42231", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/kernel/sm100_mla_tile_scheduler.hpp": "e664316462e86130992aa56675efece67fc0b10504550d686f2257a29f392d60", + "python/sglang/kernels/aot/csrc/attention/merge_attn_states.cu": "9616eeea04989a033d4c26cc37887ecba926841d59965f2d443bcfe53038c5a8", + "python/sglang/kernels/aot/csrc/attention/vertical_slash_index.cu": "eb0e6cf3b48ead871cd662de53ae240c4a3da4bf07e9fe1db0e141ec08bffbed", + "python/sglang/kernels/aot/csrc/common_extension.cc": "7952111e8d8ffa20ca51e625f6e713eb93ff3b08f4a6f9bfcd482954b19c0520", + "python/sglang/kernels/aot/csrc/common_extension_musa.cc": "7048ae3e73d91f7fb8aaf83ba4fc26ce498ce555396bef8afe748fc224378d95", + "python/sglang/kernels/aot/csrc/common_extension_rocm.cc": "f0eb606c3d889206790c9debe54e8610f87cdeaa5dd618fca89a55e66e792eb4", + "python/sglang/kernels/aot/csrc/cpu/CMakeLists.txt": "606b7db5e872f2672cd1f156c89cd1514b21602c2c8073dbe6a14d8a3197fe1f", + "python/sglang/kernels/aot/csrc/cpu/aarch64/gemm_int8.cpp": "dbefb9838d6f10525de74e7c00b2d8b9cf94a95129352bdd636258128414418d", + "python/sglang/kernels/aot/csrc/cpu/aarch64/moe.cpp": "dc131c60f62c90d708fcf54bdb3b1a920c63697b16290ca508a8e3d58510e931", + "python/sglang/kernels/aot/csrc/cpu/aarch64/op.h": "f027911f459726a2d141c242b9fd15193928dbf81aa04c3259e80ac5092aa007", + "python/sglang/kernels/aot/csrc/cpu/aarch64/shm.h": "ebc2f3b2901168505609a51a9a95e76849546169e9a8dfd31eeaf6c9961e58ec", + "python/sglang/kernels/aot/csrc/cpu/activation.cpp": "85814e5f2cdc8396e958f8dbffa274b46db63d1e86c551f52b2db62b5b30cf1b", + "python/sglang/kernels/aot/csrc/cpu/bmm.cpp": "41d34a5b54926cc2ca769af4b4297b67ecdd25c7bcf51ac5720dc09297672b31", + "python/sglang/kernels/aot/csrc/cpu/common.h": "65384338e96d0c596a92ee17fc28ea51ee0e8c3b8832742327a7c2f0362b0783", + "python/sglang/kernels/aot/csrc/cpu/conv3d.cpp": "a167ebb92a6eef845dab2959f2304bca6b5fea62f6579b4f3df2b328537537a9", + "python/sglang/kernels/aot/csrc/cpu/decode.cpp": "c723317aaaf49b1c689c86313a85d1cd37caf7824e4f498429701cfb4c573dd0", + "python/sglang/kernels/aot/csrc/cpu/extend.cpp": "413e617fb3fe74ebe114730b4ef2aa560bceec5037f29dd740fc4cdc1fed663d", + "python/sglang/kernels/aot/csrc/cpu/flash_attn.cpp": "8f43a9cb15e3b9b9ec290c6ecb060f2f2aea16cb2bc46748b096702bd6904932", + "python/sglang/kernels/aot/csrc/cpu/flash_attn.h": "b4fe6bfab2545db10e104989d2f9b5686d5648fbc8740e3ff8aeffe4e3807aa6", + "python/sglang/kernels/aot/csrc/cpu/gemm.cpp": "82f2fb0b47e7d70247f83d4eb461dc804530706e2b6f629160b04cb6df175dca", + "python/sglang/kernels/aot/csrc/cpu/gemm.h": "b5b24090f2c17bce33250902942212008fa8ec5e69a163693b6aa8d990c7c7f0", + "python/sglang/kernels/aot/csrc/cpu/gemm_fp8.cpp": "db88e0528acada85b4c2c76e051e857663559a54d24a1b2bb4ee4165ed1faeb1", + "python/sglang/kernels/aot/csrc/cpu/gemm_int4.cpp": "ccabaffb60f3e70c66c98dfaa13109d241d207c528e7fce79570bd42d9626e0d", + "python/sglang/kernels/aot/csrc/cpu/gemm_int8.cpp": "bb57e5ce69c6bcf0e22d6fb934168c4dd680dfd666307c19f8911673ca6b4311", + "python/sglang/kernels/aot/csrc/cpu/interface.cpp": "0098034a6959b3c25db5896d32c16d8c605fe6e73ae91316498e2d3093428c40", + "python/sglang/kernels/aot/csrc/cpu/kvcache.cpp": "e08fd253f6c61989c714e01420fcf80b322714e958d7dee6d239b20891b9f310", + "python/sglang/kernels/aot/csrc/cpu/mamba/conv.cpp": "8a2a6eee0c6d83e3622ec5f74019b24cdd48f16dca9ccacc89d94ce4a6862efe", + "python/sglang/kernels/aot/csrc/cpu/mamba/fla.cpp": "415c55a0f61bc87073b7ea414e5315e20f8df9fa5542670ef2ad9894847b34d5", + "python/sglang/kernels/aot/csrc/cpu/model/qwen3.cpp": "a232f51d423ff7d88d5624777f3f6567b25c8458faf17a465a8a42a614c687b7", + "python/sglang/kernels/aot/csrc/cpu/moe.cpp": "afaed65c3b6c31855a5cc4800a4bfa240c525d73ebbe6e1fad430bb4594c15ae", + "python/sglang/kernels/aot/csrc/cpu/moe.h": "7b4f9244b5eb2d8d103fea74df8d15929073664aa87eddf25bcfbf276cd5d3b3", + "python/sglang/kernels/aot/csrc/cpu/moe_fp8.cpp": "bb37c7f2771f99202e2e72397d822e9caaaa598d8d53a84cd7ef158275c8b1bb", + "python/sglang/kernels/aot/csrc/cpu/moe_int4.cpp": "5401578cb03b5da19c713def8aa7a747e611093493c37a76e5c521dee9f6b624", + "python/sglang/kernels/aot/csrc/cpu/moe_int8.cpp": "6a3f61e38f1863381cfd9f3a2bda123945f9a062398fc1cf462bebc6be94239e", + "python/sglang/kernels/aot/csrc/cpu/norm.cpp": "6a75bcc1e1b5e94f75cbd8496a743f4abe808a5d09eb4108265e10329bc13a50", + "python/sglang/kernels/aot/csrc/cpu/numa_utils.cpp": "32bdc91aa9cbf9fd00777adb19954a0a10952e8d46314234c718ed75699c765d", + "python/sglang/kernels/aot/csrc/cpu/preprocessor.cpp": "410442288042cd40bca0dc19918cf587d2572d3dcb4e70d796d9b126dfb9b81c", + "python/sglang/kernels/aot/csrc/cpu/qkv_proj.cpp": "1c5a16226a392583d5666e73e96f29472efb5c885b4033b703d373e5ffdb836d", + "python/sglang/kernels/aot/csrc/cpu/rope.cpp": "6bc1264bcfcfd25663db5e6135d30fdecaff10382286655588d7c7f5dc5d2406", + "python/sglang/kernels/aot/csrc/cpu/shm.cpp": "f5249b7279391a710178e3fdd8192b5e9c9a07f68535fa66fc5af5a9926f1b4b", + "python/sglang/kernels/aot/csrc/cpu/shm.h": "c034540e6a55470a679177ca4d53425d7de821e1342e10e97762008e75cae379", + "python/sglang/kernels/aot/csrc/cpu/spec.cpp": "7459e239ce4a2f35d58c962b36adafa5884f4259ee99f74b4065eee36d51dc73", + "python/sglang/kernels/aot/csrc/cpu/topk.cpp": "a67c7b12b57d8e1631976d2a167acd1609ffeeace4f3fd336263ac8bf1ac085f", + "python/sglang/kernels/aot/csrc/cpu/torch_extension_cpu.cpp": "5976e8571ce8bc074431e4230d85f7defd46bf1f6bc725404b19853980849a0e", + "python/sglang/kernels/aot/csrc/cpu/vec.h": "72d9318916091d8372c7e6d0a6e69bd71817440edc98eef80f463a5449a1cf04", + "python/sglang/kernels/aot/csrc/cpu/vec_pack.h": "9487659e2354abf11ab2d989f6028fc977c356949eca27e315ba28a97c2df227", + "python/sglang/kernels/aot/csrc/cpu/x86_64/shm.h": "5d52546edfdf191ee10f84d2f87bf44f4684f7fef4f8929a280772fe20d19c94", + "python/sglang/kernels/aot/csrc/cutlass_extensions/common.hpp": "5de164ba11f88ce97abf986b0a856a72b95564ff6079d0541b75c5d38c545ec1", + "python/sglang/kernels/aot/csrc/cutlass_extensions/detail/collective/mixed_input_utils.hpp": "5e6c0d9a009a87677cb6958c41f8d9f371714beb0978d172ce59519bb38f8697", + "python/sglang/kernels/aot/csrc/cutlass_extensions/epilogue/broadcast_load_epilogue_c3x.hpp": "4f342e9ab7305df18424d859c4aa25a6811d3c6516dcaa79a15079621b6c6913", + "python/sglang/kernels/aot/csrc/cutlass_extensions/epilogue/epilogue_per_row_per_col_scale.h": "e28464d5dbd99c91a815b3dce5c12ac43000487fc8c87ea350253caa383c6b7a", + "python/sglang/kernels/aot/csrc/cutlass_extensions/epilogue/scaled_mm_epilogues_c3x.hpp": "128ccc10afb20f0b4493cb0f7d076fb647e3396ebeae8524b167d87bdf65032d", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/builders/sm90_gmma_builder_mixed_input.inl": "a55bf4d13931215540082d2b3e9d31f5260e284eb7246e83d5a4549095161ca0", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/collective_builder_mixed_input.hpp": "0a88dd2755576dba7ab85c9c175efbd2e5e41735443786c9c1f50b660e511f94", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/collective_mma_array_mixed_input.hpp": "c177521617b5626ab1c1ac05312d284f815db68eac2fb348fbae08fee18c7690", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/sm90_mma_array_tma_gmma_rs_warpspecialized_mixed_input_.hpp": "3646b448374d4e2bb35c29b64b00cb4a2ed11ec2086f01fe8a8ef78e13f1bfb3", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/cutlass_gemm_caller.cuh": "cfcb02916adbeb21878a5dacdd20b6b06bd24f9a6ada3f95254bf0e667e2b89d", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/fp8_gemm_sm90_dispatch.cuh": "549d3c1c5c13d67e7309cf50610a51c9485eb181b3a17423247287abd1a0b038", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/gemm_universal_base_compat.h": "468650577a2d861baa3fe2e20540003fcfc362742c1c53836a7cce44f32c3b4d", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/gemm_with_epilogue_visitor.h": "28fe0ba488957b5091fe43dcec6a4379ed95afd449b63437a61dd683d76e6cd4", + "python/sglang/kernels/aot/csrc/elementwise/activation.cu": "dffb5a9cbbb4d26a75e7e8aea0c0acfa2e68c64158466854fd6d54262103a7d6", + "python/sglang/kernels/aot/csrc/elementwise/concat_mla.cu": "f41395045b483ac3528e46a1d80ea9cfbf40d744123db9dfbfc011189a37addf", + "python/sglang/kernels/aot/csrc/elementwise/copy.cu": "a194cd8cd7756453781f9b719794e73ceec3434b794fbc6528e1be548d6f76c0", + "python/sglang/kernels/aot/csrc/elementwise/deepseek_v4_topk.cu": "c9cb9025efaee27c88c257fef446d9d17b40fd9588f5a1d928d62d8a1d4a3067", + "python/sglang/kernels/aot/csrc/elementwise/dsv4_norm_rope.cu": "b7ce890d1edf72b627088f8de94912ca6f63f82bfe3df752530ca58df0a7c538", + "python/sglang/kernels/aot/csrc/elementwise/fused_add_rms_norm_kernel.cu": "91173e4c7d1139209dbe60ada9f6c160cc579e64d6e2bc6093b19489f194d893", + "python/sglang/kernels/aot/csrc/elementwise/fused_add_rms_norm_kernel.mu": "14f903ee5446cc4ed670a928b2050cac50cd9a2b125ff37fea1aaf942e6fd5f0", + "python/sglang/kernels/aot/csrc/elementwise/pos_enc.cu": "bcb566f16d4b280ad970929cf588b887670cf9412cb44c45ca6ec6487c123017", + "python/sglang/kernels/aot/csrc/elementwise/topk.cu": "f899cb9d2db331f2315e84f89c48716863870082f76ae65428ae4d865b0205d7", + "python/sglang/kernels/aot/csrc/elementwise/utils.cuh": "e1f8762cebe626fd0a4014db77af2dc3a03a754fb086344bd8df35c5e9d34987", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise.cu": "1588e12f0577d71c8d0444ee93bea01d66aef4af1985ee41dd7e0d343437114b", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise_functor.cuh": "20a9ff701eb620020b543571c4a308b73aabae0adeb6b02ed4eb6795fda8279c", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise_launcher.cuh": "1e74f78bdcdde807ffb4a31a96d9439360f1fb709812e157a2c0e5feea81cdae", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise_traits.cuh": "2b4dc917c37799228adf58881815ca2307e527b8211df5c52b698ab297a29131", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled.cu": "62351cae829471d4e2f1140c284ef71fdd9b2f2ac9739e08657d3feaea73cc43", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_functor.cuh": "7b04f268f0a05a931f0c666d139cbdc3b54a427b556357514162821839cf7bd8", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_group_quant.cu": "7a682171f357b4eaefcaf94aca7c827598e97c6eadeaa3120068c82d61495379", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_group_quant.cuh": "8a386c3336f37540b8e0b91c87f0f21eb7f7de3e48b02c3b8d19456691aaea23", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_launcher.cuh": "aca30ab23b21cb1c3805f3b33a00f9b4517d7307e47f38d534c44e7cadbb0008", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_traits.cuh": "1c4fbbc2d1e5c8d605cce7b46d59c56675f7e0172fc35fbe5cd3582db7dab9ff", + "python/sglang/kernels/aot/csrc/flash_extension.cc": "9c237be7a8fe53b3785472c6ee1fdb0636023d8006cab281bc565389e7dfe78a", + "python/sglang/kernels/aot/csrc/flashmla_extension.cc": "aa4b35b211026318df6a5481f57ff32741bb90d9cfb955b8e83eaf8dde93dd77", + "python/sglang/kernels/aot/csrc/gemm/awq_kernel.cu": "06bf26e1fce3ab5a70fb2f66a95d51b6461a2fdae11df5f423a3353eeda397ad", + "python/sglang/kernels/aot/csrc/gemm/fp8_gemm_kernel.cu": "681c8afd21ddd78fb656ce9643b4988743faa64f178f48d55b87dfb8be9217ad", + "python/sglang/kernels/aot/csrc/gemm/gptq/compat.cuh": "4a2d33e68e4930293d32475a6f57edd5e42d343dd642cbf1f5a492558e505374", + "python/sglang/kernels/aot/csrc/gemm/gptq/gptq_kernel.cu": "6f726c7687d5721d645759dae892b70ccf18cccc929cca31f5f0b1fae986de64", + "python/sglang/kernels/aot/csrc/gemm/gptq/matrix_view.cuh": "efb127be9bbeded2111ecefd4df9d2b5eb625c0ffefab904cef21ef1b1657aa3", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_2.cuh": "1a706e6266736241be7f851697c4c4ecd685c9f0b0894436530eebd81761000d", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_3.cuh": "f7fae2447ef01c66d3b62758a860e041ae3b6477714846a8be5834215aa23a51", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_4.cuh": "7fb89f88bc54d7df14293c272694bd984e987f62d569ab7408c484d403058494", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_8.cuh": "a65c9207b4dd8815680cf525155ead154b3ce098251073adb6138b876ff56f7f", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_util.cuh": "3a0712467f6daae5e3ab86027091048aeb5aae39a0213b0b44e361d3393398c7", + "python/sglang/kernels/aot/csrc/gemm/int8_gemm_kernel.cu": "e328045120e3c884e33bb905ab646df6cc0a1544ffb7ba838c945136fea0c2f3", + "python/sglang/kernels/aot/csrc/gemm/math.hpp": "b80a3ffbbe5944c865331da95261696e430981b623d447adf24f272241104f59", + "python/sglang/kernels/aot/csrc/gemm/per_token_group_quant_8bit.cu": "fbc0d20e0bb890b0c84b665c92069399e2fd9ae6d9ab6fed4487ddd9ae43fc54", + "python/sglang/kernels/aot/csrc/gemm/per_token_group_quant_8bit_v2.cu": "66c638e069dae59e6c1f9a618299199d86f0963eca57cd26517a71d4596bca62", + "python/sglang/kernels/aot/csrc/gemm/per_token_quant_fp8.cu": "c8a3e755dc165cecfa09232bed58e8b36010061f050acf2f82722b75c3c1edb8", + "python/sglang/kernels/aot/csrc/grammar/apply_token_bitmask_inplace_cuda.cu": "72610dc5e2effa6b8e46518dc398cd9320f251a444b1a03026f44d80d70ce194", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/flash_api.cpp": "cb99aa9ae74fe2514e4103d76b549a57a1b3b0805ee8823792bc63c547d74f59", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/block_info.h": "338f8246268db78724cbd7720c553247b302ee6002db1ba8b643ed4586309608", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/dropout.h": "02efa0d8584b2ab0793a9e40c69d13d49ee07b66f91f573f56ab42786af9e4ec", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash.h": "72c173aba8ffa52627ce9ed74c82deb03dc3f53c61a380825fec277e4f07de59", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_blockmask.h": "e0fb10597a7e22170d3e6e4e20b7aabc24543f3f24bd8a2f4369cd6236478a9e", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_kernel.h": "768fc27a85ac26c311def3e5c3c7f49cf0df3e4e0fe60ee00347f93bb3b97371", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_launch_template.h": "f8ba739ac0af00da53a7737aa954b4ab693690cfe23ff28ae8e5770985eb6c51", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim128_bf16_causal_sm80.cu": "206684211db2830b101122c741da0d0a7cf96a1219ae1a79012fe9fd0e04cd4f", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim128_bf16_sm80.cu": "ce345f08360f2112b4e1cc3646bf1efaa4afaccb4a12db6cd661ea84ea8868c8", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim64_bf16_causal_sm80.cu": "bb1d25fffadb5393500e2502a5cf3650720187ecbe227f9a174934364356e2c0", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim64_bf16_sm80.cu": "bf75ee560818988da58a2cbdef13e60185dbcee9577f14e0e042ab3f4f4cf385", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/hardware_info.h": "3adb689a79f653b97b19ad0cd5a25d8b44d71dda43c55cf774ca9f698d61fe74", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/kernel_traits.h": "440f8322a0e9b2b07c165fd0b62360bfbc28e1640944b1b5c54dfe31b6fee367", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/mask.h": "50637532c664222e24d0e42d916c3bdd9382e05ee8241d0bb30cdee85c929493", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/philox.cuh": "131c4da3f06a3122242878bed3574e2e2353ae6d4eb228aba5028204a5232a4b", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/philox_unpack.cuh": "14d35e2e51b5f248d7007d4f783c46c29f5803444ba7d4e30204a50fd6811ac5", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/rotary.h": "f616830da4716124b6962eb200a3fb5c26e22bf4b13c0aa7ada6f17f73adae49", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/softmax.h": "8d61de3d1cdd8dbffd506c63f9231626b133b2db54cae93a71f3607d3753d691", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/static_switch.h": "b873eca73e4826d2da525405a80a16fcb23cd6a416c2b94b99c35646ac4f8ffc", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/utils.h": "c7d40d5605abb766478d1f2cbb2691eabcf376a4dd03d609732eb8b6671583ba", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_extension.cc": "968bdf8e0b951ca19a97c2ae9c36e9c938dc7df1fc6ff92e7e6a2d03e11fce92", + "python/sglang/kernels/aot/csrc/infllm_v2/max_pooling.cu": "3376def6b26d2f527e51adfad1a8dd8f5f8fa22f29dd3d6352e765d0f043cad4", + "python/sglang/kernels/aot/csrc/kvcacheio/transfer.cu": "9e45665fcb3652683948754449f4d31e91117f53874bedd1285d67f7127b285f", + "python/sglang/kernels/aot/csrc/mamba/causal_conv1d.cu": "93421646032517ce921319ea86a78086de164de5dd7c7fc95ddaa075d2c1c8c5", + "python/sglang/kernels/aot/csrc/mamba/causal_conv1d.h": "2e4bfde82f89142647170a7812270b42f487627c6032fc735da52ecb43e006f7", + "python/sglang/kernels/aot/csrc/memory/weak_ref_tensor.cpp": "f8aed1facc79cd1e7f15cec7e8b5ece97cc12d0569a4183a0a69925ed5b24d80", + "python/sglang/kernels/aot/csrc/metal/README.md": "fe9699f735ffbb368fefb831a7a64b27ee5049b21cd9656493a8de53e696e697", + "python/sglang/kernels/aot/csrc/metal/rope_pool_fused.cpp": "2df146a113b9590d1cf575b65af28a0c454ac2e59365b90abcadccd50075e116", + "python/sglang/kernels/aot/csrc/metal/rope_pool_fused.metal": "b35b95a18d956288360b571a9d08cb3765dff377df7c202d39385ba9bf8f50d6", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/scaled_mm_entry.cu": "96c8953053bd1206bbe90f57e43ca6ae5f5467e561dceba7c3bdf9cbaa08a93e", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_get_group_starts.cuh": "f254d94fdd77acbc221a587f9e82589c3c9cb85ab45d6cb4ff339a0e783e749a", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_grouped_mm_c3x.cu": "5569ab6a80fc6d9fefbc986edbb61ca67bd9c44b0c7be453916aaf163aaf78ec", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_grouped_mm_c3x.cuh": "e8dae3c98e24e4285b22efd97524ba612b1706e089707792ca0c2d9c1a5c1d41", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_moe_data.cu": "3198cea71295f8dc474e9ea0bfb837bb76ecb4fa2988e6c6e4593c4ca53af6a7", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe_helper.cu": "44a65aea73b94d50d7ae15aadecb27df8907139f83ffba0c2726f50f2929773e", + "python/sglang/kernels/aot/csrc/moe/fp8_blockwise_moe_kernel.cu": "b812c2972bff64e1571d22d7313efbe330c3322d06cfd25e50b098f418a3fdfb", + "python/sglang/kernels/aot/csrc/moe/fused_qknorm_rope_kernel.cu": "bedd99015a68a39175c20b07c917046d7ee25b268aed9a998fab01a3423455b2", + "python/sglang/kernels/aot/csrc/moe/moe_align_kernel.cu": "4f1afca3ec9687272213e4dcae2570fbb0ff98e418a0d73e542850d245969feb", + "python/sglang/kernels/aot/csrc/moe/moe_sum.cu": "d34f734c50db73d52100a03ff0c958f7216301f376f8aa4625fe810ea002993c", + "python/sglang/kernels/aot/csrc/moe/moe_sum_reduce.cu": "03717a4617562fb7704854dc276568c587e998f248b6addcf25e12d9fe2ffef8", + "python/sglang/kernels/aot/csrc/moe/moe_topk_sigmoid_kernels.cu": "4b8eadf84561c8b71c31893508caacc2c132a15510c725385616775a59e16ce3", + "python/sglang/kernels/aot/csrc/moe/moe_topk_softmax_kernels.cu": "e1ba39d23e79b5a209f8ea6adddb283170055f1d5523e63298a8aa1e70ba0e9c", + "python/sglang/kernels/aot/csrc/moe/prepare_moe_input.cu": "811aa0a3bb94ceb65cd2d156a79d8355e1477c35177ef0b60fe3a74e90b26be5", + "python/sglang/kernels/aot/csrc/musa/common.muh": "23faabc0b5750254f7e36666677aa5c7d13dffde67444939f8af4b4dfe38d7c5", + "python/sglang/kernels/aot/csrc/musa/dtype.muh": "49646e157e5b9d1adc5123c90d51bf72f5b0e21e9cddf0204b6389d865149e39", + "python/sglang/kernels/aot/csrc/musa/moe_gemv_swiglu.mu": "35d8a2e327fd4a27f77e9043a3e29c29efd21a792d64b30887c1a0826b9e6268", + "python/sglang/kernels/aot/csrc/musa/pos_encoding_contiguous.mu": "a29f93eecbe8364f7553ec33957d597b03caaf068095b7806c94bc1a26a97dcb", + "python/sglang/kernels/aot/csrc/musa/ternary.mu": "fa932c991708954f91be0f1027ea0908d801f5d001262234084bd7f4cb28cd85", + "python/sglang/kernels/aot/csrc/musa/top_k_top_p_sampling.mu": "789b4a6c5cb4db331d3dab2b27f27a0e6d45a948e84674bb4a01ca20b4f6219c", + "python/sglang/kernels/aot/csrc/quantization/gguf/dequantize.cuh": "e43f4899fecbb4a3f0f9bc1cf4ba9d5febed22c109caf8ed4174b1c3f2d17aba", + "python/sglang/kernels/aot/csrc/quantization/gguf/ggml-common.h": "9bd236e5116402243ff4b243fb8a8e42056ff1ae825be12a7b6da2fb108e8698", + "python/sglang/kernels/aot/csrc/quantization/gguf/gguf_kernel.cu": "9905943cd6987a139bf75753b0d2480bcfc5396f8cc9f0fe08d224451f098f32", + "python/sglang/kernels/aot/csrc/quantization/gguf/mmq.cuh": "442bb32c4becd009c0925811d800d52378a5c41188ab2b3958b82033ccd02a17", + "python/sglang/kernels/aot/csrc/quantization/gguf/mmvq.cuh": "ba9b2f97e6ba383f0650b3833311e28a7906f2de1fb98635c09f3e268abf253d", + "python/sglang/kernels/aot/csrc/quantization/gguf/moe.cuh": "6f96c93d0d35989037422e4ae5cf88ed7d3a01da8ce6449649d2ee109700c1ca", + "python/sglang/kernels/aot/csrc/quantization/gguf/moe_vec.cuh": "99573567e402824b589a10362ec9e820b6072e1ad453e739de8fc2f4557d60c1", + "python/sglang/kernels/aot/csrc/quantization/gguf/vecdotq.cuh": "7c544d85fbcd3cb6ddc1c67ff6ef1315e390d62cc92a4af0021f9690129adf67", + "python/sglang/kernels/aot/csrc/spatial/cuda_utils.h": "b2373c5172585e7ed3f289d6b95e5c5176db48bf0a5c9f155b1aa9fc7b76e0c6", + "python/sglang/kernels/aot/csrc/spatial/greenctx_stream.cu": "de20703fc8a6f359ecbcfa2d91f6556b61fa94cc605e2d606a3e075d0d898305", + "python/sglang/kernels/aot/csrc/spatial/greenctx_stream.h": "35982dff2acf36ef001c05fe220ede5984e1ad3606f0733d520f5ba4b4bd4cd5", + "python/sglang/kernels/aot/csrc/spatial_extension.cc": "5f4f6abcf0f2f47a49bd17c9f238f6cafe1824cf1b9eca4d098c4b971499fb7b", + "python/sglang/kernels/aot/csrc/speculative/eagle_utils.cu": "734d7bac46bad97d8c6446234c4875f4e8d7bc2816358eed56847d926b8ddaa2", + "python/sglang/kernels/aot/csrc/speculative/ngram_utils.cu": "d5afce91de182f915cb9ed3fe6d02c0e3c31ca3409ed87202fbb0e9783f8edf4", + "python/sglang/kernels/aot/csrc/speculative/packbit.cu": "9484696972ed750f8737a0512eb9246090383f7b0793b38b06fdfb85ecaf44d7", + "python/sglang/kernels/aot/csrc/speculative/speculative_sampling.cu": "a572115a4467989a78a3833c2b47b4097886d2d2a7c31391b714b8adcc394413", + "python/sglang/kernels/aot/csrc/speculative/speculative_sampling.cuh": "2ba289074e83f1df6cefa219b674b08c3c20061d0b5b328bf2681be7b88cbe2e", + "python/sglang/kernels/aot/include/hip/hip_act_and_mul.cuh": "854254686226b67592f6eb8562fdd8af48f8be8f09bc703ec08228cb09c73003", + "python/sglang/kernels/aot/include/hip/hip_math_def.h": "c8f8e302aebb1b187355f39d3dfd63703618c7946b66a2e5dee252881e36a69c", + "python/sglang/kernels/aot/include/hip/hip_vec_dtypes.h": "a1267963adc88ef49bfa017b4bf24fde8f4848c93e0ab7da5c5a3a4d55155aee", + "python/sglang/kernels/aot/include/hip/impl/hip_vec_bf16_impl.h": "f02542bee4e9551b17c94fa37a25cfeb94ab221ba29aaaab12e72312f5c26667", + "python/sglang/kernels/aot/include/hip/impl/hip_vec_fp32_impl.h": "d53b84a3aadc4c5789beb3a8bb1bf65a3b77f09d0659a0bc3eec451bf559a17e", + "python/sglang/kernels/aot/include/hip/impl/hip_vec_half_impl.h": "4c0ad29942f1dc2026bd838d7eba9e243d8bceef8449e5d32cd8c7e6e175d6a9", + "python/sglang/kernels/aot/include/musa/dispatch_utils.h": "ecaccdd4d957e209e9ecb09f5bc062f81d89954464ccf57ce5a78a9d66452b1f", + "python/sglang/kernels/aot/include/musa/integer_subbyte.h": "c025fa298197df52096c40141d6ee448bae96d3e1648b75225c7826e46eae0ee", + "python/sglang/kernels/aot/include/pytorch_extension_utils_rocm.h": "e23b3520c211db5334bf9cb3977f6d6d617766e63a89eeb708474c4cdd58d5b4", + "python/sglang/kernels/aot/include/scalar_type.hpp": "16333e83eb1a6a46bcbc14fca3c49249db80083b7c0bf7afee96114f94c5443c", + "python/sglang/kernels/aot/include/sgl_flash_kernel_ops.h": "895e3d6ba3ebfbe70c49a70cc96bb3745d9c2a8a35f3b64d19c7c9e54c961664", + "python/sglang/kernels/aot/include/sgl_kernel_musa_ops.h": "f68a29838d3f39ca0db23fdc3439039f374ccef429f8252d99cbc58deca417f1", + "python/sglang/kernels/aot/include/sgl_kernel_ops.h": "c26e4df2fdb420856f18c3b28276deda346fbc0f4195b7f2066960abfae078dc", + "python/sglang/kernels/aot/include/sgl_kernel_torch_shim.h": "af561b9c374499cf463f2302f7a52d0e7af0d4039e2b1db6c73292ede3a62700", + "python/sglang/kernels/aot/include/utils.h": "442a8e60bed72f78886ad23ea478b00bd0e0a21421c845bec8b035b24c6caf1c", + "python/sglang/kernels/aot/kernel-runner-setup.sh": "a975029ef18a2d93d9edc6afd3919f45c5996d9825b731208c127994aebb929d", + "python/sglang/kernels/aot/pyproject.toml": "58c174b9a07901f09528cbc6f0bc29977b93019a1b5d4201f4012bc7d39faecd", + "python/sglang/kernels/aot/pyproject_cpu.toml": "6ef324147d97db4b5ec653c2f7159195aa1df47834b0686dbd13e08eb9259f7d", + "python/sglang/kernels/aot/pyproject_musa.toml": "4794ea61ab60e421be123b6d624a8c59f0594b90ef6b3455ddae914e9d0d49cf", + "python/sglang/kernels/aot/pyproject_rocm.toml": "d7d4d7203dbf53092951d62c0966b205fddcbb015455f55c1aa642bd8ed37d10", + "python/sglang/kernels/aot/python/sgl_kernel/__init__.py": "a912485cfac6a2f28b4407807ef66d31d05e140ad79a4b7e8a009d358c49706e", + "python/sglang/kernels/aot/python/sgl_kernel/allreduce.py": "89acec7bb9a4538a82eaaadb67057ec4825b4bd2b13b1e5508f0dc441515348e", + "python/sglang/kernels/aot/python/sgl_kernel/attention.py": "b7363f7e3a976ade65d62f2cdbddf27dc7d2659df623a3f16045780d359c37e4", + "python/sglang/kernels/aot/python/sgl_kernel/cutlass_moe.py": "38a92f0897ab45242ec2e75e3faf84f8b5668abcb7a4d894c58c2de2b4f3b221", + "python/sglang/kernels/aot/python/sgl_kernel/debug_utils.py": "096c0dd0dee4fd57cbf00d6b0fa734f44b25403d627f40bf95fdd7e26fd1759f", + "python/sglang/kernels/aot/python/sgl_kernel/elementwise.py": "5af8a849dff586835b679618c568940afe8d6859b329268311ff5538f1b7356a", + "python/sglang/kernels/aot/python/sgl_kernel/expert_specialization.py": "c03ff2d24672ad0656870387671437c3e247a571dd39e9768cd4f40cb0d182c9", + "python/sglang/kernels/aot/python/sgl_kernel/flash_attn.py": "610747f2c68495c5f3ba67f1247f0a1b4e4f7df116e2f89cd8e8983f0271f9ac", + "python/sglang/kernels/aot/python/sgl_kernel/flash_mla.py": "7b4d4830a23b6349db5d530ba34920337e26b814b11f79c15e0c797054e26386", + "python/sglang/kernels/aot/python/sgl_kernel/gemm.py": "bcc6815ae2bd529f7aa8e0c4649557f85f4f3a30a52a0b267c516653701dc809", + "python/sglang/kernels/aot/python/sgl_kernel/grammar.py": "3345ab05c87474b7286d606a3ecd2b3216ed2ef1a4dbde3781e597d6491f12d4", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/__init__.py": "80528ed06dc2d02295d55cd9e906574bc28a3637bf36ce993d9b58029656c40e", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/_loader.py": "2ccca1059382518cc0d8b9057aed9c178924fd9bf34ce453e420002254437ef7", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/attention.py": "98d9b084a9c7cff0902fbb7e5e8d6dc6301b517245b47cb15f68916e4a4aed24", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/max_pooling.py": "72c09227a77aaf532d7276a1d9438e19060cf211dacb66c734bdf50273e92782", + "python/sglang/kernels/aot/python/sgl_kernel/kvcacheio.py": "76378182be4f3bf06fc88acaa7a4a5803d302cc6279c4cb2a75960273a988dd1", + "python/sglang/kernels/aot/python/sgl_kernel/load_utils.py": "e7db471562b3fa3748af4793fc1647f23d9dd2142249d6cccd6bbe671a38c5c2", + "python/sglang/kernels/aot/python/sgl_kernel/mamba.py": "451bcf76c35cc191eb440df80918920b52abe14f39baf6b6d225068e9a008e6e", + "python/sglang/kernels/aot/python/sgl_kernel/memory.py": "1d20daaa7336a20049c310f86a18ef5bd5f39844541cc91c5b66288375383c97", + "python/sglang/kernels/aot/python/sgl_kernel/metal.py": "b4851811dac0bcef891655288617f9a0cc3288995cb1739361e8d5abb03266ac", + "python/sglang/kernels/aot/python/sgl_kernel/moe.py": "7d2b3862905962127f89eda91a537ab4e522dc251cdc404631762f166a57bbf4", + "python/sglang/kernels/aot/python/sgl_kernel/musa.py": "b9efc53b00c0b47d85026aad0a2ae639d74ea66493cdc80a8b62902e5ef5acf4", + "python/sglang/kernels/aot/python/sgl_kernel/quantization/__init__.py": "a7d723f109f161665b6b741016e9dbc5bea724919f2019e68f29054b9f94cc51", + "python/sglang/kernels/aot/python/sgl_kernel/quantization/gguf.py": "6c924e2261309dd8ebf92bdbef4b71a00a2d716faf7fb23656011dbca7f35fce", + "python/sglang/kernels/aot/python/sgl_kernel/sampling.py": "80f01a3812ff7be617c169ab82828a09fa4f22969c42cdcaedf3a01c628bfdf8", + "python/sglang/kernels/aot/python/sgl_kernel/scalar_type.py": "ca0c5beb5cc3dd2b3c02b51dfd75d2fd9f8fafb143e063be855f8d3f4012b305", + "python/sglang/kernels/aot/python/sgl_kernel/sparse_flash_attn.py": "9211e2a98615c98e0edc69232fdccb22c8a01dd2c4e822c099e2b9e689ab5561", + "python/sglang/kernels/aot/python/sgl_kernel/spatial.py": "687898eefeb3b267ce9c0476b2877b72ff7fa8308d9cbe369294fe9893686aa3", + "python/sglang/kernels/aot/python/sgl_kernel/speculative.py": "2af216aec3e41d0c3240dcc131a0017ff734f93008f99d62d4ac30d06e1f4b46", + "python/sglang/kernels/aot/python/sgl_kernel/test_utils.py": "615d5d2124c69e20504223712ec6a12a93d4da6ab97b502f5f198209faa848d1", + "python/sglang/kernels/aot/python/sgl_kernel/testing/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/aot/python/sgl_kernel/testing/rotary_embedding.py": "3300617a366ad038b1d22002a4d9a66f3fcc04ac4eed484e4044f94c3d9c1c26", + "python/sglang/kernels/aot/python/sgl_kernel/top_k.py": "567c1c5725fad322b6e7b2d54b216a48740c9c66b58af6ed8f45a944c67fda56", + "python/sglang/kernels/aot/python/sgl_kernel/utils.py": "cc778f3a0da90fa453f684086b32c9d426fad752787f899b584431f086e13f68", + "python/sglang/kernels/aot/python/sgl_kernel/version.py": "99bedc65616d05360f828b675ffd6801969d1484cb1eb017c134acd846f576f5", + "python/sglang/kernels/aot/rename_wheels.sh": "868e715de2c2947ebaaab15ee6b2017ee2eff196630732ecaa74fd6e218fbf51", + "python/sglang/kernels/aot/setup_metal.py": "b7a37c3ba45d36562ffc75b3404044db9d38aa1f8a4c53fa0fc1121f6a828bc8", + "python/sglang/kernels/aot/setup_musa.py": "0ebaff2ca7a3b0aa518d98d45a43602f3ff965eec7f51f5268493439c76a5679", + "python/sglang/kernels/aot/setup_rocm.py": "87a8171878c36d18452d24a4efdcf9eb1cf09bcd1692042a788673749e6eb4c5", + "python/sglang/kernels/aot/tests/conftest.py": "d915f91707370a962671a554241a2bbf96ba3fae0c2a7a6e3d2aaf159d6a2f61", + "python/sglang/kernels/aot/tests/spatial/test_greenctx_stream.py": "aed5808c6fb05e60b00640e7d825f65c59f3a4e97b0e6656e8a84c594761a39f", + "python/sglang/kernels/aot/tests/speculative/test_eagle_utils.py": "198d47ad4b4f81b2f5d8a8ad4161bf857c87e86c9a2b5746291f6245ddecdb6c", + "python/sglang/kernels/aot/tests/speculative/test_ngram_utils.py": "d71a84b5cab3a98e09b92b6d6c6b5b6ecf0a235387dc124d083ca93c0b90128e", + "python/sglang/kernels/aot/tests/speculative/test_speculative_sampling.py": "f59059195c8c31159833d779e8a0bc988ca233112f65d75af24ea72d0db60d29", + "python/sglang/kernels/aot/tests/test_activation.py": "2fd80bbccd5e429138a0d163d46ba79f497d6fb947040b43d6f346d6bba905c3", + "python/sglang/kernels/aot/tests/test_apply_token_bitmask_inplace.py": "bfbbc29e342aa0c44c2646aa654f9445cf91aa2dd2d24b499d937a86a5a61872", + "python/sglang/kernels/aot/tests/test_awq_dequant.py": "2873ca279cf90b1734b7c96df358e9c62929adab9bf0f3be93bd036f2754e6cd", + "python/sglang/kernels/aot/tests/test_causal_conv1d.py": "252f9b9dd90dbbdb58360c88bafc018048b8a1c4e90b81fc46fdfef59acc65c4", + "python/sglang/kernels/aot/tests/test_copy.py": "71312e5fc1f2579a676bee1769edc52e486c95412b45d93b7bdc56d1008a0f95", + "python/sglang/kernels/aot/tests/test_custom_allreduce.py": "d2ae02bbfdd1cddf07fd1bc508d0f29094215530a12bda655670b0011beef501", + "python/sglang/kernels/aot/tests/test_cutlass_mla.py": "decea5a2a956b9e109e9c0d1f5eda558f6fb3c183eb67052385e32c8496e7331", + "python/sglang/kernels/aot/tests/test_cutlass_w4a8_moe_mm.py": "f02124611a58312fb7f9dceeeebf396a2f14ee6e73341ab7f43460925ed79618", + "python/sglang/kernels/aot/tests/test_dsv4_norm_rope.py": "9e42901508a5611132a4c95e14746395964557cb87ed56c44f6a9c9956686434", + "python/sglang/kernels/aot/tests/test_es_fp8_blockwise_moe.py": "925515f5ac77f3e9e0b303896d8bd379fec655efdc5c2c38354d6a6ed52dec8b", + "python/sglang/kernels/aot/tests/test_es_mxfp8_blockscaled_moe.py": "0843eb2853ebc8858525fb86ad9142a85594bdab8f4b247c957ec9e04369c8d6", + "python/sglang/kernels/aot/tests/test_flash_attention.py": "fd827e844ec95d5def4eb24882735c5b2b9edbba1d5beacf70b05ed847db99ee", + "python/sglang/kernels/aot/tests/test_flash_attn_sparse.py": "9f0681803e24ba629229eccaa7bc5843f9e019570fd358901926a714f87ae06c", + "python/sglang/kernels/aot/tests/test_flashmla.py": "6a50b68e252985dd01cfb24530786090a5f67f223f2613f21488ce22d88af4db", + "python/sglang/kernels/aot/tests/test_fp8_blockwise_moe.py": "157c42ae1101f32e077514acaf3c0c4c166a130d7a8bc020906db5a6ce60ed40", + "python/sglang/kernels/aot/tests/test_fp8_gemm.py": "16e23f28db3968e23553049076e6848139828543d2e78b8f30e3a651bc430c65", + "python/sglang/kernels/aot/tests/test_fused_qk_norm_rope.py": "36d4692e2e514e1638c96e3bb5bf143ba325c44fe451b56271583a69c7c3d288", + "python/sglang/kernels/aot/tests/test_gguf.py": "bc903b715cddbe06a9080f85628e6fcfaabe6e4ff0a10c6a08d71076c97f588e", + "python/sglang/kernels/aot/tests/test_gptq_kernel.py": "4c629a9dfd8a89fe08231897853f1c5d6c697d38e708cc4e3d884c2058a78315", + "python/sglang/kernels/aot/tests/test_infllm_v2_attention.py": "892f282cb77b8b80a7a1bf75a2e26f87bcf19c452fcb194cf0229ddd738c8115", + "python/sglang/kernels/aot/tests/test_infllm_v2_max_pooling.py": "43da1a8132e025def95070b081dc53a396288b461cfbf67968f6b755631a2052", + "python/sglang/kernels/aot/tests/test_int8_gemm.py": "c881c4cc6b0683b8857cae1bb5641a043b58646d70ccf6d22ae402ae4045cfac", + "python/sglang/kernels/aot/tests/test_kvcacheio.py": "48cfc734b01177d941e033e05ecf060682961b212287fb84abb78bd521602d57", + "python/sglang/kernels/aot/tests/test_merge_state_v2.py": "2d057b965a2fcbd9a7771e543b911374f7cd1ce2ab7bd7a0cd09a9b751c77af3", + "python/sglang/kernels/aot/tests/test_moe_align.py": "66a80d5dc4e874f528dc3b83e06adc3f261674b9d5d86eaf6de4b33dae5f6f48", + "python/sglang/kernels/aot/tests/test_moe_topk_sigmoid.py": "70d79d86a51976b4cdd24a2794549483f4c8164fa6dd25176fe6a316d38331c0", + "python/sglang/kernels/aot/tests/test_moe_topk_softmax.py": "2ed1ebc5cf07b4dc1d99588c2d551f9b4d142985d38a50ae0e66426224d343da", + "python/sglang/kernels/aot/tests/test_norm.py": "58f5d01b30699b221faabba56cfb8e8ce1dcaab6db227ce3734b8a3fb4bdad70", + "python/sglang/kernels/aot/tests/test_per_token_group_quant_8bit.py": "db350e50d381e3e0d44dd92128862cf4301d0d9edda09ef9658f0cc84fb0d9f7", + "python/sglang/kernels/aot/tests/test_sampling.py": "4835c5e20778b0e223893aa517ce8846955ae1282651ed5545f26c70c0f5be1b", + "python/sglang/kernels/aot/tests/test_topk.py": "c59211e1480251cdb0d4d8ecf3a05838388764bb7d8d0dd8e9bab0e7e4e7b16a", + "python/sglang/kernels/aot/tests/test_torch_defaults_reset.py": "c6f480087adb952a8a4c48d889de38f084609e3282e9e83320940ea932da8b5d", + "python/sglang/kernels/aot/tests/utils.py": "59593109617eccbd0c9a23bc52f1a167437005cddbe0576fcee904307f1e2f30", + "python/sglang/kernels/fused_op.py": "d676a11cc7a68eb4e4e3fb096454b18279719df0c681562036b9db595dd65c4f", + "python/sglang/kernels/jit/.clang-format": "ff10f2f096ddc386f50248987d484d915b9c82f142e970c7af2537baba88f9e9", + "python/sglang/kernels/jit/__init__.py": "7d3a182933356ee4a73edae72cde73251f9b4ba13b7a1b1731b6bc8acae20f5c", + "python/sglang/kernels/jit/__main__.py": "fabf3deb09e00dd8d745c1a2cd5873549601acc9b71f66619866853a24bdd96c", + "python/sglang/kernels/jit/benchmark/kv_canary/utils.py": "46c598858d164bfce232eb48bfc5916aa80e3f41fd27744ab7b282af58ae1c35", + "python/sglang/kernels/jit/benchmark/marker.py": "7fbf26e2007cea158de50a593efcf8ef8ee69e60b509cfd6df89156eaf12bc5a", + "python/sglang/kernels/jit/benchmark/utils.py": "24c533e70352bf94b9a12d6185384b4305be1f4e1e1a566bcfd47fe9d1c92690", + "python/sglang/kernels/jit/csrc/add_constant.cuh": "ad1e5219cf6eb63f5affe92cb782576cc1f238d11f39c6fbaadf757b3b88fdcb", + "python/sglang/kernels/jit/csrc/attention/fixup_zero_kv.cuh": "66695df6792a2a1dc913da535cfa5df61f011ca8e553a7efaeef7f9e794cd11b", + "python/sglang/kernels/jit/csrc/attention/fused_fp8_qkv_kv_cache.cuh": "b28e18d57ce7def3e593a8f2c29364ca8a87044c8814487ca1d079dced8fb595", + "python/sglang/kernels/jit/csrc/attention/kda_fused_decode.cuh": "d0a2078431d967efd252aa8f4a003d08fce03a34b5860d8ef5b922004d11f53e", + "python/sglang/kernels/jit/csrc/attention/kda_packed_decode.cuh": "22bd2d7675b5dcdd623d4354418073aee9686951cf7a8710b27a0ce6c65e8ca3", + "python/sglang/kernels/jit/csrc/attention/kda_prefill.cu": "9d918668ab24c4c4bd9c74c193040e97af1a91f657eff8822fc94bf4d2dbbabd", + "python/sglang/kernels/jit/csrc/attention/qsa_indexer.cuh": "672290ad5594ba94e0006f73c9d1f341ba768a9adfddbc9296b94a88d4feb77c", + "python/sglang/kernels/jit/csrc/deepseek_v32/indexer_k.cuh": "18b93a66c8d194a00c2c4010059839c9a1439d36292d834b62068e6e570987a5", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128.cuh": "5b9cd573814ad422b6ea74749bf85a6d7fb572a6c8d33b706255727318b71f1c", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128_online.cuh": "56b7d8ea4c8fc3f155c0d6d40752c57b952aaa750538af39e0b6a1c2a74589d6", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128_online_v2.cuh": "8d300e8943fd6e3d7c2ccfa21e8f80489295bee411fc2f84294f8f9842ea15a7", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128_v2.cuh": "e8ee36b093eca277d2fe37f51ae21d26695e135be09da518fb82d52a17fbf953", + "python/sglang/kernels/jit/csrc/deepseek_v4/c4.cuh": "16cbbc7075baeffe17067d92ca9ff2d7bb94be6812edcece91d1b5c29173054f", + "python/sglang/kernels/jit/csrc/deepseek_v4/c4_v2.cuh": "051c7de8c9ca0c22d13215905ce99b44f2b500adc9ca7eec141f9b2211715642", + "python/sglang/kernels/jit/csrc/deepseek_v4/c_plan.cuh": "b0d792dc409ea18a8d0fe9eabe26be7b338ab86da496b588ecfb93da7ad4159a", + "python/sglang/kernels/jit/csrc/deepseek_v4/common.cuh": "793ff2ce21920bb1a62531ae5355b58a69fafd6e476d9e1dac203cbc5e261ce6", + "python/sglang/kernels/jit/csrc/deepseek_v4/fp8_wo_a_group_major_quant.cuh": "afb56b97c677475c667e0399c9b7af6c1ca222577a15a4950d57bc5acf88eba2", + "python/sglang/kernels/jit/csrc/deepseek_v4/fused_norm_rope.cuh": "97f6bb13534724cde2658a88e7dd77df12273742d241252911a44222db9b3bf2", + "python/sglang/kernels/jit/csrc/deepseek_v4/fused_norm_rope_v2.cuh": "d3215e51ee7204ed78d6800705d61ff395558e264d2e75e065b3396f6c6ca34d", + "python/sglang/kernels/jit/csrc/deepseek_v4/hash_topk.cuh": "7830147cefd0b95254242883dff567549987e50dcd81b7c6dac4a89198d260f2", + "python/sglang/kernels/jit/csrc/deepseek_v4/main_norm_rope.cuh": "133631596f649104ded59981bc2c0c51f9590bde40e8097e6c64a9a7177add88", + "python/sglang/kernels/jit/csrc/deepseek_v4/mega_moe_pre_dispatch.cuh": "715272b21652502dd619ec9e9d96c8d7b20ab3ae686a78b7ecefd45aa7b128f5", + "python/sglang/kernels/jit/csrc/deepseek_v4/online_c128_mtp.cuh": "dc5eea6ac0bc4ccc9b686e6a5dd7427fce25e750b02501079b00bf7cccc49286", + "python/sglang/kernels/jit/csrc/deepseek_v4/paged_mqa_metadata.cuh": "77168812edde134a14d98f9b6a24a140cf391c5c101addf07e716c7b02270227", + "python/sglang/kernels/jit/csrc/deepseek_v4/rope.cuh": "c599b6d5bce1f3e7cfd0422707cd1a1ad33ea676493c9fe36d73810834e88103", + "python/sglang/kernels/jit/csrc/deepseek_v4/silu_and_mul_masked_post_quant.cuh": "c3330410de115d91eb14b1f395365b9243a3403453e1ee5e0a99c3715edfbb7c", + "python/sglang/kernels/jit/csrc/deepseek_v4/store.cuh": "022addf9eece267bf8962ebd0414a2945fc6b72349bcbd35be5a45be3535cbeb", + "python/sglang/kernels/jit/csrc/deepseek_v4/topk_v1.cuh": "e0bd5e43e045d2b263b4796449e513f93f0fd50a522ed5c81ce42385850e0802", + "python/sglang/kernels/jit/csrc/deepseek_v4/topk_v2.cuh": "3b2d091c830698a6ef2820eab66da83e17788ddcc72101694850f440e1ad17f7", + "python/sglang/kernels/jit/csrc/diffusion/causal_conv3d_cat_pad.cuh": "c0091f6d158cf2ec919ed981d416b40f144e3f02ea1eb55acfaf68ac5ab55f9a", + "python/sglang/kernels/jit/csrc/diffusion/ltx2_qknorm_split_rope.cuh": "cdc91194188f11eefe18df510d54f6bf53b736d0cce3610f7484225bb5aa17a5", + "python/sglang/kernels/jit/csrc/diffusion/modulate_scale_shift.cuh": "33570b4d2adc897ed2a91d95a4e5f0e6681f8504904d699a3d9da48ebac3e7a5", + "python/sglang/kernels/jit/csrc/diffusion/norm_scale_shift.cuh": "ee74320288d630067af17dcf4bcf6c93d05fa3e16fb1e04d4f8086f8e97bb09b", + "python/sglang/kernels/jit/csrc/diffusion/qknorm_rope.cuh": "4d2f194e5100beb87ae555bfe68d9188a87b24c0ae59de75ccdfd287bfa12a5a", + "python/sglang/kernels/jit/csrc/diffusion/residual_gate_add.cuh": "19f008a703f5f0181a321628e9b62113701ae97cdfd77cd1d871c0c574047fa3", + "python/sglang/kernels/jit/csrc/diffusion/timestep_embedding.cuh": "59f4d6c7e0c470b92cc0da405db6aaef11e3092cd1b7b388e91c2031e25be252", + "python/sglang/kernels/jit/csrc/diffusion/usp_relayout.cuh": "3de2834c294e709027f68a3d526cc403442c64cae101d055565f4274c606ba34", + "python/sglang/kernels/jit/csrc/distributed/communicator.cuh": "b6aa6fa2dc87103fd8cfd32a9e7e8b822d5b28c8e78b98473fa646579ff81309", + "python/sglang/kernels/jit/csrc/distributed/custom_all_reduce.cuh": "07b0e6bec91da8f83f5c59e1f8da669e42df076f2c032932baca3bb8ab31e306", + "python/sglang/kernels/jit/csrc/distributed/ipc.cuh": "6f3aa5350b9b9daf596429b57db4b43d3584862d446d869e87cd73d38b393a72", + "python/sglang/kernels/jit/csrc/distributed/tp_qknorm.cuh": "eb461062686d3294d62637c73423b3421aacd4f70d42b5ab88ae2d2d2825502d", + "python/sglang/kernels/jit/csrc/dsa/fused_store_index_cache.cuh": "1a6d0b7b9cb9c200bfa573ed99f25c4502a0d2024400d7a2923453c4a77eaa8a", + "python/sglang/kernels/jit/csrc/elementwise/activation.cuh": "f1b56af7476695688d11bb004dc6cee144cd8922a56683a12c504c53aec26c47", + "python/sglang/kernels/jit/csrc/elementwise/add3.cuh": "ff31c39fca59586f43ed78198bfc035981dd4e49b4bd924ac3f8bc57807307c7", + "python/sglang/kernels/jit/csrc/elementwise/clamp_position.cuh": "71ed5158000a33330b8fcf8d1cb7603aa0d45f9e5c5381e4beaf652a8ee20a9e", + "python/sglang/kernels/jit/csrc/elementwise/concat_mla.cuh": "ae7e5e72f33ad0a2af0933a23a4cc46230310253d69be464c72d2fb5f46e1ea0", + "python/sglang/kernels/jit/csrc/elementwise/fast_topk.cuh": "8f2dd6ae5647f44473a1666978906581c635ebc44d4e8ff6c7977d5522ab911f", + "python/sglang/kernels/jit/csrc/elementwise/fused_add_rmsnorm.cuh": "31f906f1b51f64e6c5cf57e79f8d6acb0278ccd2547349aaf133b3fe4457bcee", + "python/sglang/kernels/jit/csrc/elementwise/fused_eh_norm.cuh": "6589eefbaab4ed170cce6bc000a49b06ba3c84bf05646d109c504d06983f420b", + "python/sglang/kernels/jit/csrc/elementwise/fused_metadata_copy.cuh": "a5ed33f509938790e0561e342ca879871133f481cb922927ba99955027d4b16f", + "python/sglang/kernels/jit/csrc/elementwise/fused_qknorm_rope.cuh": "bac3d717589496835368e3a571c7592610a8d9e43b7f25dd1d37a10b61fdd10b", + "python/sglang/kernels/jit/csrc/elementwise/grouped_gemma_rmsnorm.cuh": "acd83fd2cbd5ca4f3c6ca5362560954812ca87237b48cae80e44cb0958b849ec", + "python/sglang/kernels/jit/csrc/elementwise/hc_combine.cuh": "e251e31ad2a0bf5193abbcb0b95becc3721e26c2af69d321a517e741d35e7ee3", + "python/sglang/kernels/jit/csrc/elementwise/kvcache.cuh": "987d1a3e5d8a8a288572e31a148cebc8ab435def2378fdb828ed4e6ebf9aa39a", + "python/sglang/kernels/jit/csrc/elementwise/pos_enc.cuh": "8f77ea7925da40905fe178a038b012adcc34407c653e5a37be2cf8707a9badeb", + "python/sglang/kernels/jit/csrc/elementwise/qknorm.cuh": "ce585aaa8ed461bed8cd58424c4979204f3f346af7389918fc3594b4342429cb", + "python/sglang/kernels/jit/csrc/elementwise/qknorm_across_heads.cuh": "a3accd93f8afa05d836814f7df4f83aa8c68a807ca157c2bbe35a0a7e7c53745", + "python/sglang/kernels/jit/csrc/elementwise/rmsnorm.cuh": "52f4acbc6c5f82dabb90ac1ef80d8e030e69be68c1790583f462a9d641eb8410", + "python/sglang/kernels/jit/csrc/elementwise/rmsnorm_hf.cuh": "e20a3900bc88be6979efb4abf2f74cdc71572458e10f6be0a32ee109d9c68fbf", + "python/sglang/kernels/jit/csrc/elementwise/rope.cuh": "46780a3c1b3339a5f925f463f9589b39b95cc1f6689c3b7e3384eccc0b35ac73", + "python/sglang/kernels/jit/csrc/elementwise/set_mla_kv_buffer.cuh": "6fb00d6bfd8976292624f2889fdb353692c930422a56f348c18559985494a6f9", + "python/sglang/kernels/jit/csrc/elementwise/set_mla_kv_concat_q.cuh": "1a9173ed21bc156714a8dd7e8afb38fe231150d2ea9ee794b76bb34790692ae2", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/code_gen.py": "a98b3dd290b3d51ba9fa8ff37017f3004571b4dcb1d4775a7058999e120c8792", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/fast_hadamard_transform.h": "a172ebb9e66aef598c329a5e66198123e17663bbf8cb5b2df994f164d8eae54e", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/fast_hadamard_transform_common.h": "9142ca8c99423ae5e16cbd2016baa1d1d914c70c5fade96d26cb67c8aa1bd9f0", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/fast_hadamard_transform_special.h": "3a780812ee6425803095087b2548a26998a6e4ec8410290ee0ae57af634bbabe", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/hadamard_jit.cuh": "8d9614c3b1b2ed698242dc4241102a9d6aa5b4db06efb0c9f63057cf80c9f573", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/static_switch.h": "d5563e8b2e4d240ed5b64520d550116897d3132b892bf304e6d949042596ecaa", + "python/sglang/kernels/jit/csrc/gemm/awq_dequantize.cuh": "0269dd78d136acd8cc96deff925b02b187a2b8b86c535c4944f2ddda9a1a4840", + "python/sglang/kernels/jit/csrc/gemm/dsv3_fused_a_gemm.cuh": "32e77bc885be4c51c734119ec44f56623691c17850a3e598f0846dd20d79528b", + "python/sglang/kernels/jit/csrc/gemm/dsv3_router_gemm.cuh": "dafb382089f6ecb2c2497613caf6cd135d16307c13e45683a0bf1ab670d0874b", + "python/sglang/kernels/jit/csrc/gemm/fp8_blockwise/fp8_blockwise_scaled_mm_entry.cuh": "33d41c2ef4fe7f752b3ee571697c4cff5f4a1c061c0a6b0f20f7693eef9763f6", + "python/sglang/kernels/jit/csrc/gemm/fp8_blockwise/fp8_blockwise_scaled_mm_sm120.cuh": "57c41c6d9eb62cae7fbaa4bd65a5c1cfc63c28c133f592cf8ce8ac2088825e6d", + "python/sglang/kernels/jit/csrc/gemm/marlin/awq_marlin_repack.cuh": "15e0041d645d198c49303769a1a664bf9ed77d94b2dd7aa2e6c83277bb0db9b3", + "python/sglang/kernels/jit/csrc/gemm/marlin/dequant.h": "f07f0e1284431bd630d605b438c054509573c495d66d3a2b2e017396d84887a0", + "python/sglang/kernels/jit/csrc/gemm/marlin/gptq_marlin.cuh": "00fb263e7308b2d2cf2ec180ec53b3ea18c66ce5fef993efcafe0872b8950247", + "python/sglang/kernels/jit/csrc/gemm/marlin/gptq_marlin_repack.cuh": "baf9c493860b8f2d7af160c82a65b5b963f1da77afb02adfeb9b266435c72aaa", + "python/sglang/kernels/jit/csrc/gemm/marlin/kernel.h": "d2866eb1ad6342a106bdbc4edc87b5b3a8139d652af5bde4ca3f3d4d1ef69518", + "python/sglang/kernels/jit/csrc/gemm/marlin/marlin.cuh": "bce2c9316e047749af8553b35a30a9d5decb062d174952b6d5e46f9096494419", + "python/sglang/kernels/jit/csrc/gemm/marlin/marlin_dtypes.cuh": "fbddccaab5802b44e6167ee3747a207b88defeda2addbb04f737b85843b36185", + "python/sglang/kernels/jit/csrc/gemm/marlin/marlin_template.h": "c314a899e797b788dc3b0cf7e79d2ba2bd839a8338181e4c6c06942d15e8797b", + "python/sglang/kernels/jit/csrc/gemm/marlin_moe/kernel.h": "b7a0dfdbe8bd12dd4cf87236a0c7e102b8668e5d328b7ec2d8542b942fab4ec2", + "python/sglang/kernels/jit/csrc/gemm/marlin_moe/marlin_template.h": "6b43bc72d64a591bc86f62df2db14bdea5adce7b70b00af1a3e601a3c0d24fdb", + "python/sglang/kernels/jit/csrc/gemm/marlin_moe/moe_wna16_marlin.cuh": "a8c60a970f55eb28ea5673b471a40fe1374a6578d6b8ab3427148e1587309d0d", + "python/sglang/kernels/jit/csrc/gemm/per_tensor_quant_fp8.cuh": "a482dd40cbed6f7ea40b84d1c30d46b8e137a728d1ab1575b2497a0c8268066b", + "python/sglang/kernels/jit/csrc/gemm/per_token_group_quant.cuh": "238d3d4db7a36ae36e118bed8d37aeb9893cb40d0f5c2670cb307416499e9678", + "python/sglang/kernels/jit/csrc/gemm/per_token_group_quant_8bit_v2.cuh": "7719545131a8f77de08213f347f7b6ae242dcfb4ff2b9c4b25e42f0ad1e62020", + "python/sglang/kernels/jit/csrc/gemm/per_token_quant_fp8.cuh": "1b0603ace7a61533c9ecaefc77129cf75d459b6f1f7866cd3437e686d8024342", + "python/sglang/kernels/jit/csrc/gemm/tiny_gemm.cuh": "b6fd96712b080383cfa407b72e3516720e5283c65642ba4edb5b765e4d85fccc", + "python/sglang/kernels/jit/csrc/hisparse.cuh": "58b4d685eca4506e37b50b90e3b84a97e60481913fe274bbdb6266b3ae3efa4b", + "python/sglang/kernels/jit/csrc/inkling/causal_conv1d.cuh": "8185ba6e936a3333270082de515107ac511c0b20f05d281ed7169481f284a3f8", + "python/sglang/kernels/jit/csrc/inkling/draft_extend_sconv.cuh": "81072166e47849c0f17f6002378be5fb46649d1cfaaf261752bf3c60ebede3f1", + "python/sglang/kernels/jit/csrc/inkling/fused_decode_update.cuh": "c0f8f07a69182dacc7a857198190446ac56805844c2433c677f0bb3e8da5cc9f", + "python/sglang/kernels/jit/csrc/inkling/gather_scatter_sconv.cuh": "858d9657ba459bc79be42a48ce19cc3a93e701117395f14b1fbba83a192314cb", + "python/sglang/kernels/jit/csrc/inkling/inkling_all_reduce.cuh": "7df29829abf216717ee03cfa7fafe0abaf0e8a5be19dfed872b6a64de5d3bd88", + "python/sglang/kernels/jit/csrc/inkling/inkling_ar_barrier.cuh": "ed2c9fe6fc05c5e97d51ad7c501f6ddf5cd48e2de19cad93d4bbce57b19dc907", + "python/sglang/kernels/jit/csrc/inkling/inkling_ar_fused_decode.cuh": "2538a37b776d2d3c9c99de9f49dc5af3e5d171e5ac863861aca2e85150daf9b5", + "python/sglang/kernels/jit/csrc/inkling/inkling_ar_scattered_sconv.cuh": "3fd31b83efe21ac944b9fc872dee33cb50cf68bb08989cceb61616bd55218132", + "python/sglang/kernels/jit/csrc/inkling/inkling_attn_prologue_fused.cuh": "8d4d4bfba861b2dc20265f242a2f65a6a20dce63e2ed9cfbb7cd7a8785605822", + "python/sglang/kernels/jit/csrc/inkling/inkling_rel_proj.cuh": "c3c2b11b1fea4d191c7c2ffea9f09a4c1870eb618230fcb32421b084f51e61e8", + "python/sglang/kernels/jit/csrc/inkling/inkling_row_scale.cuh": "e7ae0573ba97ffeeefda8de155f40e8c03b8262f50b722e8f7154dc33b4a993d", + "python/sglang/kernels/jit/csrc/inkling/update_sconv_cache.cuh": "ed171c22a99ae7675d080044a4bfd4dbf32535b9686696c2829706a7f4d7fbf7", + "python/sglang/kernels/jit/csrc/kimi_k3/attn_res/fused_tma.cuh": "c67a610f15cb4faf6f4797fae052340ca6b93805774cac92a95f6b602b42f64f", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/ar_fusion.cuh": "c232ca37e83915c843b6e2dcaaa94b676eca034886f04c8a7118ca17553b65cc", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/gemm_ag.cuh": "094807027542cbdd9908c8bd00fc048c2e0577ba466787d9a0112579fcce6266", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/gemm_ar.cuh": "e04b083b051ee38d98d0445cbd7483f6d75247f0d95e75fa6eb1912e829c63c8", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/ptx_sys.cuh": "3e774aafe8c524fec8b0b7744b330fc292f50ed205ea5d01814f35080fc75d34", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/sp_collective.cuh": "47fbc28a578db6566206531a4f625c4b09c90026653d7ed07c3964e44709555f", + "python/sglang/kernels/jit/csrc/kimi_k3/mla_output_gate.cuh": "a898572ee61e6d5ed092508e6317c4e049453b4a3055a27b1b09f6b6e6d7d596", + "python/sglang/kernels/jit/csrc/kimi_k3/situ_and_mul.cuh": "f115fe9d64db37ab1deb85e481d98240c436a8e4236cf95fc74146726dff797d", + "python/sglang/kernels/jit/csrc/kv_canary/canary_common.cuh": "6da3c1d349c1360694ce842cb3626d24db5039916fbd21217ded985810f21a27", + "python/sglang/kernels/jit/csrc/kv_canary/canary_plan_entries.cuh": "50e31d69f717651c4699ce50bb74bbd17ff5b3ed7329179ca827944b867ad9bc", + "python/sglang/kernels/jit/csrc/kv_canary/canary_verify.cuh": "e3f4ff7b9debe237d02cbdc13014f718031735073a11c11b19d5b7761e48b4d4", + "python/sglang/kernels/jit/csrc/kv_canary/canary_write.cuh": "a70eb75252982eb80f8c886cab052b3051aa3abadefbe15b0deedd978a3b7af0", + "python/sglang/kernels/jit/csrc/kv_canary/consts.cuh": "026e2d43e2b28ffdb031a20ebb4e2096ed77be6739444aa114b84628fa334d3e", + "python/sglang/kernels/jit/csrc/kvcacheio/hicache.cuh": "dc34f219c0c18c9111df0383db55e88bd59ed0717c139f4907096202036b7dcc", + "python/sglang/kernels/jit/csrc/kvcacheio/relayout.cuh": "5eef475951686a10fad64c2fca749935fd32a4e5ec9fe544de1bb0fb11a3436a", + "python/sglang/kernels/jit/csrc/kvcacheio/staged_write_back.cuh": "1794e12145ff90d65c32fcbb276b95c912683bbc60403dbc9f4a39b8017dea91", + "python/sglang/kernels/jit/csrc/kvcacheio/transfer_mamba.cuh": "21928b36df0588cddb62e0571bd3772a82faa4c2a3b415f094c509913388e9c8", + "python/sglang/kernels/jit/csrc/lora/moe_lora_align_kernel.cu": "406a8ae7ba84990a0864906b623f7dc46e68094587a5391d660dfe81a9cd6179", + "python/sglang/kernels/jit/csrc/lplb/dispatch_probability.cuh": "7a599a45668e1f0ba5a9b818298ed96405da81a55070184a4e5845a66714a53f", + "python/sglang/kernels/jit/csrc/lplb/ipm.cuh": "57a5f55eb0747aa72454fe65ba323a8fd31e8d716c8027f982bfec01c2ca2af5", + "python/sglang/kernels/jit/csrc/lplb/lp_post.cuh": "1932e8ef7ac2158f0dd75b6c6738acf3f701798a9423479a930cd9416ad7eab2", + "python/sglang/kernels/jit/csrc/lplb/lp_prep.cuh": "7d88b8b81de7bf0587f1068f7ed05b07382afdf681056fdd58e6867d2a2cd1c0", + "python/sglang/kernels/jit/csrc/minimax/fused_gemma_qknorm_rope.cuh": "336de8cd9adb1b78dc532e5734a99b5122e288cdd220bafb563381d4cfd770de", + "python/sglang/kernels/jit/csrc/minimax/fused_store_kv_index.cuh": "e09124ed2d1a9b2a91a1264d4d03fe8d0730b6ef91d602319cd5bf441aa678fb", + "python/sglang/kernels/jit/csrc/minimax/minimax_decode_topk.cuh": "1ff9ab6bf3079cca673799943efd6c5c9ac7cc7f33cc6ac5f5bbe5dfc369612e", + "python/sglang/kernels/jit/csrc/minimax/per_token_quant_ue8m0.cuh": "10d7e1ab1bf2a23c8a3984cf2b5c80d541b8e17911acdd5cf589943bd5b6c623", + "python/sglang/kernels/jit/csrc/moe/align_single_token.cuh": "284a9e08472d44beb552c7f13c2ed5b61c893561b95227ed49dae15e08e09ee3", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_group_quant.cuh": "398d73664bb560c2a0e1f99a5788b939793093dff2f1740a318569f7cfe6d7c2", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_moe_group_gemm.cuh": "abb556104569a0d6138516d187d1fc769fa81b613d07334eefb1744a382f26ee", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_moe_group_gemm_functor.cuh": "e4c2e9a37b380465b0eb2a8a12a0730c7e5a87ef4d66f8583918cae0715cdf53", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_moe_group_gemm_traits.cuh": "a50295047703237a860b9a87d348891e130fd49dbcf943bf2f60ddc65e2828dd", + "python/sglang/kernels/jit/csrc/moe/inkling_gate_topk_renorm.cuh": "cff262d7fd533cced45dce24c24e4a86a08bba5599b75f62e59e7022d67a9020", + "python/sglang/kernels/jit/csrc/moe/moe_align_kernel.cu": "2c17adf81459e91fd7ad149d63ef95dcc75eb5246859c83999785003e1e72770", + "python/sglang/kernels/jit/csrc/moe/moe_finalize_fuse_shared.cu": "e2fcd4ff823725a3b0d773b9c83f4c90a964e0d2c496e3a676baa143fee77970", + "python/sglang/kernels/jit/csrc/moe/moe_fused_gate.cuh": "d336c973d0491090f236e2f4585b0974452ad9f9a6260f11af2ce7627c00ff49", + "python/sglang/kernels/jit/csrc/moe/moe_permute_prepare.cu": "e58d9bab7cd10f0cd4871008a3dfac42ab5afff3e36236ba6015c0afdd168191", + "python/sglang/kernels/jit/csrc/moe/moe_topk_sigmoid.cuh": "fee82bba2fb4ca0f4e5bed7763141ea838808d37f4f771a36a52e0833b0d0c2f", + "python/sglang/kernels/jit/csrc/moe/moe_topk_softmax.cuh": "f9c8ee1f1e9af1037612418cda472b907c6455262c93a5d1e20764cf065fb55a", + "python/sglang/kernels/jit/csrc/moe/route_quant_fused.cuh": "00a830f28c924f2bc89ac280ddee233b0d2ba701850e6bfa4d140fb4960e688e", + "python/sglang/kernels/jit/csrc/moe/route_radix.cuh": "f93a2c03c15bf98203b0412b96aee97422020e4c3d22b55416afb99dd42e0c29", + "python/sglang/kernels/jit/csrc/moe/topk_sum.cuh": "7490919bf896fff6b5edae2819c675fdb526b90fdeeaeda1fd6679d8441f36f5", + "python/sglang/kernels/jit/csrc/moe/tvm_ffi_utils.h": "58649a287b1daecf47a996dcf5ff97d225181bfb6880303b60745a606fdd1757", + "python/sglang/kernels/jit/csrc/ngram_corpus/ngram.cpp": "b7300b2911647871022f10a49cdd37736f84778bf96736234bec51a307c1a8f0", + "python/sglang/kernels/jit/csrc/ngram_corpus/ngram.h": "6f0d5387ad103989b306029a9471b205b5f8ef198c68686afa430d5c22f93f4a", + "python/sglang/kernels/jit/csrc/ngram_corpus/ngram_corpus_ffi.cpp": "a2d4a93da60bdf3c6c36c439a8afaa70bf6ff3de6ba24558177348376c7e580e", + "python/sglang/kernels/jit/csrc/ngram_corpus/param.h": "659ba17b9f053a8aac36d8d3ffe30e87e781cebffe6ff9554adad8681913b112", + "python/sglang/kernels/jit/csrc/ngram_corpus/queue.h": "682d35035db7c33fd84d576b8a5d352abeb24ed422b04de5aae180d8d7586b53", + "python/sglang/kernels/jit/csrc/ngram_corpus/result.cpp": "9964b88c15f50bd3fc27fffa94d097858a5b63b3cdda2076b66bc6c85aec7fcb", + "python/sglang/kernels/jit/csrc/ngram_corpus/result.h": "fcd172342fae7beb50cd4e164caadc41908685b0ae183664331bd900bf1402e9", + "python/sglang/kernels/jit/csrc/ngram_corpus/suffix_automaton.cpp": "368f4ea6dcd5500324097171cd1b9e0cb7a0879bee227c7cc5236c7ab525fcdb", + "python/sglang/kernels/jit/csrc/ngram_corpus/suffix_automaton.h": "acc2a2f5c9b3f89546062f283910b56cd59c3be6c0cf29c35f53da38d82f76ca", + "python/sglang/kernels/jit/csrc/ngram_corpus/trie.cpp": "371ac7f5fdf9d6c55ff894a5ae668d7168257257fb484bf661f4bf0cb65ddb68", + "python/sglang/kernels/jit/csrc/ngram_corpus/trie.h": "4e72052b2c6070a923b8124f4a4d61d4424e20aad5d7190ad10c83ef564847de", + "python/sglang/kernels/jit/csrc/ngram_embedding.cuh": "90556360102cbf1ac47eaac5ab500a9ea07a924ed273fa56ab21a63c23967a02", + "python/sglang/kernels/jit/csrc/qprep_bf16_fp8_sm90/entry.cuh": "4c42ac4c702e7162acc1b36a98e8c694b8d4a1f134b2de18ea4451a224808280", + "python/sglang/kernels/jit/csrc/qprep_bf16_fp8_sm90/kernel.cuh": "4023069a19b12db9ce3489fc591e63e44aea7c4317a784f9485c5d34cbfbba11", + "python/sglang/kernels/jit/csrc/qprep_bf16_fp8_sm90/params.h": "2e37fa9934e1555f888b9c40eb9106d64ec9cd088b35c7c4b8d84d1301b20914", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/config.h": "cf5ac5b5f0f8d69f4a6d093a51df08be7f8ec1a7137508c6f6ade32431a5759b", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/defines.h": "89c365d662f0f15e264999b5556a6627f6c61a254411ab28de79853e4a98bf1a", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/dense_fp8_transpose_v.h": "42330889541bf80258014c8984fcc1b2c9dc42bdbc64018a06f6fb58db5fdaf0", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/dense_fp8_utils.h": "34165574c9498c1fc2189b495f36d7177eb6ca113dfdcc68800e3f60fba87443", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/entry.cuh": "e30b002075802d045fe5813936d1951baf5c7d3073c0f51f6fe12d1c845a1830", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/helpers.h": "331ff0405e757a62c53cc21e0936b399725e8395165803e1d65f392090c811c9", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/kernel.cuh": "a5894c569493eef70582cb18b7920bb69285fdcee6919c6946b9836872fa2032", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/params.h": "e4dd80e30f31c1ac368ce6f5c1bd95e2b2e4d753d0853c1dd4309e498bfcf0c9", + "python/sglang/kernels/jit/csrc/trtllm_lora_temp/kimi_k2_moe_fused_gate.cuh": "f9bc440197f1e297f8773ab0892e99800d16233f936950314b06dfbf3c34e5bc", + "python/sglang/kernels/jit/csrc/trtllm_lora_temp/moe_lora_merged_align_kernel.cu": "cc39fdf9fd8df60afad33c3c263b659d62d8961a3a5aaaac965bf0a4df50d0f1", + "python/sglang/kernels/jit/csrc/trtllm_lora_temp/topk_softmax_pack.cuh": "727b05ce97d9fae8c98d878fa552f6cecd7fc3832a705e2208ac26dae415034b", + "python/sglang/kernels/jit/include/sgl_kernel/atomic.cuh": "c6027db53247cef8de1176fa5ef4b3e1aa459a468014ad90fbde67712917a572", + "python/sglang/kernels/jit/include/sgl_kernel/cta.cuh": "591d5f3014a43cc6bef5e5e86cf8b0304f79a86e35f4fd015585bb33b7c8079a", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/compress.cuh": "fb90d430136a949651c6f56316bca5134e2e3366b6edbfa7dbeef858a4b09b46", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/compress_v2.cuh": "33c3b30c05894ec589a7dc1d377e557c6193f42603324b8ce43fab5e3b37cd09", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/fp8_utils.cuh": "18fc737eccaeb4a6d657ab601361b3391082385d0e808c9393159c932918985d", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/kvcacheio.cuh": "be8387ed456d64f9fe707a02708d541ac7793723619af63d36d2206f0ebc16bc", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/topk_impl.cuh": "8b4842c35f2c6a733c15c4c0e2e6e3f6d5800fb5694ae075659ea71e5afa3935", + "python/sglang/kernels/jit/include/sgl_kernel/distributed/communicator.cuh": "6cd35c7716eaf20d184abd4ed238074042a96fef0c18e18200dda0761f03c192", + "python/sglang/kernels/jit/include/sgl_kernel/ffi.h": "def534f44595978151e47056ea77c9eb91c9c1ebdd8f8145425704846f756a8e", + "python/sglang/kernels/jit/include/sgl_kernel/impl/norm.cuh": "d8dbe98b5a69faf48aa39f13c73306c0882dd92cfaea2fbdb42541692283c0cd", + "python/sglang/kernels/jit/include/sgl_kernel/math.cuh": "9e63daa4b29bd93bee873eabc7e374636c6c28de237d8b63beb70cca755bdff5", + "python/sglang/kernels/jit/include/sgl_kernel/mbarrier.cuh": "51153324b76e8683c9127ddfbccc3c0503e39d7192c7fd4c93cb0c68142584a0", + "python/sglang/kernels/jit/include/sgl_kernel/runtime.cuh": "f5d625427f6a78ea945adafe1eb0c9af35c5a46ae36ebe20d073756db7b04654", + "python/sglang/kernels/jit/include/sgl_kernel/scalar_type.hpp": "e1c15e090e603b230c14b0589455217773c4565b432549aed8126dfdffaa3e7b", + "python/sglang/kernels/jit/include/sgl_kernel/source_location.h": "300026cbeeabe03b10b0c46b70e2e85b19a743cbe9ff462faa1dff4268cf806e", + "python/sglang/kernels/jit/include/sgl_kernel/tensor.h": "61747de0460e2075dc6bd298212d860b4bb9812645b33b48316b3648d9ec3d40", + "python/sglang/kernels/jit/include/sgl_kernel/tile.cuh": "3ecd35d51d4198d568906d7a8db30b8b4b5fed07e6c6f722710a9ce2d9619d5f", + "python/sglang/kernels/jit/include/sgl_kernel/type.cuh": "4c72b0892e8d003490bdab2633056172a674bc6a9689be552861564c7aaf8edc", + "python/sglang/kernels/jit/include/sgl_kernel/utils.cuh": "f87eafb71f39b9428ec4b3b524c95634f794b4256a6b240a17f2aa5339d92f8b", + "python/sglang/kernels/jit/include/sgl_kernel/utils.h": "68cd3ec640f9ceaf66f46be99b1e025c2a70dde32ea95ce462a1558af78d3515", + "python/sglang/kernels/jit/include/sgl_kernel/vec.cuh": "ba4ea5d07aa1a2722b48d690462c90cf4d3af2c608de1b97897d38ffb4d3965f", + "python/sglang/kernels/jit/include/sgl_kernel/warp.cuh": "6c911f6e53045e54f1119e6219cc455e0ba2cf9205cf8cdadec81dcfc030c633", + "python/sglang/kernels/jit/utils/__init__.py": "143200928e33d8630ca5b9a38cac8e4d0f37bd4657c0d6ca9bc4bd5581d6fc7e", + "python/sglang/kernels/jit/utils/arch.py": "b24cdb3c2e0f8187b188253ca47f666725b521f911690f5a4246f528e8917290", + "python/sglang/kernels/jit/utils/common.py": "cdaab0ec52cd48eddf527e03e3c109745f2bf882751802407bc51b7e7ad4c22b", + "python/sglang/kernels/jit/utils/compile/__init__.py": "7e1aaa05da2f5c814e4d2b6452a37f270d0acefe2d4b47c5dc87f5931f1e1e88", + "python/sglang/kernels/jit/utils/compile/cache.py": "45d4b3ae569886b2ea286b6feef93e618153386776c3d563a08e1fb0028f9157", + "python/sglang/kernels/jit/utils/compile/cpp_args.py": "84be4f6ab4b3a435a424e2762cf2f48c25ccf57119e6971e83f4856d779757c3", + "python/sglang/kernels/jit/utils/compile/loader.py": "00b0fcb4d284fad3d0b82c5880487434c387f6f4343afff745e44892aaa61564", + "python/sglang/kernels/jit/utils/compile/ninja.py": "68b9ff31d0fd43bf281741bef4d2a0a53cb8463a754078d2ca2085f6d6b628b1", + "python/sglang/kernels/jit/utils/compile/paths.py": "bfa8a912174607c74237f1b5f45b0a87dc8da8b5f1f5be39868966787fae76e2", + "python/sglang/kernels/jit/utils/compile/spec.py": "f762d7d90adb2770988ab0d17b444496d9d611531ab136eb37b8c8707dd42b2f", + "python/sglang/kernels/jit/utils/compile/toolchain.py": "d75ec06b9b323b0567970a1aae9c2a49ad320b88d0352bc19f18198f6f8ba41f", + "python/sglang/kernels/jit/utils/deps.py": "6c5312bba714e3d89c441002848cfe21963d91547cf8f9b0627a9f8612488922", + "python/sglang/kernels/ops/__init__.py": "17dff6cbcab853740d5c74243a33ca7151d1efa300db6b3e2f42704052270598", + "python/sglang/kernels/ops/activation/__init__.py": "3ffae92048c328bbe02761dd0765f4720be4e01a92d6298a373ad2390236a75c", + "python/sglang/kernels/ops/activation/activation.py": "1b938a3778c68ce5f24af370c674097dd9b0dd0771d960262369a200b35cd5d4", + "python/sglang/kernels/ops/activation/softcap.py": "6137b3c2d33a4d208e44bd5a32a77c349cafe56b79b78e1f092fd980e26807a5", + "python/sglang/kernels/ops/attention/__init__.py": "9c656a6e4f908e4117aad6a826e37625b511d9b86498e18ee763237d49e1e34f", + "python/sglang/kernels/ops/attention/clamp_position.py": "3b242de474485634cfc500cb5f0bdf19b44f3dc046172f6eafea93dcb87d9228", + "python/sglang/kernels/ops/attention/concat_mla.py": "78e47bfd60ed0036d211dcdc601efd90ecc2eb08358f3dd11ad9bb911a966b2b", + "python/sglang/kernels/ops/attention/cute_utils/__init__.py": "bae5c59b81a21abc499713696addc9e0f9480b0edfafd8e8b291368b91eae261", + "python/sglang/kernels/ops/attention/cute_utils/_tcgen05.py": "72673dc0362510d25f5a800a24cfd92a329170aad0c7b33005d1e70737906d05", + "python/sglang/kernels/ops/attention/cute_utils/cvt.py": "592eb52223e0e2e1525d179a75430f109b329ce87cada679b9b1b84d5172a257", + "python/sglang/kernels/ops/attention/cutedsl_fp8_paged_mqa_logits.py": "a2cee285a395159a1003530d14791b151df242ff5d36d77e0f9e3cf0b97ef061", + "python/sglang/kernels/ops/attention/cutedsl_gdn.py": "309913901b7f9787d3e5066bb3417f4d7e5412267562acbbfa9d3b6294961866", + "python/sglang/kernels/ops/attention/cutedsl_gdn_mtp_ring.py": "f5e8eb4af1a67288103e4b9af3c9a34c0483838baa9b559a0c55de0f71ca5ebf", + "python/sglang/kernels/ops/attention/cutedsl_kda.py": "c77b7c1632d281a7745d6c10fbafcfd7f6e2f10a741ad0ef0da1bdb552af0a0c", + "python/sglang/kernels/ops/attention/dcp_kernels.py": "491b0fd6db3c8fd04d1b287026f1e9108a58e217eeeeb5e6519efeaef0984736", + "python/sglang/kernels/ops/attention/decode_attention.py": "7833f6d06115dfd54b384d9ce907a012fa2f568083d90fc0f259e9ef24bf5311", + "python/sglang/kernels/ops/attention/deepseek_v4_rope.py": "dbba9685fd108c5e1d5d8e1fb824405d396c5efe3e7f1aba786740919e72abfa", + "python/sglang/kernels/ops/attention/dsa/__init__.py": "e5a6166b0b49aa607226067dde70ae0bb447aca2e44e3d8df1652d826efdfd3d", + "python/sglang/kernels/ops/attention/dsa/cp_split.py": "d41738790eb2bef1e723b59efb87bcb60d5670c8f79ea854a8b3d13c53ad1585", + "python/sglang/kernels/ops/attention/dsa/cutedsl_paged_mqa_logits.py": "ee74a18a516ae9233f5400c5373d365993c93cf1b58106ec724dba662ec293e3", + "python/sglang/kernels/ops/attention/dsa/dequant_k_cache.py": "9fb188edb6230dab5841e3f14990cc6cf2e49c120dc26400b04fcc7bcc69426a", + "python/sglang/kernels/ops/attention/dsa/index_buf_accessor.py": "5ce7ff62b2843dae6e03601708c59078de9f3ed23562210b92f007f64e4ebdd4", + "python/sglang/kernels/ops/attention/dsa/paged_mqa_logits.py": "51591504130457f6e423f8930749ab8744e4bece16ca0cd19c79d2196634807e", + "python/sglang/kernels/ops/attention/dsa/quant_k_cache.py": "23dccba0f293449067a25b90e4ac009ce4e1d424c3358aedd9396fd35c995fc6", + "python/sglang/kernels/ops/attention/dsa/tilelang_kernel.py": "29ab236ef60c67b6e20d7d89afc972e40e31336251195b6221cc529c44ab004d", + "python/sglang/kernels/ops/attention/dsa/transform_index.py": "fe6b45fe4b764e97c012c31d774041a9ad8bfacd99725196bbefbaec993ae5cd", + "python/sglang/kernels/ops/attention/dsa/triton_kernel.py": "58c0924b2c5f5ea3febeeb490fb64a9ee205d98ec142047dd1a6860a53680f28", + "python/sglang/kernels/ops/attention/dsa/triton_sparse_mla.py": "4fd8beada8f58a93a32dedbe70283b651d6e56b8dbf3035225647f3465d9d623", + "python/sglang/kernels/ops/attention/dsa_metadata.py": "4efaefe6d925b4d5f73e7baef69a63f5cec35d5fd72c06aea8bbbcbb812b53ab", + "python/sglang/kernels/ops/attention/dsv4/__init__.py": "3c54a9103bf88ec2502024fd7f5860ec6283a5250a2fe1deeb51872535ab2e53", + "python/sglang/kernels/ops/attention/dsv4/attn.py": "4efb7a3dc9ec56b81e117c9c383dd08cf153b12c95d4f3ed2137efb0689754e2", + "python/sglang/kernels/ops/attention/dsv4/c128_cleanup.py": "140a1760c899abe8968189dd7fcad026b534c889954d8967888c25f4b1d8477b", + "python/sglang/kernels/ops/attention/dsv4/compress.py": "f010f91edc9cffe44e975a2bd628fd90998cae0c502052a61da2936b4e9ee271", + "python/sglang/kernels/ops/attention/dsv4/compress_old.py": "8717e962fe937958c68e44334ad5b81006adf93bd574a364a1c912ab603182ca", + "python/sglang/kernels/ops/attention/dsv4/dequant_k_cache.py": "d11a3b063006d8454e875d5a42398c0711f16f1287bd65956262f90a19912de0", + "python/sglang/kernels/ops/attention/dsv4/elementwise.py": "883e36339a2db3f8a8b978431bb82b080d4781568c965d4564eacb2da41b5b94", + "python/sglang/kernels/ops/attention/dsv4/fp4_indexer.py": "b69452017774f74740cbe7ccfb4030607ce15858a812a3f661636e370aa844b4", + "python/sglang/kernels/ops/attention/dsv4/fp8_wo_a.py": "cba3e8d702771b3f9e01d43f2ffa322c6a13ff29c0b2cb518b322d4dfb21cb49", + "python/sglang/kernels/ops/attention/dsv4/fused_compress_triton.py": "4e17f79ed97e57f972f1fb37fbaa59e6160b66e0aaf2fb4806b9da19c04f7081", + "python/sglang/kernels/ops/attention/dsv4/gemm.py": "7d08628d9f298c404afe3201552b8c39df5a1f8718db2c1f3dc36b3a2659d428", + "python/sglang/kernels/ops/attention/dsv4/index_buf_accessor.py": "0922ebb9bdde82b115ee9ae17ca604b5c7e55a357e2fdd54f16942eece50290b", + "python/sglang/kernels/ops/attention/dsv4/metadata_kernel.py": "c9edb7c07a5189c67ea2cf55cd6c2d60a6de5b629fcd9aba6de0b8016c7192de", + "python/sglang/kernels/ops/attention/dsv4/moe.py": "13d01b06131160266ffbd560f91a6cba515483a0c48199e9f41e466763bd8eb3", + "python/sglang/kernels/ops/attention/dsv4/online_c128_mtp.py": "3d84de7e3aee335a3ec51a49a326a340bb4bd8ea74cc2d5d45b24fbb28899aa9", + "python/sglang/kernels/ops/attention/dsv4/quant_k_cache.py": "d557c3b3b7a0062dbeee5c24d6c0499e5fecb0b10a1e3b07756a0870a024764e", + "python/sglang/kernels/ops/attention/dsv4/rms_normalize_hip.py": "435e8f05d62266fc37db9956963616bc406844d984df9bfcda36dab4f215ac79", + "python/sglang/kernels/ops/attention/dsv4/sparse_prefill_kernels.py": "74bdd03e419233ed17b7070f625ba2959299fa6419c5e0cdb8911bde5baddcbc", + "python/sglang/kernels/ops/attention/dsv4/topk.py": "bbfa1356f1a65aecdeac7ca2f23436bddcc0c30d7b5c3d2d25016732a5097c49", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/env_gate.py": "a395164121f06b671c138595abb23d6d57cdf9bbf3fa121a002aba99b211707c", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/paged_decode.py": "ca49b68c9151df67919a9fbf2247828b0ab79785466959c7c8a7eda2f69e4d35", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/paged_decode_indices.py": "f008dfe6cf2332921cc613a24fc835c9746694836242ab776a451d51eb503d45", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/paged_prefill.py": "20379961e07ffc613e4ed1f0171da22ce641d697bf722f88fa65c541d30ce419", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/runtime.py": "eff745080c1c530b613465f8b8ce061e1cc74371984e41615cf9b42e8bc86969", + "python/sglang/kernels/ops/attention/dsv4/utils.py": "14c23af783cf8c301b9a125f689fb97447574778de7c433263b0a656e6e051f8", + "python/sglang/kernels/ops/attention/dsv4_attn_metadata_kernels.py": "4276de2afa328739ddcbecf7d8a48f273fddfa8d8a029e7024b82e7dacb91969", + "python/sglang/kernels/ops/attention/extend_attention.py": "8aa8d01f0a73a144f51a8b7e8dae94a96c227b1dc6b6397ab8ff03116514dfd9", + "python/sglang/kernels/ops/attention/fa4_sm120/__init__.py": "05622241f5ba038d487f91084605c66360d3e59a3cd9e2830ad08c1587cd19d5", + "python/sglang/kernels/ops/attention/fa4_sm120/dispatch.py": "f317529e990321f64bc41705a6069b37c30765ec4c780601b3e0411414ff5b1f", + "python/sglang/kernels/ops/attention/fa4_sm120/flash_fwd.py": "3ccdfba82570f26eb812808fe4aad34dc4d3efc036cd78931a17af2d429cb995", + "python/sglang/kernels/ops/attention/fa4_sm120/flash_fwd_decode.py": "0623ee03ad82f3ed9d602227931870361879ea008aabc48e74e506258a337113", + "python/sglang/kernels/ops/attention/fa4_sm120/paged_kv.py": "99d640185f7e29fd80afd387032da6f998989dfb5fa21afe9b5dac01e45f263e", + "python/sglang/kernels/ops/attention/fa4_sm120/policy.py": "58bff198c322d87166f6d7330df81e7fc3073353e277641d39c66ca3ea4269dc", + "python/sglang/kernels/ops/attention/fa4_sm120/runtime.py": "560875edbed63a59d2060dc4adff839566ff603e0e8f3443181d04785c0e71fe", + "python/sglang/kernels/ops/attention/fa4_sm120/scheduler.py": "d5dd1d29975f3e07a042ba7b509ed14269103bd3dd087494d10f55e85c08d771", + "python/sglang/kernels/ops/attention/fixup_zero_kv.py": "b5d30088d783c3f9099de0151e454258013d4427e5277ac6ec7ae9dd86965024", + "python/sglang/kernels/ops/attention/fla/bench_gdn_replayssm_fold.py": "ff66ca4c761ef052e5ed10d772e27282e5a5791f45c78bed6d3c9638e9b8704a", + "python/sglang/kernels/ops/attention/fla/chunk.py": "8edab1f6fc35b86300a91dc6afd61c2456bd7a4ed3986564456977fdb098f2b2", + "python/sglang/kernels/ops/attention/fla/chunk_delta_h.py": "580a24d2e91c885ef180f5135978c3cc35f01e96a17776baa4b13fe06533bb60", + "python/sglang/kernels/ops/attention/fla/chunk_fwd.py": "e6ee7b4601ca12ccda6fd93050acedae25d2b6e6a27a27ebf194a58533a4140c", + "python/sglang/kernels/ops/attention/fla/chunk_intra.py": "1ea350047ddada714183928ff30199796817e3b6c7907557af6f6cfe00fe1b38", + "python/sglang/kernels/ops/attention/fla/chunk_intra_token_parallel.py": "b66650b2b1299a76d471a2d026aac638727431f2786ace32eb745b9c9bab41f0", + "python/sglang/kernels/ops/attention/fla/chunk_o.py": "c5e5b0f7ccdaa744c5e0eede8ec73a5767b322132a72ce46a56f04bfe4c07564", + "python/sglang/kernels/ops/attention/fla/cumsum.py": "4f5efb6cfdf25137bbdde22c84fe28783b5fc4b6bd83ce4b57ffee1924ef7a78", + "python/sglang/kernels/ops/attention/fla/fused_gdn_gating.py": "c7736d1e506fb2c3e5c0496a2ed8c23347c2507ebe73c08bc6745517495d0957", + "python/sglang/kernels/ops/attention/fla/fused_norm_gate.py": "9110a606a057c6268932cd51a3f88ffdf419f063407559805e9b4fd2211fce7c", + "python/sglang/kernels/ops/attention/fla/fused_recurrent.py": "cf5e980d86174a631bcd0872f8ebf7a6ab7c21c3435c097f66f8ba0e686debc0", + "python/sglang/kernels/ops/attention/fla/fused_recurrent_linear_replayssm.py": "a8824a71ab49fde1f070c325c89603e6198928bdcb2238f2d6e9ef8fb7247f62", + "python/sglang/kernels/ops/attention/fla/fused_sigmoid_gating_recurrent.py": "c0142cf78d5374cbff285d8d46b39710b2eed42620d41fbd93e518104cce1695", + "python/sglang/kernels/ops/attention/fla/gdn_replayssm_spec_decode.py": "74043400ac0cf1ea5dd9b30ee1fd79ad0db2f22843c0333d8611f1ca20a4d26d", + "python/sglang/kernels/ops/attention/fla/gdn_replayssm_spec_fold.py": "fb79ad9e12ec1e485cc65e12d6394debee69fb21a14c50e1bb84a809f6a46e28", + "python/sglang/kernels/ops/attention/fla/index.py": "bb0b99067ba9f2f24d4c52fa75e6c008ce3837c519e20c18c0bad1e4a3c5db0e", + "python/sglang/kernels/ops/attention/fla/kda.py": "6d37f8f7bdfc5d430090f99106448f4051a9076c6df166fd2b96bafc61c601eb", + "python/sglang/kernels/ops/attention/fla/kda_replayssm_spec_decode.py": "bb51f807c932bc19b45eedc2a6dd3d1f6533389b3d788e0b91901b4208d6f331", + "python/sglang/kernels/ops/attention/fla/l2norm.py": "b1323047a7c7f46268a9c295f4fea5c53a210ebfb04db5b17d7ce6ff4b24b7f7", + "python/sglang/kernels/ops/attention/fla/layernorm_gated.py": "3ce4895e768aead4f12031b37fc0ee511d783b9ec476016c85b715c2dcf84988", + "python/sglang/kernels/ops/attention/fla/op.py": "592dc573983a1a20a00e1cea3b2d5a2a43ec8881d6bb45ad7a1f1faebb1cb7d0", + "python/sglang/kernels/ops/attention/fla/utils.py": "72afecb7e66a2f3bed4058901859dbab6aec233ecf7ddc595a9d21e123ead20f", + "python/sglang/kernels/ops/attention/fla/wy_fast.py": "067afef050b30951d6e24f08ada0fbd1434acdd0fb6f4f253c8f5c40c363b50c", + "python/sglang/kernels/ops/attention/flash_attention.py": "a45762ec7756a436a74f94d47b4ca2bf386976edd49001547e9600a7f652e19b", + "python/sglang/kernels/ops/attention/flash_attention_v3.py": "b77ed59eb5f8d27b32eb92eaa54bdbb229fe6d3dcd4ac2be85f43682136bc47d", + "python/sglang/kernels/ops/attention/flash_attention_v4.py": "53b5fd198ebbbd67cb65dc4d783d35b03826e18010576c350a7f32fcd8d05497", + "python/sglang/kernels/ops/attention/flash_attention_v4_sm120.py": "880ac1dde246b93bc237ed05462e030dba61886aa3ffeb892ec100459e3e298a", + "python/sglang/kernels/ops/attention/flash_attn/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/ops/attention/flash_attn/cute/.flake8": "8cb396353fbdedf8028792aa3428849e7bd9c724a6ea4953da32737860570ec9", + "python/sglang/kernels/ops/attention/flash_attn/cute/AUTHORS": "82b4aba3841946660c3d8be4b565b94477af318dd185368cf1a76aa40d7d84a5", + "python/sglang/kernels/ops/attention/flash_attn/cute/LICENSE": "8c9ccb96c065e706135b6cbad279b721da6156e51f3a5f27c6b3329af9416d73", + "python/sglang/kernels/ops/attention/flash_attn/cute/MANIFEST.in": "a9c54041b68b5e51a5ba1a3942b0eed6b39ba1b8575dd83512ca1a4584ac3ec1", + "python/sglang/kernels/ops/attention/flash_attn/cute/README.md": "69e70ec669e9a5e1b843e5b8e5e8ec1366c67e70098b84ee0d79b612cb9bad1d", + "python/sglang/kernels/ops/attention/flash_attn/cute/__init__.py": "50713012c3a5e8045f368672342aea6eeeb3b3ce0968cb5639b1f158b9499487", + "python/sglang/kernels/ops/attention/flash_attn/cute/ampere_helpers.py": "0fb11626d3d68849220d251a5ee5fa1790e599cdbf0f62817e6b4e2b2f05400f", + "python/sglang/kernels/ops/attention/flash_attn/cute/batch_invariance.py": "0d47e270bc35458417609e980b9be1c26cfd54e0d91f326fa51e7aa360309a5e", + "python/sglang/kernels/ops/attention/flash_attn/cute/blackwell_helpers.py": "e36bc15d0dbcb2e91ae99541c7275aceaade0f96b471075b43e31cef065b22b0", + "python/sglang/kernels/ops/attention/flash_attn/cute/block_info.py": "607c304d0cd123595188537a9815d69282d3a7419cb457768d8c31993f25b359", + "python/sglang/kernels/ops/attention/flash_attn/cute/block_sparse_utils.py": "2b3e749380f21d6fb77853ca4270f0c9005aad52225632202d3ee442af2f7cd4", + "python/sglang/kernels/ops/attention/flash_attn/cute/block_sparsity.py": "9ca21cf8b9ae5f7c44023df646f70b793667cdce2bbb09ba15f5f7a3a19a4c26", + "python/sglang/kernels/ops/attention/flash_attn/cute/cache_utils.py": "c34ec6747921a83f4e1fa6838fb42e694a36d5f1a4b3b3a4af3e4e68d25971a9", + "python/sglang/kernels/ops/attention/flash_attn/cute/copy_utils.py": "43ae6db77b9e48280ba7b6e7413ed24929430b8a53015bc5ea9dffad57d1e9ad", + "python/sglang/kernels/ops/attention/flash_attn/cute/cu_blocks_kernels.py": "31a4b3dd15457c0fda258931544bed4ae859c71de2775bc9679ebd544aeca388", + "python/sglang/kernels/ops/attention/flash_attn/cute/cute_dsl_ptxas.py": "acc3f18e41bca5555505dc79129e45eae6a3a5510d0b9e93fc1614bdad242776", + "python/sglang/kernels/ops/attention/flash_attn/cute/cute_dsl_utils.py": "03520beefd65d44c5bb1d3420e18664f0202b3c7926ea9d5dd8c97a983ef2583", + "python/sglang/kernels/ops/attention/flash_attn/cute/fa_logging.py": "bc71edfa4b1cb7af64b78def09e790ff4c6fe64ab4fcf8e3d9699f44e8d3c0a0", + "python/sglang/kernels/ops/attention/flash_attn/cute/fast_math.py": "7e5f822bf4d0ba36967558f3ae9a1408b410cb726c31222cd61703569d1be738", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd.py": "97edf14f4be14d83176efc816f867c0bf751ae65b380942da9147932ce959ea4", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_combine.py": "b604abd7f3aa747451a733bb98ec2cb159febbc0140c58a16fba56e415b170ed", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_mla_sm100.py": "5b180193a2f3ad7c0d87fb19b7d6ea1985bf2d70102e4abbb34ab8c09015e573", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_sm100.py": "37e40dbaae7d22c87210c4e0541790e9ace2d66e469259faf5b299f746403dfd", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_sm90.py": "16815521b74bfc9e5fc16411e503da6ff5b4146a0d40e0563073bafcc90d61c1", + "python/sglang/kernels/ops/attention/flash_attn/cute/interface.py": "4d74a7506b635f9890daa6705784148a71bd0bce22e0c21ecbbc3d5090f76368", + "python/sglang/kernels/ops/attention/flash_attn/cute/mask.py": "1f4a0980b684083ab4d8bd90dc617bc9f2b6ce8074532d9d5814e76230f413d9", + "python/sglang/kernels/ops/attention/flash_attn/cute/mma_sm100_desc.py": "3f87737997bd1e589500ca8b3b8e6e56fb466760b4eb63eeaa332bbf1bd8b6f9", + "python/sglang/kernels/ops/attention/flash_attn/cute/named_barrier.py": "729f4581800b31e1b6116bc44c0f9f5268b986cd7ed108d407d4bee4441ece46", + "python/sglang/kernels/ops/attention/flash_attn/cute/pack_gqa.py": "71b087e2f1d299a8c9e5181e6d083444e9a421f749b7cb51c5129abeef0aadf8", + "python/sglang/kernels/ops/attention/flash_attn/cute/paged_kv.py": "a80b0cafdca4a570722d6d4edaf9a35e5ec31d535360b14a931bbc393d51a359", + "python/sglang/kernels/ops/attention/flash_attn/cute/pipeline.py": "71f7416f99bd187758e940d51094e881a0e485c96d5fad5224830c7d5fa1f846", + "python/sglang/kernels/ops/attention/flash_attn/cute/pyproject.toml": "ab14226518b1a9121bbd2ac19794d7babebf1a89a2e25790e94ea8f2a397d646", + "python/sglang/kernels/ops/attention/flash_attn/cute/seqlen_info.py": "e2444eb09131f12dddf4444e54985e60435b877012ea90e73ae4b8da6483e6d3", + "python/sglang/kernels/ops/attention/flash_attn/cute/shearing_bias.py": "2c1d13ab9b569a6b2309098cac4f946c4971c34158d13d563f1de28a3acdd195", + "python/sglang/kernels/ops/attention/flash_attn/cute/sm100_hd256_2cta_fmha_forward.py": "6d315ad3f40404b0da688f57bb481bbe0766a92ff6b4ffdcb5b35686b7c0072d", + "python/sglang/kernels/ops/attention/flash_attn/cute/softmax.py": "b9bd63eb9f27be36e60e7c3040eefe9f6a5967051086b752e80a005513e4d268", + "python/sglang/kernels/ops/attention/flash_attn/cute/testing.py": "e83f8804a1198f967267cb3b081bc8cc3bd1b4e7d50a7bf04b6e2bf020956cc7", + "python/sglang/kernels/ops/attention/flash_attn/cute/tile_scheduler.py": "e6d1b4ebd9708f01cfb5e12f4aa54dc9f7d9b15d7a92c93a28faaf9407a7102d", + "python/sglang/kernels/ops/attention/flash_attn/cute/topk_gather_kv.py": "f1e226cb2552c6cc1ceacf706a5c5ac40b39ad7ddd2350136e2579491199dbe5", + "python/sglang/kernels/ops/attention/flash_attn/cute/utils.py": "9ca44a24082e440b13afa5c6f18fb00cfeddbf6f79d1e5cc5274eb9dc2543a78", + "python/sglang/kernels/ops/attention/flash_mla_sm120.py": "f80df68c252a8c8960f96e97d1ae9d89825358ad286f716f7d8eb66300c29495", + "python/sglang/kernels/ops/attention/flash_mla_sm120_triton.py": "37e6dd6dcab87a812b20a2ea2d35ae01a32cdb2e8dd67fa0ebbf799873c1e4a7", + "python/sglang/kernels/ops/attention/fused_metadata_copy.py": "34a84755371995870a179ce60a20a216a6f5aaced4640e9348df424203f83054", + "python/sglang/kernels/ops/attention/fused_qk_norm_rope_store.py": "0803a0e0a4b462b4211abe8b6cc51684a47cdcce8d8027b3a6aa13eeb7cc7241", + "python/sglang/kernels/ops/attention/fused_qk_rmsnorm_rope_gate.py": "d1972dffb4da33fab4410567f32359527bc5c32794c8d8015ffc39b9b9d80cc1", + "python/sglang/kernels/ops/attention/fused_qknorm_rope.py": "fc0131556a5b80bc6585caba6e6cccab3f4a44079e72bc7f93cb1381ebd64d90", + "python/sglang/kernels/ops/attention/fused_store_index_cache.py": "e5cb4a31c5a51fc0b413fa729f9712270f86c815853baa6183efe6861075fcf4", + "python/sglang/kernels/ops/attention/helion/__init__.py": "307fa361ccc4a4eb6347d5d3ca1199a17be821efa55511946609af5e763e8953", + "python/sglang/kernels/ops/attention/helion/kda_decode.py": "25803b176e1830355afc854fb1117bbd96637e7b67a6778aa627d90567260a7d", + "python/sglang/kernels/ops/attention/helion/kda_prefill.py": "200e95d07f68b1dd11c4d6b76f962dc98e383ed2af19ebb05740dc37b0ece58c", + "python/sglang/kernels/ops/attention/helion/kda_replayssm.py": "327b25962159b19f310330a2882be9517979997b7b0f1e869d04d4644b5a2137", + "python/sglang/kernels/ops/attention/inkling_attn_prologue.py": "463474b4a7617981611db3ff36790e95d2d98488defac193c6f70a1de8e5fb1d", + "python/sglang/kernels/ops/attention/inkling_rel_proj.py": "5deee148391d06dcb2e78b3f08cb6ece6d563c7c5b361f488f3ed90aacad472b", + "python/sglang/kernels/ops/attention/inkling_row_scale.py": "8abdff86ace18bfa9d90953d054dcde3cc28c306c6235d108e3bc29bff830924", + "python/sglang/kernels/ops/attention/kda_fused_decode.py": "0038e4b82f74ff2569a29e09b1b9f4a8d5b0008b2b6784a67152b190f36fe7f3", + "python/sglang/kernels/ops/attention/kda_packed_decode.py": "518855d312f44ae0ca1bc5f730fd5f26c98e731f9298ddb1e493a3d46edebef2", + "python/sglang/kernels/ops/attention/linear/__init__.py": "121dd755ac7b2e17c9ca8bfa0892813d98ac8af6a96b865c37be5b7966713d00", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/__init__.py": "773bcce973a6496403b6e07413928903931da727520e680b7d1f51b2d97c36d4", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/kernel_h.py": "e751896358a46abb7e338847962b1fa1a12f5c99979092a54bb719c61dbcb126", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/kernel_kkt_inv_uw.py": "f5743c4a14bdab8baf6aa79ed7846931b2afc883b9f58dacf7339e971116bf71", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/kernel_o.py": "c06b292daa82e720c4c6ca0ee03cb1d84c851e05e95f795adea4ffffb4df4333", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/__init__.py": "da6231a532f3bca80336e020e10ee5e099ed9ff39e27548fc9aaabe51631e6b7", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/kernel_h.py": "c7f6ae3771d09223c61689649cba1e9d87656b3c75115effdb67ce1e62fd7842", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/kernel_kkt_inv_uw.py": "115feffa986944f3e538cd47403f738e6060c8c9ab3930b673c79f1b7ed16a98", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/kernel_o.py": "4d9cc537c45dafffc2654a9851bc6213bec267ba7dd0895ae9377b102b896f5e", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/prologue.py": "72c1b42d256bc797d291bbaae80493206813beccf098b99cccd4e145b4807785", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/Akk_inverse_lower_triangle_bf16.py": "418208ba8acd2644750413ac223b18423a45f8fdc3aea2714f6987ada8e991b2", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/__init__.py": "04282eb62222296bf6778f01eae374aac1d0fa185da63498898dfc55fe504a3a", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/chunk_fwd.py": "e70269de406548d9ab0e4180a293746e9c7d3fdb687fc9ad45cda5c3c414e88a", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/fuse_k4_only_persistent.py": "79398ed857a586dad6e71fde4cf64b22006941e48d929b503e1b43fd875c279e", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/fuse_kernel123_persistent.py": "d9c79963c50a01704c306965585bfe2f41b89f2e77c746144fa87967fd58c4f6", + "python/sglang/kernels/ops/attention/linear/kda_ptx_prefill/__init__.py": "5967689a59d9eec6a188fea05331a3c554ee38e9b4de590310f090231eb777a1", + "python/sglang/kernels/ops/attention/linear/lightning_attn.py": "e7c81f873addd1e66f1b6ca829f13ddea1cbe97b54702f42c10971c8738f7ad2", + "python/sglang/kernels/ops/attention/linear/seg_la.py": "a5a52db38a754a2358984022bc0c81a027376cc6b8c14c5f719799526f4e7e6e", + "python/sglang/kernels/ops/attention/log_scaling_tau.py": "a879bd967980d4c7a9cfdb084c23aebf117d6324827fe5b526b5736339a04302", + "python/sglang/kernels/ops/attention/merge_state.py": "bfd9c3d356b97939e4c19c4cc0446daeb45f0b9aece86c6460ea44ae400f7182", + "python/sglang/kernels/ops/attention/metadata.py": "8301be5035f976e02e91323fb469f0e925193ca4a25a39cf25640d50c66f0d29", + "python/sglang/kernels/ops/attention/minimax_decode_topk.py": "3e773a7cc4d20a05585993242d10d5fa0e59a16cf06b4c31596ebc97308eb090", + "python/sglang/kernels/ops/attention/minimax_m3_qk_norm_rope.py": "e782750231f136aa4d606c1b06fbaa1f9c66d2ac9a0a97900b75ab2268ef63f0", + "python/sglang/kernels/ops/attention/minimax_qknorm_rope.py": "b97f5a99b370e6b7e561f68b29e3d56755cfdb4f62dc46d3272adaac52637a23", + "python/sglang/kernels/ops/attention/minimax_sparse/__init__.py": "891d49998a7c1bf8dcc77139b4bd6e1702fe40c17efcc315895af5e307ed3c63", + "python/sglang/kernels/ops/attention/minimax_sparse/common/index.py": "f7141f5d82e92f88533ac3a4ee7001cb1c2181f1f0a8b487c41da28646f9484a", + "python/sglang/kernels/ops/attention/minimax_sparse/common/utils.py": "7dd6ffa28fcc14374cc2d7006c884217300b344fe544e56d8bbc662c1a9af3bc", + "python/sglang/kernels/ops/attention/minimax_sparse/decode/flash_with_topk_idx.py": "84a9816213d65af954a712faacd0e44045aeb60376ccf2bc735f6e1f143be6f4", + "python/sglang/kernels/ops/attention/minimax_sparse/decode/topk_sparse.py": "a7ba7bf7919a7faa02bdd2888f939e7648c6b84bdd6b6616c28b2aa8fc28cbc4", + "python/sglang/kernels/ops/attention/minimax_sparse/prefill/flash_with_topk_idx.py": "e9ea1ab4e617d261752c49ce40650ff561dd05068d410f99c82270d3daebf87f", + "python/sglang/kernels/ops/attention/minimax_sparse/prefill/topk_sparse.py": "1bc59d10771c5f4ecf98b0addd50e7de88cc7aeeddb9121532ccd259458c3688", + "python/sglang/kernels/ops/attention/mla_kv_pack_quantize_fp8.py": "dfab3349c84cc1ed458ff18253952a0dd88ad67798e0f90b1d37d84952cccba7", + "python/sglang/kernels/ops/attention/mrope.py": "5d42bb01f7ceee189879678054e3023c0c34130d75543ce242da7cd14ebb7cb7", + "python/sglang/kernels/ops/attention/nsa_triton_decode/__init__.py": "7b1934f54d88e22c722df8986d7ae30c4609d19e3b257af13985c14aafbb07cd", + "python/sglang/kernels/ops/attention/nsa_triton_decode/triton_mla_kernels_decode_fused.py": "9664d16537fee95b0e50fd24d14b8f12b8aac495691aef2e9895654952f707f5", + "python/sglang/kernels/ops/attention/nsa_triton_decode/triton_mla_kernels_decode_optimized.py": "7eba46e5715be8584edd1403cf8d9088277bd4d8679737e31221d1966c437234", + "python/sglang/kernels/ops/attention/pa_page_table.py": "f21bf6bbf7ceb104bfcf3f0b9a4e4308a8526dd3f08fc1d98310b99518ad3daf", + "python/sglang/kernels/ops/attention/pad.py": "805e534b8533092ae375f7186d5bc35051abbfd9bff38e4238df41d9ab2d5ea4", + "python/sglang/kernels/ops/attention/position.py": "5b0c61b2bd74d4eeb1d3fa21dfb37c52838ce3533701c4f9f66f6031fdabfb17", + "python/sglang/kernels/ops/attention/prefill_attention.py": "eb158c4c03e69091eb95a1bce093c9b054ac1ca5aab12769063d2e84630ca7f3", + "python/sglang/kernels/ops/attention/qprep_bf16_fp8_sm90.py": "6b76a8f3c6fe6a2588f78cf2f3af0b23529bd9d2dd36e305a2dd2c99d25ed628", + "python/sglang/kernels/ops/attention/qsa_indexer.py": "2e413f99a9c5e475f98529691f1dddf7b59061ff234e107b1894e96e956a54cc", + "python/sglang/kernels/ops/attention/rocm_mla_decode_rope.py": "43e72631dde538f70478b8f31ec9298561109f772538826c6ed558b3a41473df", + "python/sglang/kernels/ops/attention/rope.py": "079a4d99dadbad673159bdb7ec9231467a4ff6c4aa63a40850022e61995a70f9", + "python/sglang/kernels/ops/attention/rotary_triton.py": "49b3a2ca2784b4ffb0773947d2e26055f55a520c9cd847b86bcc3f6c2bf94d05", + "python/sglang/kernels/ops/attention/score_mod.py": "01f6e619d93d1f025940ffda81f39d36ce31cc8608bc7d21c923979d41ee924a", + "python/sglang/kernels/ops/attention/set_mla_kv_concat_q.py": "0b56dd69bc4d5975f7b20fad798508eba5d5230ee04bf8623f3a9f5795578a85", + "python/sglang/kernels/ops/attention/sparse_mla_q8kv8_prefill_sm90.py": "0ff15d46709c97554652c6052d67832fc234376752bbdd4ef918773b7e033131", + "python/sglang/kernels/ops/attention/triton_gdn_fused_proj.py": "c3a7595605ff253d9ad46018bd123d7d1fb10002a3d556fb6bc5d0b323e04bc2", + "python/sglang/kernels/ops/attention/utils.py": "649ba76f5997dbb95abacf9b32626e3349b1156402f5acd30a15d741888fefa7", + "python/sglang/kernels/ops/attention/verify_mla.py": "40b1dbee180ffc289977953a448979088b4a99f7eed8b2cc0b04a41dbd84aa59", + "python/sglang/kernels/ops/attention/verify_splitkv.py": "0c2c4009b3553e13bcc4ae1e0e375aa5c96c48e6c96ab9a475a3e2d874c3c6c6", + "python/sglang/kernels/ops/attention/vision_rope.py": "d0e27aca64cf83cb90548d9e931835d44046da8178f216c8fde81befdd732194", + "python/sglang/kernels/ops/communication/__init__.py": "f9a34481689fa042fc994899cc4110f44f41c8f9c51211e86af7bdf5f64b4b02", + "python/sglang/kernels/ops/communication/all_reduce.py": "a10b7bc586399ae06acd2766b74c27ae309ce28b64ae982755bab1c26ea8a1d2", + "python/sglang/kernels/ops/communication/inkling_all_reduce.py": "b323b96e8cae729484d70d418326affaae2c78f4e71582c98421e78ab9e17184", + "python/sglang/kernels/ops/communication/inkling_ar_fused.py": "30cfef8bf611749121715f8c5bb5c1b9d22517ae6884faf00798628571d36057", + "python/sglang/kernels/ops/communication/inkling_ar_scattered_sconv.py": "ccc90e7dbb8a2b9dae4d61fc30b259c9651116ed4178051b9b40a74031af7b06", + "python/sglang/kernels/ops/communication/mp.py": "8e229fe09ad4e938c946bfafc0bce6e75457f39931ad264b0332de76863e91ef", + "python/sglang/kernels/ops/diffusion/__init__.py": "48a131d5c1ab2526dde5c0bddd9c563735521d745d47ecf0fa86f53d83110f33", + "python/sglang/kernels/ops/diffusion/bitexact_gate.py": "a9a5bd028d32117f426fa4bca29222f999354d1e1c426510597243a84dbcc840", + "python/sglang/kernels/ops/diffusion/causal_conv3d_cat_pad.py": "16df0e84da819237ee0b689a18fd3769bb30b9fe3b399820f48c83883e332508", + "python/sglang/kernels/ops/diffusion/cutedsl/common/norm_fusion.py": "8e4feea1ef0a026fef873136c2cde82ce5cf823357ebc60267e770d89c71bfcb", + "python/sglang/kernels/ops/diffusion/cutedsl/common/reduce.py": "90b8a0ea9a857849799ae8c17e3306271b68156082fcc4c257b28a1d051e7e2e", + "python/sglang/kernels/ops/diffusion/cutedsl/scale_residual_norm_scale_shift.py": "db66599cb0d4cd16aa62b8c775218de5da95b00a46ff448b78ead3e230e98bee", + "python/sglang/kernels/ops/diffusion/cutedsl/utils.py": "5bd351c9360fef8596b5cd3cca269d2dd60ca3d1f3218f1149948c6549d92bb8", + "python/sglang/kernels/ops/diffusion/flydsl/fused_residual_norm.py": "f1317cd8ee0ec111739d51931444d0fa06b1cfffdce18a098e44f485bb820ced", + "python/sglang/kernels/ops/diffusion/fused_gate_rmsnorm.py": "8a6333c6f65e8cc54d3dd7c581cff06fe65b9642a37aa5075c5664ef6472043c", + "python/sglang/kernels/ops/diffusion/fused_linear_gelu.py": "f76926ea975e5cc91977f4dfb2651f7b09bab6d9b681b7584ececb641a8d2d14", + "python/sglang/kernels/ops/diffusion/fused_ln_modulate.py": "10de436aac55149942babcf0b59ebe53180c59ac0137abd6be6faa587c75dd1d", + "python/sglang/kernels/ops/diffusion/group_norm_silu.py": "1f5d6318c41d3821f915fe4790c0f7935977636b5d32d6a96d2d55afa4836498", + "python/sglang/kernels/ops/diffusion/hunyuan_qknorm.py": "d6023352ebd69bceb57330e2406c72d0a2329b7c57788473c7145eb98604851b", + "python/sglang/kernels/ops/diffusion/ltx2_qknorm_split_rope.py": "d4f8fd1d3f8d810525268ec0a678619ae7d8b13498a3838e7541b82f574cf6d3", + "python/sglang/kernels/ops/diffusion/ltx2_rmsnorm_modulate.py": "98e170af81879494ae17ccc4f356be5d04d9f0adace0715c597e0a651478f41e", + "python/sglang/kernels/ops/diffusion/modulate_scale_shift.py": "59a5b7512980429ea2b08d8479ea4cfd94f81709bade49e3d83cef319846e8b5", + "python/sglang/kernels/ops/diffusion/norm_scale_shift_native.py": "fe63af2ceece6a0960c21536b964e5cb0d8fc497e3c171f130235e278356fb40", + "python/sglang/kernels/ops/diffusion/qknorm_rope.py": "53700c9b76253b84e043ef52c35c1b65ba05b68dce3f84740c6e4bcd3f2591e5", + "python/sglang/kernels/ops/diffusion/quality_gate.py": "b83cda11bd2083dd5bea7cb09c79dfee11697832f23125faf243d0438482b975", + "python/sglang/kernels/ops/diffusion/render/__init__.py": "c7c1501d0385ccb9e500061b6e087ac3965367ce82751d9f6c5d94026135f54c", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/__init__.py": "f24c32c50fbcc6e324689f74d629929d95b76ce64b5901be23bcf7bf8d7fec26", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/rasterizer.cpp": "618007e9eabca702f43ff0f7499dfec9fe8d93129f6d90deb2a20299e51e07da", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/rasterizer.h": "0129c0d8d7d5f35ccc4f6e5c3a1a6e68878725ddba380085cb0610969b446e94", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/rasterizer_gpu.cu": "23139f3ce94197170e068f696de9dc50ad1a64b5cfd87c066f3d208ad191a4c0", + "python/sglang/kernels/ops/diffusion/render/mesh_processor/__init__.py": "3af13541c7aeef8f92bba2e7276bdaf5824308008c0f22232389cc5a438e4141", + "python/sglang/kernels/ops/diffusion/render/mesh_processor/mesh_processor.cpp": "5a222e19c4707394cfb868f5722f7b806e5100b0e5c9d364ff7397bada00e610", + "python/sglang/kernels/ops/diffusion/residual_gate_add.py": "7a461f604c9939204fe825936017a71faa10395edd150890920f234b7158d230", + "python/sglang/kernels/ops/diffusion/sparse_linear_attn_kernels.py": "c92e69aabe9cf122f25213951768d2bb67199e5d401a787271840ec7ba6166d7", + "python/sglang/kernels/ops/diffusion/timestep_embedding.py": "f4d1128cb425bf1de9327309e121bfe0605afc9f4d869ed2345f802450df1dec", + "python/sglang/kernels/ops/diffusion/triton/causal_conv3d_pad.py": "f2f0bdd7571ab72a0891d596f09b3d2eae211e4bb83654deeb8db5e7be004d50", + "python/sglang/kernels/ops/diffusion/triton/group_norm_silu.py": "03a0e073cdf7a8ea5111393f952af511dc98849c2545d40da829d11e928fbc1b", + "python/sglang/kernels/ops/diffusion/triton/group_norm_silu_twopass.py": "edfafcb3c51bc47606ef41f8c2eb247f29d52986b421847785a12055da742d13", + "python/sglang/kernels/ops/diffusion/triton/hunyuan_qkv_pack.py": "d12d307ed3c0365f1e36e3e1ce8b59a0618522a834e576dbcc618e19105e4408", + "python/sglang/kernels/ops/diffusion/triton/indexed_modulation.py": "a9771bb71b6a34ac9f28f55b616684d209e68c0165d70cb50f788b470dbebef4", + "python/sglang/kernels/ops/diffusion/triton/layernorm_modulate.py": "d82e26b94ee83bdbe76ce50dffed8e7ff33361891002f97588c8aea91bdc44a8", + "python/sglang/kernels/ops/diffusion/triton/ltx2_ada_values.py": "9817d7593a60e9eb959f8b80673dbf00260250a3bfc53131e00f8b11290b6bf9", + "python/sglang/kernels/ops/diffusion/triton/ltx2_rotary.py": "16feb7045fa6a5be7ae42191da396d97d075b1ccff7692049f4dfe205bc8efb1", + "python/sglang/kernels/ops/diffusion/triton/mps_fallback.py": "1a24599b415bbb1b8cc0c4be7e650741a0f9b0a34e83b26b8c632463cd429c46", + "python/sglang/kernels/ops/diffusion/triton/native_bf16_rmsnorm.py": "e5f32428b41f771f63e81c1bd0118520d8102069a0564be99937aaa92a75c802", + "python/sglang/kernels/ops/diffusion/triton/norm.py": "aae6388237a26b33f5ab63dc9795a654edabd984f3814a00b2fe695ea3e0741e", + "python/sglang/kernels/ops/diffusion/triton/npu_fallback.py": "daa3d71a16a20024d88b2ddc509e0dcd305e8acef994e251b0c446bd0c7ee478", + "python/sglang/kernels/ops/diffusion/triton/numerics.py": "bb2a5e18c36f92107382a3e8fd23d345bd4b6df879a34721ba79b2c0fc47b6e7", + "python/sglang/kernels/ops/diffusion/triton/rmsnorm_onepass.py": "e1f80c95a8e707135e58e1f8f8ed95006b49e25630b80bec7804e35abde0af34", + "python/sglang/kernels/ops/diffusion/triton/rmsnorm_scale_shift_bitexact.py": "4cbecffe13479ed25803e95ac390a7c2b0263753cbb53d8886647793eb0542bb", + "python/sglang/kernels/ops/diffusion/triton/rope_rotate_half_bitexact.py": "ab4924019695c20bab2b2808370a83e0c3ed7934fda92b2cfdd11095661e9598", + "python/sglang/kernels/ops/diffusion/triton/rotary.py": "b1d04f149681103315e79c5447fdad36f49b9989cd603015fdd6d8e7b4972587", + "python/sglang/kernels/ops/diffusion/triton/sana_conv_post.py": "df2a5d8a8e6b0efa5aae8f58c6fab1ce7983be12cacd6cec1307b5bfc29195e5", + "python/sglang/kernels/ops/diffusion/triton/sana_wm_gdn.py": "614e1b1bc48600791883d3ed7b7e2db1044768d2495fd41079b7ddb11882c33a", + "python/sglang/kernels/ops/diffusion/triton/sana_wm_gdn_chunkwise.py": "6222295886ad7f4162e47e5b6940f3d2167b8be3e716b45fc7a85fc792680dea", + "python/sglang/kernels/ops/diffusion/triton/scale_shift.py": "21fd89999067c57b28c6f912cc2875e220572c850403a38f74ef6110e870059a", + "python/sglang/kernels/ops/diffusion/triton/silu_mul_bitexact.py": "a5da4c5e6e1c0b75f88047a2ea823c9ac1ad33659691994ac84e1bfd696e8e10", + "python/sglang/kernels/ops/diffusion/triton/torch_fallback.py": "6b2a61c91709aca46f0bb8e9634947c3c623ab9cfe53c609c4f0ad14c85b6101", + "python/sglang/kernels/ops/diffusion/triton/ulysses_qkv.py": "96e589548c530d2de091f07a4497f52efe09edb7029c5b0dc413e12da8ca8c4e", + "python/sglang/kernels/ops/diffusion/triton/varlen_pack_pad.py": "23077c268664919b1bb08b8c863e54a98e4d8ddaa9ec66cc936920942c35a62a", + "python/sglang/kernels/ops/diffusion/triton/wan_causal_cache.py": "0cf15e3897a74e9ce6351f469c2b39b4763c7e569731ab2b108dd3c03b5be959", + "python/sglang/kernels/ops/diffusion/triton/wan_rmsnorm_silu.py": "e16e33f202e7b88bdc0a2507c0b04b6d3095df46cd2c24b5a1816a66a1a11abf", + "python/sglang/kernels/ops/diffusion/triton/wan_temb_table_slices.py": "5c77ad9c0fa0b62589b2e49706d2c27d61df933d57e46d8e0de7b5cd019aceff", + "python/sglang/kernels/ops/diffusion/triton/zimage_native_norm.py": "957e568f47910de4efa9d9a848ad51ac4ea94e6203bfc347086f84a25d189caf", + "python/sglang/kernels/ops/diffusion/usp_relayout.py": "4cf547bbf6c3b08e2606f01add0af522f1b2c90ea40dc489617fb58f7c86a893", + "python/sglang/kernels/ops/elementwise/__init__.py": "c56d53ff6b763fb7f8eb9729b04ba8d4bd69fd62551d57c77af60a9f5b7d0db9", + "python/sglang/kernels/ops/elementwise/add3.py": "48f3d6656705e38ae685bba0b5a873db8357108e299a9f854289ff935456e587", + "python/sglang/kernels/ops/elementwise/add_constant.py": "9a6ead19ee80eee6d8323b8342737a160620c6a39164ddacee686d4c243e3d48", + "python/sglang/kernels/ops/elementwise/elementwise.py": "2592f87a688dc86f217e5e35bc88ba4c49639d5e3b52b3a4132126329f079ced", + "python/sglang/kernels/ops/elementwise/fast_topk.py": "77780478c7b48517fbe9240d62d8a71371203a1acea42d27d44022cc1e9863be", + "python/sglang/kernels/ops/elementwise/hc_combine.py": "13b7ac26cfd039495592199b2479669621503695d9f30232d1b9ec7f2f9772fc", + "python/sglang/kernels/ops/elementwise/hc_mix.py": "363c5371c5c940d802f09c8f72565174cf7cc979f638dc7657def71316d16e3a", + "python/sglang/kernels/ops/embeddings/__init__.py": "342660f1c240300f60785a0eba6927dc834c56c40e44ffa8b96103e76e5bfafb", + "python/sglang/kernels/ops/embeddings/vocab_parallel_embedding.py": "7766e50514e621317fec277fd5975adc469d70ab2951722a99d56afbb6dc16d4", + "python/sglang/kernels/ops/gemm/__init__.py": "4235aa78f78a59493159c0121f7609c91d8293b4729824a40a95c350223940bb", + "python/sglang/kernels/ops/gemm/chunked_embedding_lora_a.py": "1189c7f90730dbf62f0cbcbac07a4ff858a1871a2ab9181aa5d73ddf2da8403e", + "python/sglang/kernels/ops/gemm/chunked_sgmv_expand.py": "ec3927c0c0319fd030734b5cfc480ebfbded87e1508fcefc6fe1221a8988948c", + "python/sglang/kernels/ops/gemm/chunked_sgmv_shrink.py": "f078bcb16ad462933c6d4805f6f0656ec2ec3811198ab8ee5aa9bfe00c166595", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_expand,K=1024,R=64,S=1,device=NVIDIA_H200.json": "4dafa32ab78835e78d67e9a92f0fa788a32e28ea7c3d2bd4e70771d813bdf50c", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_expand,K=4096,R=64,S=3,device=NVIDIA_H200.json": "1656bcc75507725947af06940bd290b0fe5cee1dfee288ef4cf5a35202d85dd1", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_expand,K=6144,R=64,S=2,device=NVIDIA_H200.json": "b5dae0b58af37bec41a5d2a61ac9f0a7ad6f965b2096eefca9023c9b3e103627", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=1024,R=64,S=2,device=NVIDIA_H200.json": "637806800dbf01eba94f67067db60c9179b8016909a36d63bd4e43eb09ec356e", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=1024,R=64,S=3,device=NVIDIA_H200.json": "2d701fd6dd639b389826903177910ac727561da3e4e742d2c8eadabe6aad641c", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=2048,R=64,S=1,device=NVIDIA_H200.json": "c04d42f40c70acb8383f430226c88abb9af7d57ade0ab0304c313588a8e0b547", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=3072,R=64,S=1,device=NVIDIA_H200.json": "72fc03f2163375f242dfd5e6a8eb2f9c5630b8fd0b1ffa46ccfa16f98ef52e9e", + "python/sglang/kernels/ops/gemm/cutedsl_bf16_gemm.py": "6217583a506217f5d001f4aac125ba9253c1a65ebb6f378ce98442c0d70e55e8", + "python/sglang/kernels/ops/gemm/cutedsl_dsv3_fused_a_gemm.py": "20a48ac344d9c82198052cdaca386c504fee6bbfbe19260b42a6d3df1f14195f", + "python/sglang/kernels/ops/gemm/dsv3_fused_a_gemm.py": "7eebd0e7c5c2fc3ec5afc283012c94990f7d8995c923ff3037e3dc0c79047807", + "python/sglang/kernels/ops/gemm/dsv3_router_gemm.py": "70a421bfd27b85680373a742e49829d3dfb392f736f609ca42b9eca982082c40", + "python/sglang/kernels/ops/gemm/embedding_lora_a.py": "44a704ebb8e084326d634e1f5697bb49c6bbd3a825790849da7f4c6c28537557", + "python/sglang/kernels/ops/gemm/flashinfer_pr4266_dense_bf16_gemm_sm100_splitk.py": "ff7fc374b440218d3261c94c54be04efdd7fa549780746ac0954cb88986dbaf4", + "python/sglang/kernels/ops/gemm/fp8_blockwise_gemm.py": "86026c90a00063193fc848cff90067b3976c32255e023d6cb52ca3c3afc60b6f", + "python/sglang/kernels/ops/gemm/fused_a_gemm.py": "a7e41c536e4ad55ab04a4456a6a52bcf201707c77e51c320de245d28e361e55c", + "python/sglang/kernels/ops/gemm/gate_up_lora_b.py": "a1444cf7b161e5ce7801453ab719006e0f59d9876d293f8e97a3e8474586587e", + "python/sglang/kernels/ops/gemm/kernel_utils.py": "cdafe7d0763c7baeeabf141bbe9d38ee75ea3631dc157d9263097bf37c1db6f4", + "python/sglang/kernels/ops/gemm/kv_b_lora_absorbed.py": "59f8ea4af698f4ac2b47abb986f166f4d4930adf80cc72e630204d5b66c8543c", + "python/sglang/kernels/ops/gemm/lora_tuning_config.py": "aed0be9961f803cc6d4956e0e5abb0bdda960e859477e85007c925f24a1a7ddb", + "python/sglang/kernels/ops/gemm/qkv_lora_b.py": "57457ce0c29538c60e95f8c8a212e07726ade389460baafdcb1b6d230eb719aa", + "python/sglang/kernels/ops/gemm/sgemm_lora_a.py": "5d175ae4e9671085f24e298ed7ed3042e829bd2079eb8221fa3d3e2c0c04ecf0", + "python/sglang/kernels/ops/gemm/sgemm_lora_b.py": "266579cda8289e8c87c5411cf69a8fd7276e32b2b255328484a995e2d64b04fe", + "python/sglang/kernels/ops/gemm/sm120_online_fp8.py": "949793d24c9e166f46f173279e96541698153cb5d4765ed0e29d60d87e04df31", + "python/sglang/kernels/ops/gemm/tiny_gemm.py": "f975b4092e23ea26cdb62b07e3db41c68caeb293969ed90643a7b05da9ef65a6", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/__init__.py": "46a41f87b80b661d990f84ce9925f265ae3d833b378aa496822df31392bf5721", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/gate_up_lora_b.py": "a8d57f36f29d36284a2e0a9a045e36fb369e9a68681359254e6b58994c602c2f", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/kernel_utils.py": "14eab93e5bc85eeda76d679e422e95d48ad3fb3b7b86bdca728b83887e1aa829", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/kv_b_lora_absorbed.py": "d2e100d3af9711fe9fc9f8312e9990898397fcffcc55b8da8c4bbe2234d13b84", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/qkv_lora_b.py": "85a494048308de003890526ffcad00c4d6df6f3ce67a059147d7cca750a3a1f8", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/sgemm_lora_a.py": "db88315cd2db0b991273c00f9388953f0123df355faa7462f749bcd20fcadf03", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/sgemm_lora_b.py": "8a6453a9f32c23ba46b7800868b6b7392e23f50c5f367fc66f33963ba7624b5d", + "python/sglang/kernels/ops/grammar/__init__.py": "650612778d49fc2fc68e5641dab243c22ae5f73117f9d363e1477ed77847fc6d", + "python/sglang/kernels/ops/grammar/bitmask_ops.py": "5a34de9fd8aeb8558bce41359801d0641f7feda232e501fc5a37fe941f856a6b", + "python/sglang/kernels/ops/grammar/token_filter_ops.py": "7f78601f2f6143dfbc8e29c5aa4daf63e7d4002bef1c7e8b774cf7683d3f3fee", + "python/sglang/kernels/ops/kimi_k3/__init__.py": "d05bc02c371ab2ed217af119bc40cee853f7ef8cfa5204bd50d027f9dff86830", + "python/sglang/kernels/ops/kimi_k3/activation.py": "af6f58799eb172d39a350ad23440621915dd76dad5479339fbcfd550e3710cd6", + "python/sglang/kernels/ops/kimi_k3/all_reduce.py": "6e1d0eaeb4e8bf29f887c84140bde18691dd9cf38d89b1c4f409d18c757ca348", + "python/sglang/kernels/ops/kimi_k3/attn_res.py": "c851a9d2d3c3da409cc2ef535a9f94eb03bf8b4d4a47154c623b2444006354a4", + "python/sglang/kernels/ops/kimi_k3/attn_res_hip.py": "95ebe877ec7176f869e5d19997c92b0c57079b32430da8e264ea13809aacc51b", + "python/sglang/kernels/ops/kimi_k3/configs/sp_collective/world=4,H=7168,device_name=NVIDIA_GB300.json": "64fbfeb5b29e1eb1870692b6fbe7e74a1706c12742c4cfc69567a27607aab8f3", + "python/sglang/kernels/ops/kimi_k3/configs/sp_collective/world=8,H=7168,device_name=NVIDIA_GB300.json": "219b532137b089b3ec9693fb3c199034b7bc44d1a6a97a9b5c395bc5967a9b10", + "python/sglang/kernels/ops/kimi_k3/gemm_ag.py": "db348314282a1c38cf81149db702fd2e162bb2634c1cf2edf3159391b95b0a64", + "python/sglang/kernels/ops/kimi_k3/gemm_ar.py": "dbd6b822687a4dff30511202a3ad08853093cabbe4f1086b9340d9c5f9721ad9", + "python/sglang/kernels/ops/kimi_k3/kda_decode_mtp.py": "2a6c135ad98b823243d8492b81105df07f3c72db908c873fb0bbf25171664adb", + "python/sglang/kernels/ops/kimi_k3/mla_output_gate.py": "155c434b7b5001e9f4778b0d6bc2dc7ad2cb760b93e050ca2241a91ded5f78c5", + "python/sglang/kernels/ops/kimi_k3/moe.py": "ba62b68696260912ff1c7eceeb4f255f61411b72bc9071331934345b954164ef", + "python/sglang/kernels/ops/kimi_k3/sp_collective.py": "ef40307391fc97b15a39a93fa2ac15682b291e354c6fc5bc5a55efc193abd48c", + "python/sglang/kernels/ops/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/ops/kv_canary/consts.py": "6bbef700edfed32676d101c4e29f45ca6d7c9327019d8f3b0d01be4e83d3a83f", + "python/sglang/kernels/ops/kv_canary/plan/__init__.py": "f89a48c8cf947b6f98762eee9f338ee20cd8dfd1483c51e27f1c688d05eb5907", + "python/sglang/kernels/ops/kv_canary/plan/api.py": "8906795df412ba2b346593bc4825a40442bd3c1d8894a8c6f20a724af4cedb64", + "python/sglang/kernels/ops/kv_canary/plan/entries_kernel.py": "8971648dd987b7033e5fa111e9c6e3099afb2784a814fb0a675756c83b6ed222", + "python/sglang/kernels/ops/kv_canary/plan/offsets_kernel.py": "b2de9670740afb283edc8b6c33c8e77698a6d4f255fde30469b68d94dff7c800", + "python/sglang/kernels/ops/kv_canary/plan/utils.py": "d4f55a6637cf5d75ee6b32d0a26b7a60fff8d69d38b26f40653c45d7243fb11e", + "python/sglang/kernels/ops/kv_canary/plan_ref.py": "b2a3670f1f882a42f7459006b7309dc902e8ef5644c9edd372cecc73f02f26cf", + "python/sglang/kernels/ops/kv_canary/scatter_req_token_ids.py": "c14ef46d47a3b3039da885d349448c8091f8760b95a00a0fdca136a0573d1e0b", + "python/sglang/kernels/ops/kv_canary/verify.py": "ec4e777b3c6147b3e077fce68747161484662f570eeff0a531fa2d525f3e7147", + "python/sglang/kernels/ops/kv_canary/verify_ref.py": "03f41f0419bdda26c76b8a8db53ec67ae023fc76ef04b9a90fea0e48c19b9047", + "python/sglang/kernels/ops/kv_canary/write.py": "6e3c8ad4ab1dfae483070cf966a244bf3bf86382d346ef63d2da4cee6df2d4ce", + "python/sglang/kernels/ops/kv_canary/write_ref.py": "39c31b22ea0e908842f557770cc25f1f98ba42ac8ba1a8f79bf349dd18df6e8e", + "python/sglang/kernels/ops/kvcache/__init__.py": "ff8b033d0695a90a804b80116e08e93535013a2af6d4e4cadbfe6ed0ecfd921e", + "python/sglang/kernels/ops/kvcache/aiter_unified_attention.py": "4b295eeb1d77a7e40b3aae690ebdbfbe46258c90525317994a2b6f3164243a8b", + "python/sglang/kernels/ops/kvcache/cache_move.py": "eabca144a116c58141342d6dc6471e8244216776a3b1692aae6abc9e73d7b75a", + "python/sglang/kernels/ops/kvcache/cache_ops.py": "8965e5242a80e12cca326272a67ecb38eb36f2e6d3ad41dda22035861e59458a", + "python/sglang/kernels/ops/kvcache/fused_fp8_qkv_kv_cache.py": "88755d730cec527a7135aabff1c57779d11752ea7b286343c47c285a0be39fa3", + "python/sglang/kernels/ops/kvcache/hicache.py": "9b8e174c83d10743795f14ea5118abb4be86d895c8df238e7b163134883eee2f", + "python/sglang/kernels/ops/kvcache/hisparse.py": "f4b3958f0ed4c154fe39cc1fae217b2b80a7e1547c186d10105098af4ed5c566", + "python/sglang/kernels/ops/kvcache/kv_indices.py": "9d676688776c6c30883feba9f87a470ae364ff04e6cc1d51e5b2e7d2d45b6303", + "python/sglang/kernels/ops/kvcache/kvcache.py": "9a2101696be86275ea15725e11f8fe3ac55d560876ba66d81740236a916e47b6", + "python/sglang/kernels/ops/kvcache/minimax_store_kv_index.py": "dc8cf08f18f287f3a01c4071eed01d0186f38a4b7cd0657fb25c78922b20dbe5", + "python/sglang/kernels/ops/kvcache/mla_buffer.py": "3726d1c298e50cfcc3704573ffc001ac9343294480d331552e22f907bcf546de", + "python/sglang/kernels/ops/kvcache/rope_cache.py": "3aa237838d71d235a6df3ea41a91921d0450ef8fdf207cc340da03a8bd577f6d", + "python/sglang/kernels/ops/kvcache/set_mla_kv_buffer.py": "0cd007ea7fc26c2e3c84c0fdfe4caaf65b8b71d2b1b3d5775bc4d7d1b49bc2ce", + "python/sglang/kernels/ops/kvcache/triton_store_cache.py": "6c4b892865a0c198e9b980d03a8e7b75803cbc0b0a565ec0f1e3533bc8db6584", + "python/sglang/kernels/ops/kvcache/trtllm_mha_graph_metadata.py": "f58a0217a26dca700d1a91d73fdc069643b1870f6312c1a7745b0fb2dd81fecb", + "python/sglang/kernels/ops/kvcache/trtllm_mha_page_table.py": "1f47077656f99720d37aead72242ec7ac8dfcc1bd2c331c95118a3a9f6c7bd6a", + "python/sglang/kernels/ops/kvcache/zero_pages.py": "765e5ae8b8fae7ac7ea9c2c3a4e361cbd35e07d052adcc60f98da1e2a788a5fb", + "python/sglang/kernels/ops/layernorm/__init__.py": "50106dfbcc81884ec1ea9dc3b7522423d196d731fd051f7992347ed260889967", + "python/sglang/kernels/ops/layernorm/fused_eh_norm.py": "662a38cdbfde51eeed8ff07af486affa467b93a2f051eba1cb7f7b9f7b468281", + "python/sglang/kernels/ops/layernorm/gemma4_fused_ops.py": "f9d8c7c3ea71afc1341c2de02807b8fda94e418248bd9ee404b15b3337463ad3", + "python/sglang/kernels/ops/layernorm/grouped_gemma_rmsnorm.py": "ddda52c6d0bbceb817e83815a8e89c54b408a1b5bc238df7df81e2b974dfddc9", + "python/sglang/kernels/ops/layernorm/mhc.py": "d1bf39ee70af251ae539de44fd56671f95d76bcdbb02f816d5f3f25ec55634e3", + "python/sglang/kernels/ops/layernorm/mhc_head.py": "a82d40c36a0c9b40285116cf1701f5e449b895eb48f18b00ab6600ef53537826", + "python/sglang/kernels/ops/layernorm/minimax_m3_rmsnorm.py": "e7e81662d1989eacd46b757b0240111ef9caae31a77fb3035ca2b9196307198d", + "python/sglang/kernels/ops/layernorm/norm.py": "6105bf76253528190cae48c77f2d62315debf3c201950337ab7ae2273a3a7d17", + "python/sglang/kernels/ops/layernorm/rmsnorm_hf.py": "9933deb3f66af9e04c125727819d47b392cd804f509d04bd23484301efac6d87", + "python/sglang/kernels/ops/lplb/__init__.py": "cc59c1c96943b4860375c4d45b2bdfd668f653613cccc1dca62e4cf38766b1d7", + "python/sglang/kernels/ops/lplb/cublasdx_solver.py": "936110bc5799cc43ac1e50c65e03a8099bdf057a24b75c506b42e1aaaf79ad64", + "python/sglang/kernels/ops/lplb/cuda_solver.py": "cada08e6b9c6e421adbad7b37857d97dcc40d0fc96074d74c52bab2a889fac79", + "python/sglang/kernels/ops/lplb/shmem_budget.py": "360bd9171b75299b4f5563d6fd2d1ca2b5f7012df68add0a93a575432a95449d", + "python/sglang/kernels/ops/lplb/torch_solver.py": "f8c4501c5fc51795b9ccf374cc9c803f314d6b9092be8c4634bb45dde30558b5", + "python/sglang/kernels/ops/mamba/__init__.py": "97bc4578cddcf40ce2badad85079f2446b3240281195dd2a8960606ba3518bac", + "python/sglang/kernels/ops/mamba/causal_conv1d_triton.py": "5fb01e6aafe9b9ddf1fc3adac49c2a09c8aec310de234e2b0d8d4f75f587bfe2", + "python/sglang/kernels/ops/mamba/inkling_sconv.py": "fdf8b125ad55e8964ae7cef273880aa08953ff51f8aa146c243fb68285ba9517", + "python/sglang/kernels/ops/mamba/mamba_state_indices_triton.py": "75f8ced02daa10b77a284e5cf8cf176ea417259ea09ae4dad51dd4c0c0d6c6b3", + "python/sglang/kernels/ops/mamba/mamba_state_scatter_triton.py": "67681aefc281375e96ea48fd471b14a9b1594c6496d53c3bce3e5cc026537abc", + "python/sglang/kernels/ops/mamba/transfer_mamba.py": "07a7649666ea0651b549a071172dc324b8bf97d1ea6cad23ff2ccf621cc63757", + "python/sglang/kernels/ops/mamba/triton_ops/__init__.py": "01af68cc89077d4152b2684f4553f53e5ed3e5767841fcb5c13265e76a416b34", + "python/sglang/kernels/ops/mamba/triton_ops/mamba_ssm.py": "fe453aa738428802bc7ca4dbf5afa653787bfb646434b73ef91376c028adf7f3", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_bmm.py": "27afe193a8f5ea7f51258cabfbd67200929be9526da8cd73a189c1ceb3dea37d", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_chunk_scan.py": "9fbd0140cf03a60effb215fcedacb742f04450ee1f11c9a0d4ea2953cf0a3e21", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_chunk_state.py": "dc2fed284d4fba3328b45e531a21ce61e94bc5895470acaa9a5ceb1a0fed1d24", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_combined.py": "0f98cd2e9a9d6f743d7d334ccd89b18f2336dbbaa5665bdbe4cd4d08024d9648", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_state_passing.py": "cf0460418fabf6035e0af6f3ebffa63d25d0805e135151f5ac378a27f1bbb7d6", + "python/sglang/kernels/ops/mamba/triton_ops/ssu_dispatch.py": "a6125c8c4268d7aeafb67b983cae4f0d3cd0cfc3109613504cf4075b2e888e11", + "python/sglang/kernels/ops/memory/__init__.py": "eb0efdf461a1c718a18c3d85872f15402d6e8d4762fdb624d6d0c2a02e99afcc", + "python/sglang/kernels/ops/memory/allocator.py": "ea84e0af085cf6821e6c4568516764da706aa9efd997f8d7a8dbaba8d97461a3", + "python/sglang/kernels/ops/memory/common.py": "a2377e0d262b8a527475477a7e76a3dd137ff8cd589f9af0067f5c23378a6aa3", + "python/sglang/kernels/ops/memory/gpu_tensor_hash.py": "0401f647b849a0f763e55f9f917dec78678f5a735aabb401e64801e49123a38f", + "python/sglang/kernels/ops/memory/memcpy_triton.py": "a81f299bb4186f9cae247cb3f5c97c8554e9ec7f248aa34266156964ca8a939f", + "python/sglang/kernels/ops/memory/virtual_slot.py": "3e11bc67d4169134a9b8c3984749baf89b5971d827bcb0a87cbb3ccfb01fab48", + "python/sglang/kernels/ops/mm/__init__.py": "8b8c0d9e89ad6a28d359ef75769e6496ed7812b6aef71031dad6e4a53eacc829", + "python/sglang/kernels/ops/mm/process/__init__.py": "2cd3d5d1285cd203e6c10bdd5efd5d32c79d6f64d4c1627c65ff519df2fde96c", + "python/sglang/kernels/ops/mm/process/image.py": "79870c590b700056cafff51814d892bc090a0d3dc73fffaea5ecfae266a1ae33", + "python/sglang/kernels/ops/moe/__init__.py": "907720e21482bba929cad791045c785d9885e1db1acd5bea3dfd5c15c2a4ea0a", + "python/sglang/kernels/ops/moe/configs/moe_front/epilogue,E=896,topk=16,device_name=NVIDIA_GB300.json": "f6140a7d1cf3b8f75c53cc41e7d4aaf4c8fe10b34189119ed4293d9419a56966", + "python/sglang/kernels/ops/moe/configs/moe_front/strategy,E=896,topk=16,device_name=NVIDIA_GB300.json": "c333815256dbe18a9043b16c66704498b00d392e1e6bdbade3b647180cd20af0", + "python/sglang/kernels/ops/moe/deepep_waterfill_kernels.py": "ff5685f930c3a630e3f72551d3b810d773c2f35bca5482104d77622d9dea443d", + "python/sglang/kernels/ops/moe/ep_moe_kernels.py": "e685835c09cf82a5d15481345cc8163f083bdf391e94f58d8398b073b77f62c5", + "python/sglang/kernels/ops/moe/fill_padded_rows.py": "18439c7bf44073acc136ff644052e9b9a0d76a2312108ff3d0a2203a251bc022", + "python/sglang/kernels/ops/moe/fused_moe_lora_kernel.py": "0042c5aabfee2bed6985a9e3796dbabe2426a9ec50fe9c5f23c7b48754e123b4", + "python/sglang/kernels/ops/moe/fused_moe_triton_kernels.py": "9c3342d3147e7d60a78a2c934111f0fc1becbb8df1d2d32aafc82e6c8a0b2e70", + "python/sglang/kernels/ops/moe/gate_topk.py": "9bbbe6a89810f6ea68a90dfed2dbf48da02dd1872eb51e2c9e5a9b5b5ebbe6b9", + "python/sglang/kernels/ops/moe/inkling_gate_topk_renorm.py": "b2da874fb42e04e5525e218db074cbb28fe42efaedf0488d49aa87150ac55c9c", + "python/sglang/kernels/ops/moe/inkling_moe.py": "0727ceccba5c74700ba47230f84cfbd937bd251018c505cda338bedcd162ac2b", + "python/sglang/kernels/ops/moe/minimax_m3_swiglu.py": "4e2cd1f047ffc5b5dd5fd20359e51dc31816d078adff5a8045260800231261ed", + "python/sglang/kernels/ops/moe/moe_align.py": "86877951a95cb96a4f92586bd3fc649493454dddb7521297ddd1560ecece3b17", + "python/sglang/kernels/ops/moe/moe_align_single_token.py": "5815a12c30b00719496db29860353900d27225803eba16d91a3c09eaabb30498", + "python/sglang/kernels/ops/moe/moe_align_small_numel.py": "ddeb1b65e6b86338c51077029fbd1e1a9c61b6fd625ef6fb272435c0b8608008", + "python/sglang/kernels/ops/moe/moe_finalize_fuse_shared.py": "6702f87cbbf57e73707313590368de95af3c6c2dd571facdaa6dfc73be0993e2", + "python/sglang/kernels/ops/moe/moe_front.py": "951be9046a5785294866d747c130fa2fa25aab945304cb49b48fa0e4b7209849", + "python/sglang/kernels/ops/moe/moe_fused_gate.py": "945eae03580d034420a20f2c38adf8d9ae8fed4a13de364d8c235466ffc513b0", + "python/sglang/kernels/ops/moe/moe_fused_mul_sum.py": "937d437f85e600b4566f9c436437139d27f5e0e65b76c4d407023468338e58e4", + "python/sglang/kernels/ops/moe/moe_lora_align.py": "0a0e28a7c7ce9c41fb6ed434b316e998b08e2af37d808dc32d68c5b841d24288", + "python/sglang/kernels/ops/moe/moe_permute_prepare.py": "53df1bcd7c072f23e44ebfa4cecd1a51d464793ea2b5a33d7236c563ca6ed46c", + "python/sglang/kernels/ops/moe/moe_route_quant_fused.py": "0c5965c027558dd464d9af83f7bb11bb05785309fa53292ec0a6000f978d19e8", + "python/sglang/kernels/ops/moe/moe_route_radix.py": "84a7b2e8977dbcca38b92fd56ecf8c72f4d6cb8dac484fd137ea96bad64682ed", + "python/sglang/kernels/ops/moe/moe_topk_sigmoid.py": "d4351193f9cf41e51086f50432c88eb9ee1a3e3ddf06c50be05fa2050398c52f", + "python/sglang/kernels/ops/moe/moe_topk_softmax.py": "e5403377267035a6a9914e8e35b80a59158d2091f83d458bc4198c70c7ae28a0", + "python/sglang/kernels/ops/moe/moe_topk_sum.py": "1847f8d4eb524e3b2e11969496f6bac485c1e275a5da58d3737002048c5c8e37", + "python/sglang/kernels/ops/moe/moe_wna16_marlin.py": "0f99349d7b7efd56f3a6fce990c6792246e83b1696a409798514ad5e0c309e6a", + "python/sglang/kernels/ops/moe/mxfp8_moe_amd_gfx95.py": "28e68a6a9e6d5db18515a670a3fa622a9ba2bfc11b489e3e6fdc81b8f3debff3", + "python/sglang/kernels/ops/moe/pack_topk_ids.py": "01114f7c2d013b2629fde0cf50fc4cb7e2ebfd09951f90b0bb496c61d2a7d3ed", + "python/sglang/kernels/ops/moe/rocm_moe_utils.py": "2ff5f8ccbe7e1454f6c9ca61dc5521211c07b32a765dde9ebe6e99a504047b75", + "python/sglang/kernels/ops/moe/router.py": "787fcfe75984ec59f5154fcc7cd0dadc37cdd4548545971a8533d2a7c63d86ed", + "python/sglang/kernels/ops/moe/sigmoid_gate_topk_renorm.py": "308766f6b682bf7938da86ba85bfb731067d5ce6191c866828cdde119afa3366", + "python/sglang/kernels/ops/moe/triton_hash_topk.py": "ad764744fb1b569717dc6f6d2952326dc41a8fc05637c9d2232627e5907fb17d", + "python/sglang/kernels/ops/moe/triton_sigmoid_gate_mul.py": "7c357dfb96efb31a52e1895477a97f96d17c11e618d35cc0cb04ba4d051a6d89", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/SOURCE.md": "14ab603836404013486041129d3483d6da61e1d708ddd0ebdfb0676a51c3cd92", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/__init__.py": "d5a67ad8c9c69f9099eb9a27aa92b15a7f0fe590019eaf094f1b5f138c053774", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/core.py": "70aa97a50971d8731d1e756f095fcfea76d9394447730ae092e8d5ca77015762", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/fused_activation_quant.cuh": "9cc9f7dc1cedfa7c79cfd0e0c35023efe860de11c3d99fd5868ee731f5f4b822", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/fused_moe/trtllm_backend/trtllm_fused_moe_dev_kernel.cu": "d364842bbe3efc86f1653ab5e9e7c03c3debb6829da31cc60b212ce591680636", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/fused_permute_quant.cuh": "d3d48ef13dd4966f7130e98dc53d12dff1c4dbb067768661fb77f2cc1c9299ec", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/trtllm_fused_moe_kernel_launcher.cu": "94e7367cd8be10b4c800764bf20bd420816d038d64477a90e603355967905c16", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/trtllm_fused_moe_runner.cu": "404b03aaada56bde468bf43001bb0b62422f617131840c34d3fbea438dc887db", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/include/flashinfer/trtllm/fused_moe/DevKernel.h": "7e8e91cae9a0730654e4f096ee35c2d770f345cc5795eadea67ee42daaa4c917", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/include/flashinfer/trtllm/fused_moe/runner.h": "3fc2f48d1acd13ba71cd7747d9415936a7155b4f92c67b62d7ba83bb513ef9b3", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/jit.py": "4993f260c64aeba3c46874fbc43ed0d28edac29a8932ab4a667e45f9fad7ad3d", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/kimi_k2_moe_fused_gate.py": "3a06d43b3c1291646e7c9f20650b9f07f51f05f7cd1896114bf2ebb760ca8dcc", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/moe_lora_merged_align.py": "b623e7d7f0c0d2c5f60c1296113115abfe64ee395a7d8a7151f86f79b17170a8", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/topk_pack.py": "9dc26c3134be47ea6af4078ca4e0e28d71056d7cc68704f960bb1733061669a3", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/topk_softmax_pack.py": "9960dbb95c50bb403180b4204b08fb82a0f21ffa6ef8051193ad7d18545d8d7f", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/virtual_experts.py": "911f7e344ec3b19e198ceabc2d8eb3b7e4e7a22f3f6405bd05f5544ff9ec0b19", + "python/sglang/kernels/ops/moe/virtual_experts.py": "43ce29967827ab2b3603e6ec06651edc984cbd5f915ba3d83496855ded8a7fc9", + "python/sglang/kernels/ops/quantization/__init__.py": "26d3f9c70f1b68dc2b2820530a85412dccfd27a12d82c725094ea230f8b12e12", + "python/sglang/kernels/ops/quantization/awq_dequantize.py": "82c4c1396bcfb05b6d6f0f8de2ba6060c6b0dccf8aef8d5bb2a841365ae504e6", + "python/sglang/kernels/ops/quantization/awq_marlin_repack.py": "4d10f132f5ee312ce6d48926811851ea0630d3182a58c89e95e8da0dcf1e2ba1", + "python/sglang/kernels/ops/quantization/awq_triton.py": "d50c29c4fa2a71f7b7b0353cb91b372d705170366fabe33dc50ecd13d455d0c7", + "python/sglang/kernels/ops/quantization/configs/N=1280,K=5120,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "7e0ad2a82391ae0500492bed02e65a51d4c36e9dbb159cc17f265c7621528c95", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "45d1d0c565f05eabe2a37d75f76bec2da2a312be1ffc38e930f2a56ab6352009", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "d2f2da260a3907db62f97305289baf4a83068ec650f918474b1e1c0bc5e38be5", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "b642e3c0b0bf6955e1ceebe8fb64079288d765ab8f26c7f78cd1c59f54bbb910", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "08fa355911741e0b1030f064be9a0898495032b7f0a492e112f2fce9ee9f90f5", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "f6a77287a922f4b032abb5433bd58c46604e3d6292ad9854f88ef3d44f5b4ca0", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6a24dca01603c27b88c3a647d5396097a6e34c5239acb1d0fca06869da25eff", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6a24dca01603c27b88c3a647d5396097a6e34c5239acb1d0fca06869da25eff", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "f726bd7f536dd20d110feeac45105939a20f2d2a521590b3ee336fa933eb8051", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "dc4f8b5da5b514fa138823c1bab9bb536495e0a9968b8c66ab07428c7bd99240", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "68ef3be22bd7a67afb5ab1540bb082378871c5cfc8cce4f0d9260dbfa2f4fb64", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "4288fdacb2d10db28ce08281097bcdf11731cd298d3ddd1341488cec25c3a872", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "5199639f1c424a3c276655f73a029664919709fe41585fda804a4d5fc2386717", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e03dcabb8cbb042544273b9e2af402fcabce474dbac3738d5acc5fb00fd8ac47", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "e8f397cd064774dc1c043bf5c3a04929b2cc443b748db154b8cb0c35ff93a04b", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=4096,device_name=NVIDIA_L40,dtype=fp8_w8a8,block_shape=[128, 128].json": "2f46d4a0a76cee0bd0ce11cd379b18ce4f1ea99fae6c696a19008ed5b288d21d", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "d46d91b8a352f3c9a30fbe9985717047e2c184a6aa96dba9195250761b0ac09a", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "d035cbe8396572f76c17bae82d8a44e7fec99811237135a2170da21e3114511b", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "eefe2da7445a4f8bf1178bab481ae42b9151ff98a478543586d1770f00e5d659", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "de66ada02cc47b869ec70a1eed84e6923c84e0d03c9215978cbe44c92b8dc330", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d09d8c16068b92ffa67d5139c77eb796054a614ea688b1bfc513b7b495206bf3", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "25e5cd2e46cc023743295f96a73432f3b497374eada30a37c54a1f2edbd80902", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "93cd6296dd75f799cfe2bd7ded6edc6689cf2797f667902d4b05198c6da730e1", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "fef928b83c0620fcb2762140d95c7c4bd30ae542c5506b374b0ac83da2e1c47f", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "e2e6db8704855ff5db79f44b1242e85b126471eb4558fcecb333eed17dff5abc", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "f5ff086f880b10549f74da4ef082fcba238d226bea9e53db26b6741ccdce07ea", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "161ca78864f1e50782b95ac14954d0caceaad393ebe653c470fca4a405fb232a", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "0686bcdd948f6742efceab5f2c6be88ace502b84e625fc230369fde9cf444f9f", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=1536,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=1536,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=1536,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=4096,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "3d7ac07c8cdea58f76746a72b01b4b82f869a449cb891c54d8d942e2d21a571e", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "7e66f3a427748b25408eb9d49002e6abf464c2ecd5fd59daa656d2d4c8ff72c9", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "c18f0fb7cff9ece2c8bf210b92da8d7b41b5a79184c1551a719df111e6c69cb3", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d2fd7bbfbf291135efe92d99a226de9313958624e60a6f34ec3606e0338d51c9", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "238e0fbc98fbe7cfacc3f7c239544e2d3a46d0d439ff93c263241ca590b56126", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "b46e7f8957910474e01d7fa588e7fbf675918e3fe5519f8d4164db06b0603914", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "0c10b1991dbd41ff5fefc0cf719378b7f61baf8dd300b3594fa179bc03fee7a2", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f82547a829513a58bd1567bf167967b801b62e2162bc314afe78211fab7e0567", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "f6d099c49d1e003ec060c1fb3aa4b7006a692549652a724b36f32aec531776c0", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b264f5620f1f54b03346a42e6c20b18ab589f4a2dbc04a82b7dbcffdda0fbffa", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "7537b53b75225d272c2d4499a381a28f843901eec894bdc34a730f8994d8d366", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "1ac2e8624699da9e10bb40a88fe5fdd2cec95b27d904e9682073e5c8d29221eb", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "0692b0798e077c1c79c6fa92bf035a872f71ed1e451fe60af23eab2c541d2b0a", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "40c55f3174b46238286fcffdc69b35c6e662e8a9d8e65d8c78ac572d18d37a0e", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "6d2c536a9b5d7208f6ee640699d52642d6139f857ff04726b5169536280a8cb0", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f33b8984575de9a5d11298aa3c58482841560399602d51ab1b4f9af545dc06a9", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "8a75d7abaf113f9e347e02c2e472378163397d166fb8243fd4cde759d559074e", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "667d53be10283cebf4cd00581ce661c1d0f0de8ab2c66d3321aec82644c21e9a", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "caa8ceef330bec4b1e049c3a067e4c4f21de022b643ec97576775778be919fa0", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "fa740884a00e54242bc4b57a1c395c0f457c1cc5afaabbfebf288e45553baa5b", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "261b38a1dc76e5f817c974a69ef6e63595b2a6ff7da2e85d04324a0f776b541a", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3379f0a59776fb4c36eb7cb066df606b0e77cfb30debbdd3e6d978b5ce3736d9", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "ecf69ac0312680218e2a77f997ca15a02116c7d97a00f9f6e67759f18aed6abe", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "ba92c3c86b2b89abed5be0b4b9367602172d5540f3c6fff95d5e2bc08c9cb5e7", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "bcba15dc932dbc738aa51e43d4178240f32e625594025ad7bb9e20072364c0a6", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "32dc3b6bd052b298f64f30be68fc44f36a352c4bf0ce06d4b88a1fc11c54340d", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "074968dd2ba8417841127a231f64f0a557aeaef94a0fcc88f2442b2793918565", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "e55f381bf372105778a3c70be32df830f598ed4ab12f9e1c43eefdadac9cebce", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "347771ded6677cb17b36996cc0ccdc4d16d011014bb42860e2b77b194f6531b3", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "658674df388f1b01b6b026ac1182e3ed920feef34ef14341479a8d4e62a044cb", + "python/sglang/kernels/ops/quantization/configs/N=36864,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "95a61e1f8c348993a3d98837bc382d2a8ae83509f00445f819418bacef74f792", + "python/sglang/kernels/ops/quantization/configs/N=36864,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4d670f0d9da6890303e8e5830b516d791b3cd0d0fd442fa824bdcf2d59896ed2", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=12288,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "452380d435c282ae8eef1269c65086c6d55b54aaa2ed41233daf541a575faa2a", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=4096,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "9bebe165ab5295f364809405b9501589d9d39e50bd12ab5ffd375a67300ff240", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "c7135f1ad1c09710d55fb3c19ea13124dd149d8940d146da6285d49ae5f426c2", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e99ee421ad7846356adde93f0b5e6ae6652ed48ad8dabd0e3fc4befe99be3185", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "afadd2664509255f3b074d21017d3be3fb9a0bbc3041776eae526c0758d40342", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "6d52657a30601e34563c36effb991b933d671e3a542fa54a72d8372c6d477152", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "c4187174215fdf069352c2f1271039e11f74cce0db0bf0ca2375d70552a3291c", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "5c635b518c9e4676f93727e94dcd65b9e1e35bf8b8f4ef63f4c03e328adab1d2", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "5c635b518c9e4676f93727e94dcd65b9e1e35bf8b8f4ef63f4c03e328adab1d2", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "d7a424e01adb55039d47d12dd93dd29cba6141dbc4c2eb86dd6dd70a60056b7b", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3bf495dafa3fa1a0017d3e8cc6a726a35da99e12ad7d7e139d77ded3639c1c99", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "835d9792eadab7ba144bb2dd4bda472ca165babe3f15a30688606f76afa2042b", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "25ca5511359c6d7e2e3e668ececc0b2e5696a90b4e7ce90c4319e202a3196461", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "b4576b6399c00e65d495285d37cc3c273931ba3fd13cb5c245c797f45850df91", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "600e0fde2590732bf1f70460bece733aa8f730a6f48b79434df5f7893cc98767", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "600e0fde2590732bf1f70460bece733aa8f730a6f48b79434df5f7893cc98767", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "9b413d4f07d98efb68a5816123dd9549aaa18946698c1bbaf64bf9eab28c12e4", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4cedaa4469a9dfbbf9dd9aaef09a1eabf0526edc0cfe6a55a28cc6ca8360d3ea", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "aee99424f346bad39bb2ee24ba71613daec1a207d18acb36a82ad07f5fe23a6e", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d31aae7f4d1f81fac3383a5ac72aded150dc8ea7f3a84c63f77f6bcde27ca4ca", + "python/sglang/kernels/ops/quantization/configs/N=5120,K=1024,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "5725fdd408d67cdd0ec970db897280e946e85d64bec8d045377b65f6ed470ec8", + "python/sglang/kernels/ops/quantization/configs/N=5120,K=2048,device_name=NVIDIA_L40,dtype=fp8_w8a8,block_shape=[128, 128].json": "7600f18a8ef9f95ec1806991d1646737e6ff43aeacefb62d9f648616b4c0456a", + "python/sglang/kernels/ops/quantization/configs/N=5120,K=3200,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "70fef34b838e2aa124a97bc30943d3fcd70649b2bf63d0861d99efc47fd83a6f", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6c14caeae1ac9b0a57c9ca19bbf1cd477f58dcc854869dfca0747629ece8524", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6c14caeae1ac9b0a57c9ca19bbf1cd477f58dcc854869dfca0747629ece8524", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "038bb35894cd87235587b9ed3af5294f44e179a115bbf8ecd0d08d75abfc993b", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "ba1d872d4351188a8dba555226b85a9af328fee1311c0f92da891077aac707c6", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "497093dbede595d24507348be2e93ad1484606bcd5db3337e00d919055e05c4b", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "a86eafde7dea17a2c4d837464fe98321779c6756bbbe0ee9dd0a97602317f399", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "1201531b25bf62e0f0c840d40a81a0972235113763f49ec047451f27cea33282", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "0692b0798e077c1c79c6fa92bf035a872f71ed1e451fe60af23eab2c541d2b0a", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "956f0260a2fc1561187e0a0008aeabc0b4cac40cad3bc7878103cd4476ec237c", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "362a2b2603a8b7191070fe3d203df3e5a975500e10403ad3f0cbdb0b00162f96", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "15cbb37262857f645b694a40680b2e39b51e7dc18c80d3cc0db55d1d7464a066", + "python/sglang/kernels/ops/quantization/configs/N=6144,K=4096,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "0303aa74a51f84f4322d9420573928d55b111eee725891949a9d249a3121277b", + "python/sglang/kernels/ops/quantization/configs/N=6400,K=5120,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "dc2594d10e4c2d7621d6aa529d3a7e6f6a61b3eac965977ce4a4a6bd3d55604c", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "60a3dbf72bee313072da69de971acdd1e61cb9f68c1f5660371effd2018444e2", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "6905658c4c740b3be0916433f2437cf6a9ba43e89024378aedd2ab728f68a052", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "6cf416b6f689af338e22023e47e308c6cfdfe320bf1686e40f276edce90e16d8", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "877da509316294b97229b31eb89bcd586d6fd32249ccd8fdde4c12be5ac77da6", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "651822b876764850babbe595e431b06aee24d5188f2c8ebb78434ed1efb96258", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "92343f92f177f1b64672669e246489b1247435c52350e8772d9dbee5ce243ef1", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "0ccf74f23ee224a2b478b0d1f11d9a066642ff398c8d67362d7c4b92d62da807", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b7e99ac5ab0afbc92fdf6fe025638af7b41f42bb24de25d6f3528609a2e6e473", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "fa13ff3fc34cd0ad38986cd39a91813626d0e71c61e603f3e56b68317868cf51", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "d235fecf6953815c3b0012e65ac22c41da96e048e66d72910c7c9efd73cb0801", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "141e4b7b8a1bbcfa028054a70bfdfe521e7d9fe32de11a25f2c69755c2b744fc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "999194dfdb286ed52a3582a3b722068e1399c82390149305dcc8a7035ce34c90", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "5245f3c461955eeab7ca6a9a5dbd5012a9ea5dc5c137e985bd90d9a0a1c7e641", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b54bdb6e0975f1c81b6e64107b64adf8e7f8c248720bd41039682355306efdd4", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "90bbe21af56782980eb9e95f2adbeff48b3b31643cf6b1b196898c44feadd087", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "fdec4cdf027714c9861f0781707fbc231c1907368e98f685dd270c33a283a626", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "b9eda85a6976a2e51365e958c7936de69802998fa26f798b575ade24bf59b9d1", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "dadd659a7878167ebb612ab89da3f683f46a602d15b6c5604f0e464b5e00fffc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b326f4b4fc2b7585023a807b7d3117112d06689ea3cbf22a2378b5dfacee75be", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "be5cacd198bf09a694e3538719b59206d6d5825162f7c6e0a84c9204c73d49d8", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "616c81c8e94a4aaa7995b7146bc7aee8dd9d1d1289a890db0834a37434099e08", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "10d45661d530234a281dbe88c1c1e58aea5158e3e7c3eefe5adc5907ea901892", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "ee14d6b044935498c2f317c6a0b179a19a2b1299dc7eb0c687a9579cb6611488", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "8f93d35b4202e19db2408ca071d20268eb2f6fadfdbba32ff99a49624ac14369", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "36ff4a3ff28b1ac44974917be7975906f6d3c2cdfbbb518cd948a0311940b65d", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "bf657018b62fad8cb735fafb0a23a4b23691f976f01eedb546c5d9dc9ebfc9f2", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "f6f4ed082b447fbca132c9e0f9910053f82f28c4ead38c1381eca45740609d3a", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "1a0cb885e8e47168e2c39062fb01b348fe492d5baf3a38a9feb6e35c504965bb", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "5f2e26819c798a212fbafdb274ee1d14d213f2cd2380184d1c4d6fbbdddf1893", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "4dd5ae136448b08cabe089b6e0cb962b75f288db5b84efe10220170f3e603549", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "9c3f8a8b75ae43e324b6f1476ac624f220b5b323d499f6e9b2871751e6bd05dc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "c78efa9c57a5b41ff688ef7feb2fb3d8ffee9c06e1ee084b3c58b9cf62ce4cea", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "64e584a3ffe8532f008498809510ae18d01935d370785756045a6d258930c6cf", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "b13bda27446209a41e9b8175cfba044ba455449da02a006e71c5f5dd2d52a867", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e2e5a240c87771963f12d2c0d1adcf53c675542ba71763e9a254cf61e3fd463a", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "0f49a888aa92ef7a2b8a5df688d8f98112545a94f6499e637fe65eb1466736fe", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "afece7766553144f9bd639ce37dcf0b8142f4c1a2856e8f5aa37fb86f8c512df", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "377edd50bfc9d8956980b1659e5cfffc293b6789e344e9cd00ef15da8883aabf", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "cee4983b40de8ee1c92b476a4accd3c92a195058b3823b4b2174a38ce0bf9697", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "cee4983b40de8ee1c92b476a4accd3c92a195058b3823b4b2174a38ce0bf9697", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "46af9e30c2b575e509ce61d0387d04fe9c103fb97e654f840933fb5f07a06afc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "2ddb4ec97b00f6bd7c1a21649833a48918a7b03499059f0d61aa4be7d119e223", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "d3b19aac11e68a2624caa9feab112dac07200844ee51baa6e87aa56c7f72262f", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "655166100eb58627b2a79c40c8b4e4cdf94099672e36d5d88808e57c0c0cc7b8", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "904baf0ac5b760d07217e0c02d8a8f6695b74cbf196ed43981436aefef18bd9e", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "6a8ab8efddb33e8f3b40eed5ac47fd7dbfef8f4ccf88722eec7a3d68c5f070bc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "6a8ab8efddb33e8f3b40eed5ac47fd7dbfef8f4ccf88722eec7a3d68c5f070bc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "fd11ef15c6eda6c6412b166d7b6f84dd2507b4bd69c11b6ac21495e0131cc8aa", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3c3e002580a41dfcb68afbfd6da328b855f3053cb478a32e99b01fc5f9bdd472", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "148980f9327fb500e3ab0a0d5b14befac443a0a0d77fd81a9a5304ded9311f9f", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "1450634969692973317c0514614a976ce2bf1ddeea05e06c7db71a6bdb81e2a6", + "python/sglang/kernels/ops/quantization/configs/README.md": "62717927306fbf720b6ad618eefa94a4657894711680f57d9ec82aeb3ced816d", + "python/sglang/kernels/ops/quantization/dsv32/__init__.py": "871331116c34886397cbea62e19403cbb8b428353f1efd93723773620bec1cb3", + "python/sglang/kernels/ops/quantization/dsv32/elementwise.py": "d421f877d20799ab5f00fadf550fa33a36fb02bfa62ebf8194700254222d6f8d", + "python/sglang/kernels/ops/quantization/fp8_kernel.py": "bf4d819c35f35e58be94085c081425284de4d1efd640ff4b000219e1bfef1169", + "python/sglang/kernels/ops/quantization/fp8_quantize.py": "7d47a3d63f815af25a31cac61da9e108d58933f7a07339695e8e6eee3bccd3ef", + "python/sglang/kernels/ops/quantization/fp8_utils.py": "98d78ce79860f027c0b5989de2aff153529e28258d53bb6f4f6e32f51b308549", + "python/sglang/kernels/ops/quantization/gptq_marlin.py": "e1be46383797db3fc4235bc18ac43d54e696ae1a6be2c6240921dbba6d2f9641", + "python/sglang/kernels/ops/quantization/gptq_marlin_repack.py": "c128316664f70a631d2a0a88a6d0ebc1e4ee435114425914bb69bb1c89f30ca7", + "python/sglang/kernels/ops/quantization/hadamard.py": "bf8a100d8e1d75b542aeb3ef74c109d3170b6a0ddfa4697976d05e7714460330", + "python/sglang/kernels/ops/quantization/int8_kernel.py": "601e0fd6668af8d12d6e192e653112fec890745cd5fd40521be6b38bf290d856", + "python/sglang/kernels/ops/quantization/minimax_quant_ue8m0.py": "2e21e5a4dedac4aac89813175d3b6ace8379c74d822603d4ad5bbe5b6ae52700", + "python/sglang/kernels/ops/quantization/mxfp8_amd_gfx95.py": "a80677e9863df4f7d9ad35dccdad414488d7eaa53e81c7b35fefc3f8cbd66baa", + "python/sglang/kernels/ops/quantization/mxfp8_interleave_sf.py": "69601b1e025f5b4efac2004ad73ea5a85ee424ad916d958553f0cf6cae116dbd", + "python/sglang/kernels/ops/quantization/mxfp8_quant.py": "9c6c81711dcb6833fd12f8f2e86ff4728b5b3e97ed2862273c5eb4833d775892", + "python/sglang/kernels/ops/quantization/nvfp4_gemm_swiglu_nvfp4_quant.py": "aa8129b1cf1489d988f45658a730e9f593d20eec6d7e8e2df936efcd28658fea", + "python/sglang/kernels/ops/quantization/per_tensor_quant_fp8.py": "7fc8f52c4802eb4d33840e14e4261bb7baf45bbda336bbd861726a7b62ac9f27", + "python/sglang/kernels/ops/quantization/per_token_group_quant.py": "e06b15269ef3d75f6a85ab7a3268ece5624572e4fc95cfb0ff2ba26442432f54", + "python/sglang/kernels/ops/quantization/per_token_group_quant_8bit_v2.py": "c93f3059787d5d39d70fbe6affd28b1fa8286e2a68ead5c8becfe0004b0d14bc", + "python/sglang/kernels/ops/quantization/per_token_quant_fp8.py": "8f9ba0c5036d805eacbbb16cd4840bae035137be0fdbbb032873f291d1b510cc", + "python/sglang/kernels/ops/qwen4_ple.py": "9aad781e87bdc3be74dfc29cf9d1f5286456c550846856f6d7d0ca689a78ea7f", + "python/sglang/kernels/ops/sampling/__init__.py": "1c7676b6b0247bdce410ef682e7efcaf3409558d53ddf5383b3bf11fed55ef75", + "python/sglang/kernels/ops/sampling/murmur_hash.py": "0f1907f9b4665641166d1cbe94d392f1145eb468493fe66b44d515c394858bd6", + "python/sglang/kernels/ops/sampling/renorm_triton.py": "4c1a02b67c4aa518de72c27c495678e83c32178ecc8cc877c72dbcb34ba2232e", + "python/sglang/kernels/ops/sampling/top_p_renorm_triton.py": "ca04085e3a572a3f7ed41dd566f8cb3d3fd5f0eac03ad31ad0f101539701126b", + "python/sglang/kernels/ops/speculative/__init__.py": "a383c49aba6a5345e3879aeae9b962c5e66a583d37b32fd8b9a19784d7e19d4b", + "python/sglang/kernels/ops/speculative/cache_locs.py": "d1ae7029c4591ba79f9cc62c42cb2aaea896ca32bd918ce046063515f3ee0e65", + "python/sglang/kernels/ops/speculative/dflash.py": "f4cc3f2539a9ae6b1db0c0704f88bff557afc88f6bf25269e33ed13d574373b5", + "python/sglang/kernels/ops/speculative/dspark/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/ops/speculative/dspark/dispatch.py": "8baa09b85ad97aae209b55f40271bdd4168a2b889247dd5aaa6a7dd1e0d1772d", + "python/sglang/kernels/ops/speculative/dspark/dspark_accept.py": "184dec7ed90d64840a4f9ff3ffd583ce9ea4c50ed1bb676d1e8b1157fd207381", + "python/sglang/kernels/ops/speculative/dspark/dspark_attn_metadata.py": "9718b4ebb5934bf3eefe57ea7ae6df888d39cd1d8894db11a2b46253513f7a22", + "python/sglang/kernels/ops/speculative/dspark/dspark_draft_model.py": "c917b63f5754569288002757f5d65980de3325460712112a4af1d10dedd260c0", + "python/sglang/kernels/ops/speculative/dspark/dspark_schedule.py": "420478eac029ecff9a8914b7df4d7db2fea4f61be9dbafa1cf34b1b890292c06", + "python/sglang/kernels/ops/speculative/dspark/dspark_verify_window.py": "10266a2d86af22a42e6020a0753efe40123789f26093661ac2bb3de92387ac20", + "python/sglang/kernels/ops/speculative/dspark/fused_kv_write.py": "f48e2481327f8e5355ad2dee4c9b6d40fb4802e9e05b13d21e722f072f6a5cc3", + "python/sglang/kernels/ops/speculative/eagle.py": "b96e3d0538f52d73b32a7f29f649cfb52a88c8a74110a55bd5128524374c404c", + "python/sglang/kernels/ops/speculative/fused_kv_materialize.py": "b8dd985b7764d3212e9e3045b2daa5be0c481215346ab28f2513f8201e9cbfeb", + "python/sglang/kernels/ops/speculative/gather_spec_extras.py": "5b4e41ce94ef81db8a6a80cdbfbbf379675288a9f922a74a2cb4ac2b9f8c35e9", + "python/sglang/kernels/ops/speculative/multi_layer_eagle.py": "f43949449eef3361780bdf3b0b8d258fb6cbfe384936871b442dc90868cb6544", + "python/sglang/kernels/ops/speculative/ngram_corpus.py": "61848bb43c31193f8911dcf9cfda9e8e4871c63283d1edd96cbd0a219fd4f112", + "python/sglang/kernels/ops/speculative/ngram_embedding.py": "1bb015b137476f5fb1707da971026a9a17634a0c4469d9257aaf5b4e9008dfa0", + "python/sglang/kernels/ops/speculative/ragged_verify_kernels.py": "9d004ba087b74550b471b2fb0946c3edea8cc94f692dd7b4be6db4ce06ea6c45", + "python/sglang/kernels/ops/speculative/reject_sampling.py": "c1e1b66aba3f0a0668fab32ae46152d5fd36a23defdfe5a6b27a6380e227e1a3", + "python/sglang/kernels/ops/speculative/spec_tree.py": "8b3dde69be73a7982cd8ea8bb8b39dc3b39b412bcb6fce6f5fa4ae8cc6418f52", + "python/sglang/kernels/ops/speculative/topk1.py": "2dc54fd39c34a6aaaf46fbbc5c3737c57bf70c42f036f33490460a03b6034533", + "python/sglang/kernels/registry.py": "9d9614b4a54647fa40c66d6baf962b4a105c653239075542ce2482fcded01cea", + "python/sglang/kernels/selector.py": "e13283e97d664d9ad70422c0b0b4c27c046dd934332d40bb5610887018741504", + "python/sglang/kernels/spec.py": "3ac2cbe41ad81f147d4be6b13555f50dabcbc394a56ac60bf5b2dff63a1f6d83", + "python/sglang/lang/api.py": "15edcee0a734716e4d8986ad3a33403aeb16c9f364ce4b93d2430e85a5db0af8", + "python/sglang/lang/backend/anthropic.py": "a975aaa85964d3e9c2eb64027182118cb4dce001eb7532a997b842783cd1394b", + "python/sglang/lang/backend/base_backend.py": "b44bad182539b678b5c4696b223015bc0f5a7e5241b7676e2ab203cea69b2567", + "python/sglang/lang/backend/crusoe.py": "c653bcc66d14be9c1d508a5d1aa16ac0c3693e984ddc007d8798607ba8351549", + "python/sglang/lang/backend/litellm.py": "ba098beec7d4c6450755b1edc0dcc781d40011de140a33506e816e13729385c6", + "python/sglang/lang/backend/openai.py": "605b3ba420caebf0e86268d36bebe00d575a784e0f62bec4fac202d6aeef027b", + "python/sglang/lang/backend/runtime_endpoint.py": "82d37c4e9a07cefc0d7afb2e7780ef5ad8973cebd8227da57e9b9ff3695516bc", + "python/sglang/lang/backend/vertexai.py": "833d2e358c816fcf236cf633e99209efbe1f79fadc6ee55da0adf76e98546692", + "python/sglang/lang/chat_template.py": "d91a4548101b581828c3e7b0517360a9a42e06d8295760972200147bb51c6a19", + "python/sglang/lang/choices.py": "f96d43570f4df59962569be65abcc85c6e1cb3001a87c78c42b1d6ce44b70fca", + "python/sglang/lang/interpreter.py": "043cb4a126eeb75cae6ae1801a2b9f0fe516d6488efff53f7ca3e4023f4da6f9", + "python/sglang/lang/ir.py": "2b153e4cc92d90e4f7a57a9fe49cd405c248e0f63738b9c47e0509634eb6dbb3", + "python/sglang/lang/tracer.py": "963068f55674cd5686c33364df6ab0db569cca8eb4374523223a816d3e5ad562", + "python/sglang/launch_server.py": "9a54ec8ad199766518c519b6b98ea6170ad8ec157029eed4bb3a49431b86a540", + "python/sglang/multimodal_gen/.claude/CLAUDE.md": "3da0db1401eef176fe5e50189b6af0f894be536d8caddc5e01a11591a12c320e", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-add-model/SKILL.md": "234fab7222e82bb86b0953f26122bd8c16b3a07c91000f7bf74b5c79b236f985", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-add-model/references/testing-and-accuracy.md": "33b247b92654aa65517116c6551ee78907dce01ce830aa8acb27b023ef0da80b", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/SKILL.md": "45f542a134262717bf5725bed165e207e16e3cbefbd0e61a1118422c5f847d97", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/benchmark-and-profile.md": "34653767d8097b2ce6cafc721c53b7b99a64cfa70ba6d89305e3e0922375689f", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/existing-fast-paths.md": "fccf0458844c5b763879d19e4ee14f89d0276abcf37ee9feccdf0d6617dfffa2", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/scripts/bench_diffusion_denoise.py": "a9599c3bede9ef00b6be0466cc1a05a1b2945b119db05276478bfbb7da97e1fd", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/scripts/diffusion_skill_env.py": "6e33eceb3f170aec98937c63a7815d8132c0fc3565b20f5a6dee4ed5a8e3f050", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-modelopt-quant/SKILL.md": "d69bf54195574ff5fa2ad5f2f8c3b16dc0c9f17ca0f43796877e484f5a7c8092", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-performance/SKILL.md": "856426d2ca69413f10d4b704aedb9e33d88450aa753b6882263d5cbcb30d3846", + "python/sglang/multimodal_gen/README.md": "0a3cbac65031be3e1a0faf19f4c55ea8365ba13d159efc3dad1578546bf990cf", + "python/sglang/multimodal_gen/__init__.py": "a97a11a1ed866e58e1f18be0e697e07b97baac4a02aae38cf855b9308708aa37", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/README.md": "ea28cf5d4e9ec20c3b00abf731d1564f762ea41c2938ba7fa52e766c1574c1f1", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/__init__.py": "d559ddb65041458385e826de59b213d6508d0129b2cb3ac7be8a8e571d18bb7a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/__init__.py": "8cfe466edc4c988edf29e63b24c9bd32b3a9eeae33a3c0b982448df1c718656a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/generator.py": "5d6332833095f5822238b9265df5f19dfd7a2b47643cfd08ffd0c42824b1a2fc", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/model_patcher.py": "8744ad46bf889f92398d872cee25a6600151f25c380c30c94d6b78d587a71b0e", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/server_api.py": "ce31460c870b5a10cf69510081e3c63dc16717219002b43a1dc3759107f49250", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/__init__.py": "d43d7b1097c2657e6f65d20d8e60deee98428aef48c34dae19feabf90e4c6457", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/base.py": "e1ebffa3b2584d3a9498491ade0cfbded3933832910ac22f6f1224c1f7d517c3", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/flux.py": "5dd565803807e4db602d03fd4171491e2a7d80a0b76d01a819c63e7ff1da2dae", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/qwen_image.py": "bb28bc708a7d7dfec124b4c3783d9f1beb268b531b9b26cbfe731a6c93f7807c", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/zimage.py": "670252d402274c0f90887ac97152ff4bea5d086069903d66d106dda3fee4792c", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/nodes.py": "f58804c6daafc726b97fadcfbe5a32fdd2063fc0ab67021fce1f7e9f51b2ad91", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/README.md": "579b98f08cc508a3b111027470b9e1698dae7e63cf316cb08c7ee96d50b9735b", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/__init__.py": "2b9cadc14fc06788a3c041eb674898f0329fa173ee242a7bac748504c9f7a513", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_flux_pipeline.py": "f9df682faab73350ca77e714cdc2504aabeb82ecc936ecd9d2fcfa87660667b9", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_edit_pipeline.py": "9843dd2905e60d4510d056caaebc3e95e99ca02f2b9a49d8ff4c67809f35275a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_pipeline.py": "7ba2f1139ad2a7391d60c4f73ce95c0ea3702dd355e525214df85f08e5aff139", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_zimage_pipeline.py": "5ddf814b78fe683dcbf77bd1f286c4ef29df974f59d496f2ddb63f81e1c6b1bb", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/utils.py": "18ccb69ba09c25f2f5d1704157b6a8023ab177fbdf5c746a198b59e2d7d185f2", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/flux_sgld_sp.json": "a32697dba5a49820bd4816174b25a3eee45a1acdc8d95db5f115513abc5c403a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/qwen_image_sgld.json": "bab2400001f92d01f4fcd331a491d0029e68023ef37bea118e84e410425ed77f", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/sgld_image2video.json": "e8d532a567959ec2f9310426a6a26f4dd71e3f6b569a63d5bbdb55062b91e842", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/sgld_text2img.json": "8dceff5513a380fb79586fb88c319b8c385f1f1ed5943e41097c57bea861fd4c", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/z-image_sgld.json": "67deca18066b0d71576a5865b340ff116201cb4eea67bb8b10bb67420983b927", + "python/sglang/multimodal_gen/apps/realtime_webui/README.md": "c2acc71067182e70792fc607d6d4c1a62b01de8fcf044b28a30c453c52270a5f", + "python/sglang/multimodal_gen/apps/realtime_webui/app.js": "6e654cd3620e2524af7c4275f1e653a19069d372ed210ac367101f0a11b6fb1b", + "python/sglang/multimodal_gen/apps/realtime_webui/decoder_worker.js": "7d2655224ee3e24fb2347ef27214bedc7cf16bba60e8621aff05549055a06cdf", + "python/sglang/multimodal_gen/apps/realtime_webui/index.html": "8161da333a0e0889db51e2c050a7bf9b3c9a7767c6ca2c153af73bcb18becdbc", + "python/sglang/multimodal_gen/apps/realtime_webui/playback_controller.js": "3e01586ef955fcd35fb10969ade00825ed5756d9b1f95a2b82b00aa32ac62e0e", + "python/sglang/multimodal_gen/apps/realtime_webui/playback_controller_test.js": "cc5b19e9aa5548afb9268e9d154f4fa44153531994aad02e8560065e8788a022", + "python/sglang/multimodal_gen/apps/realtime_webui/styles.css": "179ec7d17cd189119c2180b7e0c78e7dba2b8aad65632cc5b4765958d294b39f", + "python/sglang/multimodal_gen/apps/webui/README.md": "7cb942ce7ab99a4d4c8003229acea6b600ebc46060d7303e8dc249190dab3cc4", + "python/sglang/multimodal_gen/apps/webui/__init__.py": "1f081fe4d4446bea793d8df2b829704a545ec7ed315a6411b4190ff834bdac29", + "python/sglang/multimodal_gen/apps/webui/main.py": "c39733d00b9c2a648fe47bef15cf6d78aa196e9aaa2b8dce8329b7f639589568", + "python/sglang/multimodal_gen/benchmarks/bench_offline_throughput.py": "a4c3e077312ed5c0495e7b0f2753f68234efa365dfe8641c93674ea2146d93e9", + "python/sglang/multimodal_gen/benchmarks/bench_pi05_openpi.py": "b175c2d7465220c88ea51a96f00bc2ec2b62b5568d3149f6a20b0c8d7d284ba0", + "python/sglang/multimodal_gen/benchmarks/bench_serving.py": "e934cf27af6e551fefeadf51143d8eb79a6d7446aaeaa106017b9e0e043a40b7", + "python/sglang/multimodal_gen/benchmarks/compare_perf.py": "0bd7da189b5ba7dcb84f8d18fbfff7d3a47b3fee0ec022147d0542d39239a14a", + "python/sglang/multimodal_gen/benchmarks/datasets.py": "1897ad432e7a48172d2b1464c337acc7ea1812015c171527a271ca6cc3c2bbf7", + "python/sglang/multimodal_gen/benchmarks/request_manifest.py": "14d4bfe40e878787c52e70020320965f3176d74552eb0ed8ca71194d8a7d0b60", + "python/sglang/multimodal_gen/configs/__init__.py": "2826d8dd051f9024e382088f3d1508a841881e92f9979fcfc8176479610ec70e", + "python/sglang/multimodal_gen/configs/backend/vmoba/wan_1.3B_77_448_832.json": "5c9c6a807a0943e169ca1595b302c92fa17266f3ed07a71ca565b83701f3cdce", + "python/sglang/multimodal_gen/configs/backend/vmoba/wan_1.3B_77_480_832.json": "ccb9da0f5da26aedc6a0f77394b4d4d5e4e8575d214ab4d3a2b7b2c070d90b8c", + "python/sglang/multimodal_gen/configs/models/__init__.py": "cb5d104fbae96c0d9e62fd62e53938fb666c8d21eceb6dd56839c6ac8820bdda", + "python/sglang/multimodal_gen/configs/models/adapter/base.py": "fdc068bb5ce39c0ba4a265d4b565a38e2fb0fae53de4ff4493e113f4f61c5ca7", + "python/sglang/multimodal_gen/configs/models/adapter/ltx_2_connector.py": "7c824ee702a3f023da47e5be40c9063e05c9e0aa691f56bcd455b7b64ab3ab37", + "python/sglang/multimodal_gen/configs/models/adapter/ltx_2_duration_head.py": "29d115306458b08b4a8c30f3982fac43dd04f1f5a58798ac81203b0bab6f606e", + "python/sglang/multimodal_gen/configs/models/base.py": "78506d1723cf8b6fc5c34ab8b3df228ec7a9cf4f8f878520c0d6addab5fc859f", + "python/sglang/multimodal_gen/configs/models/bridges/__init__.py": "5f2daa21e492c411fc514553b5e2b7afe9bfa1b1f3748b72e083322308ee9455", + "python/sglang/multimodal_gen/configs/models/bridges/mova_dual_tower.py": "5952b3f122ce18aaa12ebb73a51e04697e1eb832e0db202a285eb14371763b33", + "python/sglang/multimodal_gen/configs/models/decoders/__init__.py": "e86ec17d67a947d20f77d9e24d3fdf15271d6231de81c60a6ac56939a467ea28", + "python/sglang/multimodal_gen/configs/models/decoders/ltx_2_5_diffusion_decoder.py": "16e1dc5b55c95c49e1c9001136c41b0719ad16721219c3d25865c42920797646", + "python/sglang/multimodal_gen/configs/models/dits/__init__.py": "f5dab49623982c6b0a1d089922ba23f2098df59cc97d88ae390b0ddcf5a2fbda", + "python/sglang/multimodal_gen/configs/models/dits/base.py": "94db17fce1f4801fbcdf6733ce49caec5db4d2133ad84b9ecdc92b0b7f1e934e", + "python/sglang/multimodal_gen/configs/models/dits/cosmos3video.py": "d32e65a40bccbe48add895843496d076c04cb3898225ae09f9059e80393892d8", + "python/sglang/multimodal_gen/configs/models/dits/ernie_image.py": "cc10dccfeffaa9a77200aeeeca15d1057e59e1cc2adc20ed047f5b7d0f391fbe", + "python/sglang/multimodal_gen/configs/models/dits/flux.py": "0a6de167dc42c36d8d48ff448407d8e9a8df6fb7578b743a8ec38e62f4bea0eb", + "python/sglang/multimodal_gen/configs/models/dits/glmimage.py": "3daa2ae842980b184c873882de3d2ae47ca6cb6ce63e57b2225a56b2aeb85a31", + "python/sglang/multimodal_gen/configs/models/dits/helios.py": "46642a6f6d63d2d7f574406ef2599825b2db39be4a0dc7dfcaf7652d33ecf51c", + "python/sglang/multimodal_gen/configs/models/dits/hunyuan3d.py": "b438cc0fdd229821f77d388fe5d11587e129bbe438a77b250801590c7e063ea2", + "python/sglang/multimodal_gen/configs/models/dits/hunyuanvideo.py": "e32ca1339b075d4df96d48be961817b35f613d106666b1087a3bceaa20a9339e", + "python/sglang/multimodal_gen/configs/models/dits/ideogram.py": "fca2a4b7ba50eeb11abb9b5db2d3f4415eac154ec837bf607915eea3d2a27735", + "python/sglang/multimodal_gen/configs/models/dits/joy_echo.py": "ad3243260a1df4dfcb63f9195133d6605b275f7894819cac5d08a0524de63ee4", + "python/sglang/multimodal_gen/configs/models/dits/joy_image.py": "3236d64d8bd1cee09068e7318ef41c4903fc8012d93a6387504d9eb335f45605", + "python/sglang/multimodal_gen/configs/models/dits/krea2.py": "4da56df4f83573b459ca1ae10892a1a105af4c0e64c912c5f0a40ca11a769150", + "python/sglang/multimodal_gen/configs/models/dits/lingbot_video_moe.py": "219a5a9db3ba7786c7a90fb83c0f37bfb8db167f5a76b56f2eda026511b6cf08", + "python/sglang/multimodal_gen/configs/models/dits/lingbot_world.py": "ffdc1d327df385b1daf8653c621b3e192de25bfa96c9356b124a43b218ae46b1", + "python/sglang/multimodal_gen/configs/models/dits/longcat_image.py": "a461a25403b46200127e620809f97450be5522b9cb50d16134635371db1731cd", + "python/sglang/multimodal_gen/configs/models/dits/longlive2.py": "6b0f2ece41cf7ef0c8ce92e7a3300fd89d881b06053bec5bfdee1c39dda250ef", + "python/sglang/multimodal_gen/configs/models/dits/ltx_2.py": "70c3319ad2e1ce026f3ff02e8e4b5cce58d96b1e2190e33a461d031517ebc333", + "python/sglang/multimodal_gen/configs/models/dits/ltx_2_5.py": "7008178dc37431d31f06eea942e196d5d0667b7783f448e75a849d8c814dce71", + "python/sglang/multimodal_gen/configs/models/dits/minimax_h3.py": "8a239ed923abf82d577c220896d28b42c01f6aa7514a8dc2dd4cd2db4afd0d48", + "python/sglang/multimodal_gen/configs/models/dits/mova_audio.py": "7ee8ba0eef9083fd49b21136c7cd378431549b4e43bdee034e271d0ddf9a0594", + "python/sglang/multimodal_gen/configs/models/dits/mova_video.py": "0a5a9809dbd9c6981c1b195cf62915ef43ce14450d6f5baa79856986c994d871", + "python/sglang/multimodal_gen/configs/models/dits/qwenimage.py": "14da21d839495ceb9ec028386a2573d48995331f6289cf2ec3950183ada3cb32", + "python/sglang/multimodal_gen/configs/models/dits/sana.py": "d4d67b037d1ad81856143d2f641c3e47bef55d7c06de183d8ea014f198f72310", + "python/sglang/multimodal_gen/configs/models/dits/sana_video.py": "f42763aa57df5eef983adb221259e773f9736d6ba2b266643bcc28f1f5f29280", + "python/sglang/multimodal_gen/configs/models/dits/sana_wm.py": "97f3e28b2659d5eaab3954dc7601d274eb01e88868d0722ccd7bcc16e48e156b", + "python/sglang/multimodal_gen/configs/models/dits/sana_wm_refiner.py": "301ada1b905f745c13fe0717c7855a7b5e1b428a791e6a7d817c77b34be7d51a", + "python/sglang/multimodal_gen/configs/models/dits/stablediffusion3.py": "3d290e5515cddf0d40824224bf624be446d81f02c76c4c78c631da8ea66b0904", + "python/sglang/multimodal_gen/configs/models/dits/wanvideo.py": "e2703b8edad216852365e7dab09fc65d099078182806a97cf66bb7ca7d7a6fd6", + "python/sglang/multimodal_gen/configs/models/dits/zimage.py": "1ce4ec3bcc47e4f78e8e50ff5b5ff079c0ba0d9214f2721ebd80e424f487f8fe", + "python/sglang/multimodal_gen/configs/models/encoders/__init__.py": "982dd2d1dbbea63217e4dab5d4d806a7d473e86ca2efdba27fa1783ea8249d28", + "python/sglang/multimodal_gen/configs/models/encoders/base.py": "0f5e4b4ad6406c4649fa02487cd639a8d18728dd01c8d21436432591d6f491df", + "python/sglang/multimodal_gen/configs/models/encoders/clip.py": "95dd43242f1bbd8a3d4eee62dde848ff2d923ce2296ced6415772e1bc5c68c7b", + "python/sglang/multimodal_gen/configs/models/encoders/flux_2.py": "4c1e39bfc899f56a5dbc0c8faef7249b6d5f7f209a3fb9298096dbf07a51aeec", + "python/sglang/multimodal_gen/configs/models/encoders/gemma2.py": "15334d16485d0d16ccd3ad5d9ac7a22da3603178f9f6883186770f8277145df7", + "python/sglang/multimodal_gen/configs/models/encoders/gemma_3.py": "5f99d876b7ec0709ac731985cd9108f53391a9fec6fba3be06e11194cd9b4fb9", + "python/sglang/multimodal_gen/configs/models/encoders/gemma_4_unified.py": "1a3285adc6feb47ee1ab62acce97391a3608bd58ff8645248965a61d68a59373", + "python/sglang/multimodal_gen/configs/models/encoders/ideogram.py": "f2fb04c48efb5e34172c3d00a173e54b692f1ec20e750d5ca0c7949be7b68701", + "python/sglang/multimodal_gen/configs/models/encoders/llama.py": "860ebb8c5760c40ca774272ce059a0a03dc8a5f56c9453c4220d9b38a72f9425", + "python/sglang/multimodal_gen/configs/models/encoders/minimax_h3_qwen3vl.py": "7ebef8db507047384fa1cc78056afe93f7c4b707ce10693bd435014c8187f1e1", + "python/sglang/multimodal_gen/configs/models/encoders/mistral3.py": "72e05222b7961fe0561853f48cdcacb7bb8235bd93b52e2350cc73ace6286f29", + "python/sglang/multimodal_gen/configs/models/encoders/qwen3.py": "10f848e8643309e3468a856e98ee46a4e79c6c1e465edc2e620e42b5220d6aca", + "python/sglang/multimodal_gen/configs/models/encoders/qwen3vl.py": "b7f74023e4318dfe5857239a18a6ae8e36b3b963433ca1ae54d98ae6c77478de", + "python/sglang/multimodal_gen/configs/models/encoders/qwen_image.py": "c2f8e9ae8ae4dc66fb41dfc386e8194f6337efe197a2e7875778cd65b6af9e8e", + "python/sglang/multimodal_gen/configs/models/encoders/t5.py": "f142658cb9187c9258c1cf725f5a973ae8d51a87aae3e1cb042556c9330f5d9b", + "python/sglang/multimodal_gen/configs/models/fsdp.py": "3ad41ffde2108072950e2f82876504a0255324119a0470f1ff4e525ee1ac2e19", + "python/sglang/multimodal_gen/configs/models/vaes/__init__.py": "e4d897af0fa4c3307b543991d62bb785c88f443e845b7461646d8d47eff4df11", + "python/sglang/multimodal_gen/configs/models/vaes/base.py": "d6c4696a6c18f41126741ecd7c14691d819253bbd74f8d70ac08ae6f5634b452", + "python/sglang/multimodal_gen/configs/models/vaes/dac.py": "fe3b6b8a42cd23362479af6fd36c773ad8fe35e50ebc857b74a85984fb6b4330", + "python/sglang/multimodal_gen/configs/models/vaes/ernie_image.py": "bd8cf7d4b64815b7f963413473b5a1af322d21b5bf9396ad299af0c6eb24bff6", + "python/sglang/multimodal_gen/configs/models/vaes/flux.py": "1c47aaca7238d01792e3b0f3630270e06f2667f0363317159364074ec7a9a65b", + "python/sglang/multimodal_gen/configs/models/vaes/glmimage.py": "a9684072f50457c607ae4a785658ce7a7ed727998c72b2cc237888cd40941310", + "python/sglang/multimodal_gen/configs/models/vaes/hunyuan3d.py": "7381f9e37b1549be676099f850b61ef161f44dbbe6f64478f515879dd611aba4", + "python/sglang/multimodal_gen/configs/models/vaes/hunyuanvae.py": "7c3dde2a48e25664d619e1296af9c2b57f9ad9b6322f7077210bfe92b8efaa3d", + "python/sglang/multimodal_gen/configs/models/vaes/longcat_image.py": "9763882931ad55a71bc37730daab6cf72bcea4bda44289ec3b90663777b93059", + "python/sglang/multimodal_gen/configs/models/vaes/ltx_2_5_video.py": "c549785982f1fe27864c1f835064fea74ec1b6412e14467ca0352de0178667aa", + "python/sglang/multimodal_gen/configs/models/vaes/ltx_audio.py": "480423289d72034b97aa5971ad15639b6da0a595d8a10900da43a8b5cab65bff", + "python/sglang/multimodal_gen/configs/models/vaes/ltx_video.py": "00b942b8d00f2d053335fd90d169402d46d96ec7d7a1464b9c0f81a41542efeb", + "python/sglang/multimodal_gen/configs/models/vaes/minimax_h3_audio.py": "3737e8659a94aafe662c12c937b18e84551f518e2802e13a7914433ef1159c59", + "python/sglang/multimodal_gen/configs/models/vaes/minimax_h3_contract.py": "d0934b2d2acdf692983dd6ca3483ddb17f91c601c3ae07c8442cf7c6b5acc258", + "python/sglang/multimodal_gen/configs/models/vaes/minimax_h3_video.py": "cd28c09c06c77b0d398c3a7f670b306792e68c1b2f785d3177de6a374f33e161", + "python/sglang/multimodal_gen/configs/models/vaes/qwenimage.py": "17c44d212e94d29c94e9460b8918f7cd3d441f2e9a3c8dc147f8c7d77b30262a", + "python/sglang/multimodal_gen/configs/models/vaes/sana.py": "88a2c5396c5fc65b92fa5e024f8991c194b2f26aec9d126bd21417a6f589d7a0", + "python/sglang/multimodal_gen/configs/models/vaes/stable_diffusion.py": "ccda6acb4bea0a6fa821c25875c47787795102fff9a0bf5ab18eb640550b730b", + "python/sglang/multimodal_gen/configs/models/vaes/stablediffusion3.py": "08c64fc004f286459c0809200d2cdcf3c4e14406906fa0f270db134ea462a416", + "python/sglang/multimodal_gen/configs/models/vaes/wanvae.py": "1d1428ec59abfecf598cc54705bc7e338c2487aa485a4b4df1c58926e72837e2", + "python/sglang/multimodal_gen/configs/models/vocoder/__init__.py": "595e115ee5493cd740fc0cf2781ba9f5412733e630e21a3fa38ffdb90a2eba04", + "python/sglang/multimodal_gen/configs/models/vocoder/base.py": "5c017b6fae254c1da159d048b4f02c5b7eb36ca667e2ed446d3b96c892f29db8", + "python/sglang/multimodal_gen/configs/models/vocoder/ltx_vocoder.py": "ffc9f3d932daffe269bc95b0c90ad84bf13dfd1aa17a30b1f9abd28c6f6ca450", + "python/sglang/multimodal_gen/configs/pipeline_configs/__init__.py": "c1b294c5a3c418d8f1b44ecd95c02d975b87608086b3a876786829bdfe6e2591", + "python/sglang/multimodal_gen/configs/pipeline_configs/base.py": "066a8bb949d100f4a6b88e71fcb4892273f253820aa7b974019b60213e6a7bf7", + "python/sglang/multimodal_gen/configs/pipeline_configs/cosmos3.py": "bd7eac43e24677d7963f3e2537c04f8e8af5908336cda8cbe0ba56c935a8e610", + "python/sglang/multimodal_gen/configs/pipeline_configs/diffusers_generic.py": "567c368b86cfc3443ffba89d7d1112f807f8ca69586ca495c1581099da1acf8d", + "python/sglang/multimodal_gen/configs/pipeline_configs/ernie_image.py": "f859f7cc9993d95b269bb11ce1e4beb1c3f642ba27aa2d223273442b97bad247", + "python/sglang/multimodal_gen/configs/pipeline_configs/flux.py": "39c60bef47f5cb69bdfaeb9bc3dd115f7b26f6ee03181980534eb2c8e6f88ab1", + "python/sglang/multimodal_gen/configs/pipeline_configs/flux_finetuned.py": "ddb3dd4822d318c93b22ab6df895aebc34cf12d82168561be28eb87d0d39f9c0", + "python/sglang/multimodal_gen/configs/pipeline_configs/glm_image.py": "d0ad46bfad24b2f784babdf8ee788cea6323ae13a7fa641e36f79c4086ea56c4", + "python/sglang/multimodal_gen/configs/pipeline_configs/helios.py": "094a4544fb2251016ce4b62f68737327a722cf97d7506cf6ba47bd4d64de7f9f", + "python/sglang/multimodal_gen/configs/pipeline_configs/hunyuan.py": "6115724e8e69d65c7b407d3ac6166878eaa38a5e7e97aab9b2f338a8649e053f", + "python/sglang/multimodal_gen/configs/pipeline_configs/hunyuan3d.py": "570408aeca5fe43122cbdb4b1c7feb1dffa6fa1202a6619f564fb863e8eb5a4a", + "python/sglang/multimodal_gen/configs/pipeline_configs/ideogram.py": "0767e6b4ef030413a6adc279b2f6e00d74aba7baf4c86057671e8758d1377454", + "python/sglang/multimodal_gen/configs/pipeline_configs/joy_echo.py": "69b6caf69142b33c8cbe02ca93c456b6308c5bc25218abc785efb8ebf6b7ea4e", + "python/sglang/multimodal_gen/configs/pipeline_configs/joy_image.py": "6d162651eddbb853b5729e8ddf49c24986d995ef127d51ac2ae370a03008e39b", + "python/sglang/multimodal_gen/configs/pipeline_configs/krea2.py": "5da1560111d0e48ce7e0bfeb369f3ba646e3f1be0e5c896d05b0965efcde5b09", + "python/sglang/multimodal_gen/configs/pipeline_configs/lingbot_video_moe.py": "994bb9b7a0ad07b36b595abcbae968ab73b635711ce98a18263ad5ea2627ab49", + "python/sglang/multimodal_gen/configs/pipeline_configs/lingbot_world.py": "5c5a1c79887ca31ccd085379dbb23af1b1710c7fd1017129ce46a84af0000e0b", + "python/sglang/multimodal_gen/configs/pipeline_configs/longcat_image.py": "e3b8ec918b9f2b4a34420f65bc3bc14e0e0cbb2182cd267b074f4fdfa0f766fc", + "python/sglang/multimodal_gen/configs/pipeline_configs/longlive2.py": "ca4a7e2a6ad9866f59ebb8cd4dfc0bfb6e108542154ecd9db1985d9075ca04e4", + "python/sglang/multimodal_gen/configs/pipeline_configs/ltx_2.py": "76b57a82baeb51409f140cb7627e3fb2a9461abe80305dc363662fc0180028b3", + "python/sglang/multimodal_gen/configs/pipeline_configs/ltx_2_5.py": "4fe8f9ba981a668b6809520852f8053ba9412c63ca2b805c861d1817dd99f4ef", + "python/sglang/multimodal_gen/configs/pipeline_configs/minimax_h3.py": "02cd79f1b40abfb21b62bf0f6803ff925d0538671cfc91c3a8b051df329e0791", + "python/sglang/multimodal_gen/configs/pipeline_configs/model_deployment_config.py": "e6abd027ad8e0cdfca40c6d900fddb0dc07a6ca5e0031a7689c7ee5a54528ada", + "python/sglang/multimodal_gen/configs/pipeline_configs/mova.py": "e5b7e3cbd4cb343c2cccc04cb8ed890091aa4861b9183c9426efe0a8ef2197a5", + "python/sglang/multimodal_gen/configs/pipeline_configs/pi05.py": "3a96e0e67fa08540dead457c345abfd4c1c71e06ab27d6ec4a7340bfc3e08e4e", + "python/sglang/multimodal_gen/configs/pipeline_configs/qwen_image.py": "160daa9faf33cd38f17ce596a4e364c470af24b2915a0c16ebb4e83edb898c1e", + "python/sglang/multimodal_gen/configs/pipeline_configs/sana.py": "1b8eae33471d32576570b4fcc131391622aa5cda2742b3533110269fdd08a9ca", + "python/sglang/multimodal_gen/configs/pipeline_configs/sana_video.py": "58206af7c464be639e8c15f39261f465148a05856f69b238cab1c4eac202a5b1", + "python/sglang/multimodal_gen/configs/pipeline_configs/sana_wm.py": "440b9eec0707d38812506e669e79e972269ec4876987b1977cfdb47cabb281a7", + "python/sglang/multimodal_gen/configs/pipeline_configs/stablediffusion3.py": "4bb8f9d781bc7fbbbafee672cfa108b1533e5e451abef5627b7c31d11bf97f31", + "python/sglang/multimodal_gen/configs/pipeline_configs/wan.py": "7b98d3af2d1e5ae0d55763b217792c9a7c439cb06567e7c47f7dc4efd8f0341b", + "python/sglang/multimodal_gen/configs/pipeline_configs/zimage.py": "00c3b09219e95dba90806c918275041ff0a05f50dc7745358fbf946e72f29d20", + "python/sglang/multimodal_gen/configs/post_training/__init__.py": "9af6eaef9cd2746bbc48411f2f1851a8a5c754a54a1a3997d70b21acb65ca66b", + "python/sglang/multimodal_gen/configs/post_training/pipeline_configs/__init__.py": "384b0bb57d8d6e35f2d2cf5c9c91e648525d129c2cad5a3853af3587b5d22569", + "python/sglang/multimodal_gen/configs/post_training/pipeline_configs/qwen_image_rollout_pipeline_mixin.py": "46f0cd5d327e7bfaa4bd45c37e4ce5be9dbbde9e3bfe82ef6e82c00b472164a5", + "python/sglang/multimodal_gen/configs/post_training/pipeline_configs/zimage_rollout_pipeline_mixin.py": "7ce0975d78cb71ee7dcc40078cfe535ee76749375961f4bd7fde50d70e52b13b", + "python/sglang/multimodal_gen/configs/post_training/rl_rollout.py": "549259dd777cac147012d00cb3742553cf0b1e526bc2e45b6ae65b8400c8bd32", + "python/sglang/multimodal_gen/configs/quantization/nunchaku.py": "46d75c6bce484ea14f96aedea78e372c7ac49a21c07f8f6bcb5da606dabe7f2a", + "python/sglang/multimodal_gen/configs/quantization/qvg_kv.py": "dff09aa18af398bc7c820b90fac1409f3792bbe7ad6be76415ba424d469f2291", + "python/sglang/multimodal_gen/configs/sample/__init__.py": "b778b25f520563ab805431511e1843e2565058268811952e1e21dd689eaf5f89", + "python/sglang/multimodal_gen/configs/sample/action.py": "312e619c42f4a7827b1976c790945ecb1b64e032dec7697916f1984ba72d6d5d", + "python/sglang/multimodal_gen/configs/sample/cosmos3.py": "e336b83f7c92738b520e97ea05870701075e5e92248deec5b00a90904aa2ddf3", + "python/sglang/multimodal_gen/configs/sample/diffusers_generic.py": "7c739ba3f8885dd79142937df6023f4210eed2cf6a60ade68062eb517b3ff129", + "python/sglang/multimodal_gen/configs/sample/ernie_image.py": "0024b04ba1443b06d10376f794af681c880bf035cf6ae4d341f2904fe3a1dd0e", + "python/sglang/multimodal_gen/configs/sample/flux.py": "442dc7509cf5bc555873f5b31a8396bbc3cc44ab889fd498332224d8fa28113c", + "python/sglang/multimodal_gen/configs/sample/glmimage.py": "877bd695ee7245b829b540fa2c3fa326de7e891bc14cf022b7e2d47b638f20fd", + "python/sglang/multimodal_gen/configs/sample/helios.py": "8833aeb5318dbc983ec8860138b39d9c438a96f8bbaefb2402c306b97cf721b1", + "python/sglang/multimodal_gen/configs/sample/hunyuan.py": "1cbfff666fd539a55c3d21a2f91c7f81a688b34d03ecf698a080ec11d304f3bb", + "python/sglang/multimodal_gen/configs/sample/hunyuan3d.py": "a0e25f004514dae1a3ed0088c2c223a2ee893f2968c3757cbbb2f7b9f5c47920", + "python/sglang/multimodal_gen/configs/sample/ideogram.py": "6dd82d4d64a1de984bc3c10e2fed512f0490bb045f860c54e44795f94527ae2e", + "python/sglang/multimodal_gen/configs/sample/joy_echo.py": "57162970cc3cbe6c3c763cc20087eeb3c06038a4ea7652d16d15a3f97681c466", + "python/sglang/multimodal_gen/configs/sample/joy_image.py": "b61ace5aa2d288ef0b640ae2ec2acddbb497695ab13f86375542d41ee498e11f", + "python/sglang/multimodal_gen/configs/sample/krea2.py": "be892859626e7fa990fb00b94322add56e1eead791e8f4bfb8b266765f20d148", + "python/sglang/multimodal_gen/configs/sample/lingbot_video_moe.py": "70a071406105599dcb355ec82bc3bfe6c71edf2687bb91ac760877682716e276", + "python/sglang/multimodal_gen/configs/sample/lingbot_world.py": "5179822eac4a52098c168fe09a83afce311d506b9b78a45dc071b082ab7b978c", + "python/sglang/multimodal_gen/configs/sample/longcat_image.py": "3dcd05441fb21ce755081b79c190c750078ab194b1cf1779e57d7d42e72ffd24", + "python/sglang/multimodal_gen/configs/sample/longlive2.py": "c506485d0f0cb8f15e63a20d4896f6bc6f45e031b3922cc7d0c4a91d23e401eb", + "python/sglang/multimodal_gen/configs/sample/ltx_2.py": "99c5a0f17b090d77b2c6ba384c132bdd2a8a845c370c48b4a6b2a7fa72ac359d", + "python/sglang/multimodal_gen/configs/sample/ltx_2_5.py": "fcc768ce71f87c55e8a62ccd229863faa16122053a46dabf0e56e1b5f63af64c", + "python/sglang/multimodal_gen/configs/sample/minimax_h3.py": "18af182ad5f8afa61f179d17df9f9b5114a8fce54a4f2f9ea30cc388924312ae", + "python/sglang/multimodal_gen/configs/sample/mova.py": "1c3feae81b4b4e00a94844657967222b95c7d01819520b912e1afb712d4f0014", + "python/sglang/multimodal_gen/configs/sample/pi05.py": "5d43e92d41f54254482506620822d19950e8645f5f503f31a2c725184bb6d543", + "python/sglang/multimodal_gen/configs/sample/qwenimage.py": "ea8444691bde59d12f1a6d43997e9951618c56521741144b92d32cdc01474d96", + "python/sglang/multimodal_gen/configs/sample/sampling_params.py": "6884e0e62f02f66936a8ffa2937be94af2b97b32943f56b8ed1219a634da1d6d", + "python/sglang/multimodal_gen/configs/sample/sana.py": "f85ffe657605d8bebf9598b33cb05589b7304923db0a37fda65462006baf4ebd", + "python/sglang/multimodal_gen/configs/sample/sana_video.py": "2ddb49fccd4ff4e1dceb15f0a2d70d25e7d26d17598db480c901bc80024eac4e", + "python/sglang/multimodal_gen/configs/sample/sana_wm.py": "8181be4bcf14e4f7b1423ae681678409d066356d7deaa3c2ea08127cb53c579a", + "python/sglang/multimodal_gen/configs/sample/spectrum.py": "18cd0b88b5b5a7fe1f068973ba22a530c7810e4e8d1f79ea36dac3443ada0139", + "python/sglang/multimodal_gen/configs/sample/stablediffusion3.py": "a414cde6f8779e90d1828b3a75446550f9ef604f78d64d8721fdfbb1b085fbe5", + "python/sglang/multimodal_gen/configs/sample/teacache.py": "f0a19433a5f11c7d999651a1d09663d6bbbe840e7a654aeeca87fd12b262794e", + "python/sglang/multimodal_gen/configs/sample/wan.py": "85302beb7475c408238792ff52fdfc672121e63d7e17765f12d0063a82b82e27", + "python/sglang/multimodal_gen/configs/sample/zimage.py": "d6ed0e9dbd2c69e3397fd19968b5c974deb2132c6418fb6d443c91c1de21a772", + "python/sglang/multimodal_gen/configs/utils.py": "7600c200fd9da5f922009f9f1b7787f9d3bc47857ce2a1a96445e2f872d6b27d", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/README.md": "8c55e15fcec89519413672672d58175a172ca8e94786926b0ca433671a09ef8b", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/setup.py": "7cb78abf9ca9acf25098d7a460b3367e6886fec303fbd9dd950e5f0c5b7a6f83", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/tests/test_vmoba_attn.py": "7a52823f5176a6f0961b40e0cc8fc226adc8098d7706a64bea938efcb9733e50", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/vmoba/__init__.py": "30371a641040376a6189b06621a789767c059ec9df7ec1f2d4dfb12a6dc9c1b3", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/vmoba/vmoba.py": "cd227e62840beb31d4d1ebf507c81b8c33a54e20c1a1699b7fa8e5dcf8000a71", + "python/sglang/multimodal_gen/envs.py": "f71bbe54d90f8d07e8d4131f01a05b91a8a6d2cb9224373bf1d937184b10708c", + "python/sglang/multimodal_gen/registry.py": "a771a635ad06ad8a11824bc225bdd160ca3b9cba88f69a41e1398eb992d6ce1a", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/__init__.py": "ed9938cb6b128de384c2b176d2fa033e0273bc3eecd6d0d2f1a6a82721b2d99e", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/__init__.py": "e691594a5ce99c7f54e73d0f971623d7f1d2ce3aba2a05da9aa8917833264a9d", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/ideogram.py": "636fa822c85d14bcb59787a0f534ea369915bc68db897dbc9515ca208e32ff4a", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/minimax_h3.py": "ba1e588c1a880f91faae63568bcca3aace973beac3d53d0d9e5abe96ac74ca7e", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/qwen_image.py": "ec4b97f00fc9abf51f0b3dd5b0b66620c2d19672818390ff1e0787e8e54f1084", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/zimage.py": "3a4bda19ac8238b3ffba87b0cde6331d6212d6458e995cd0bb0fc4a46122c130", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/prompt_padding.py": "a25dc551ecb6a063acfe78c5407c5aacd8675eea4bbadd38020162748243120c", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/replay_token.py": "a369b0fd300c533037ea85471488ae86d6ab6933204e62b6e62f060e046a025e", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/runner.py": "1a02770b3a0e98c8b3b61d56e2fc616e985f7669bf1d9861cf317a92dbccba6e", + "python/sglang/multimodal_gen/runtime/cache/__init__.py": "0593d7834935ab33a73567fdb33dd0d39d4eb1b2f34ad9dad698c08a6890f252", + "python/sglang/multimodal_gen/runtime/cache/cache_dit_integration.py": "42a68d1cbcd78069590734f895df0c4ddabb805c929c34d3215d91c6bffc5a4a", + "python/sglang/multimodal_gen/runtime/cache/spectrum.py": "913cdbb160a29ed347d926dd134bc578486f5b621c5fb91436cffad4d6d97bdc", + "python/sglang/multimodal_gen/runtime/cache/teacache.py": "786188df7fc2012b074d560fe5cb4c7c3ae4d6edc0ae856e072ba794f0d9e41d", + "python/sglang/multimodal_gen/runtime/disaggregation/__init__.py": "637371500f02c55002eff448b2f32dadc9e0d01e613b6bd2bcd13551611abeba", + "python/sglang/multimodal_gen/runtime/disaggregation/disagg_args.py": "3ff0019ac448754180d7d566549d77427b551177ca753a8c0d491c29438d27d8", + "python/sglang/multimodal_gen/runtime/disaggregation/dispatch_policy.py": "957c7b881f80fe26a8594f97582ea0f97fafc69d8b8406689dda44c2f148ccd2", + "python/sglang/multimodal_gen/runtime/disaggregation/metrics.py": "0d1df4dae44b1815ba2a002a58693fb09f5aba042045cb41652c5aa8ce30aa27", + "python/sglang/multimodal_gen/runtime/disaggregation/orchestrator.py": "95fe507d88b67addf3c9c050fa715cdc5dde8f8a5f38b53d058569a30b76df3f", + "python/sglang/multimodal_gen/runtime/disaggregation/request_state.py": "86dd2c18a08633d96adbaeb24214d5726fd86db3f5f7d0c35966bef062e7188f", + "python/sglang/multimodal_gen/runtime/disaggregation/roles.py": "7c21ef11bb940c6e91d67fcd43ea20837be91130bb4a877f73609f70bb6831c7", + "python/sglang/multimodal_gen/runtime/disaggregation/scheduler_mixin.py": "fe6399204805e6cfc2820cf58d935ae0e9a066ad5157cca4bebe81bfe18b8f29", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/__init__.py": "6deb74a4679590b2b641b8a2b62a6a6fc390af3b608bf0319bba2f0a8aead715", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/allocator.py": "35f6f2c20ab6b83bd5f30f5b9803ae5618a1fcb044352077aab933eefac12093", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/buffer.py": "20ab807cc1fc4f82758370289a7da6e3ea2cef74a6a795799c668519f626d38c", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/codec.py": "fd4df92e4c5dbbb601eefaf25977c274ccd498a85fd28c0538e17effd58a04f7", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/engine.py": "ab6005a8a3242764d01cb17f238982e5c70e78b76f1f6ba28ae67e68590c2f90", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/manager.py": "97c74bdfd98ee84dd1bcb7ac9b505b3a137d87838529c9a0dab81c925f998372", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/protocol.py": "ea19ef2ea91b7e411ddde6d46edc0ad2d9e7d1836033ef5b244e794b790d8e4f", + "python/sglang/multimodal_gen/runtime/distributed/__init__.py": "5ef3261028b21da8e68affed24d0c66af68d68b4d65ba66f6a55f995167d0c00", + "python/sglang/multimodal_gen/runtime/distributed/cfg_parallel_utils.py": "722358a14230412a93135f00dc013c0560d93afadb03c732a9541feb60ed9499", + "python/sglang/multimodal_gen/runtime/distributed/cfg_policy.py": "a0cf5b16d0dbcc534f5b6487c7a2cfcc17fd1280e37c20e9b50cddad27f36e8c", + "python/sglang/multimodal_gen/runtime/distributed/communication_op.py": "a1d2aad120fb6bcd062f157b53165dd2d363b6318da4efec58fa2ddccab69568", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/base_device_communicator.py": "f3fdc26e0f9722a2662dd43e7f11180ffefd634d90e12b1740b2a9a0d2303f69", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/cpu_communicator.py": "7d1a179969c451e8adb9b2907780f4c2b4fdd18ace8f10d7cdcb129eeba1f66d", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/cuda_communicator.py": "24c6930bc8d15f50354209c71f7dfd4365c89d3d806c138aa49d7a90d220c79e", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/ipc_a2a.py": "cd01f9b81c72ccbbed1c942a4cfc4906f8be1a3dd74e1d52baff5bf0c48fed15", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/pynccl.py": "8cb46b8eee1063af1a0f8eca6d0912e64fcb86583131856863c4b6df96482ad4", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/pynccl_wrapper.py": "0eb4f8a9d5cf935f8126b8edc9ef80069d406ac17f8df491cff1c29a68939bd0", + "python/sglang/multimodal_gen/runtime/distributed/group_coordinator.py": "068cf27a3cb33da6d76b5076e46d3686f63b63453877a8a37d5012f29cd73631", + "python/sglang/multimodal_gen/runtime/distributed/parallel_groups.py": "b33f9e8238660a595e80c5073abcf424b7af2081a1ac9cd694778f23f994cdf7", + "python/sglang/multimodal_gen/runtime/distributed/parallel_state.py": "97692d77e1cb060ea7643eb9ad5342ae3db360010a20d781fcb6b642b3a6d3f5", + "python/sglang/multimodal_gen/runtime/distributed/sp_shard_utils.py": "40cb3fe9936966d020003d316a01bcfdea5f091637d05d2a5bd2af5260234f2b", + "python/sglang/multimodal_gen/runtime/distributed/utils.py": "d38d571a05dc1c83532b2f7942ab07807b3d0f0b7a2839d24ddfed86fe01ec40", + "python/sglang/multimodal_gen/runtime/entrypoints/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/entrypoints/action/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/entrypoints/action/api.py": "d8c16daf739fd895a65086aafba13273424b3e4cd4f5fbdaa83d7c14aa4fa94f", + "python/sglang/multimodal_gen/runtime/entrypoints/action/openpi.py": "bf41537b451d25887007df345a27a2d099be539fdbad302c5d4f89c8d156c994", + "python/sglang/multimodal_gen/runtime/entrypoints/action/protocol.py": "46188a7fdac7ffbf24ae3da4be46faac448f290f7ae2fa90a6389195f695a070", + "python/sglang/multimodal_gen/runtime/entrypoints/action/ws_utils.py": "ce4f1a12e9f5640cf0480d985a8b87b5701cae1c064b32e25b298f2f473b6e70", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/cli_types.py": "ad856b9c58ac35d9b1a6fc3fcd7767618faaff98c310ac8cccba80008b41be49", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/generate.py": "9ab20ab25260882b3128573e14b12f54c0bf53560f08040ed90fad6cf0d573c8", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/main.py": "290966752105570d8b96f3c95245e84510c4ac4ba72443c4e6724f7689eb0456", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/serve.py": "23db35d4bfbf3ad55aed39c4597aa61be1667b16a5b3d73377c86167ce663e9e", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/utils.py": "f1e98ed568eb39aa8d41e077b5092ccc95f49520fc664037ee909bab13ca70a0", + "python/sglang/multimodal_gen/runtime/entrypoints/diffusion_generator.py": "8b4b23bd0420f0f88e7b354daa3a5e20f8d1d5569aacbb97c084645c296e996b", + "python/sglang/multimodal_gen/runtime/entrypoints/http_server.py": "09278b36165f2c7d81b7409b04cc1f1fd13a575af49007206271158a0eb946b2", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/common_api.py": "ff05244c75a516c93b6009ccc06698836d10501e812813177bce3c5eb1ea0eb2", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py": "24dbba5240324a27bf72f3a8e41f980b70b704c7b14da8d9691f886371c15184", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/mesh_api.py": "94a9c8469bc9644835df54a62a47ebb63473ee3880f1719eb5c2427738f686ac", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/protocol.py": "b8ba2aefe78ac6a948cd3a557b771e06cd57fbb35884d476abdbb62492218db5", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/adapters/lingbot_world_realtime_adapter.py": "85124e3287205c3eafb506b096b535360f7afb235c30c96b1a2967126cd106f1", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/adapters/sana_wm_realtime_adapter.py": "be6916085f7b325979e0746c3d23f689f625697dde361bb6218e96e25347fd01", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/generate_session.py": "11346d37d5022742798f4ebdff58a7656765a10dbf2b2f41e3a213c54183e189", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_adapter.py": "55f1ab90571bc336d6a7d3fab679b051a863b0870bf43c0a7961256b1dbf2470", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_output_adapter.py": "9f344bb1e243c41c726a4f4608a06108bf5456d9bcb92a32e84ac6c38226ae98", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_video_api.py": "331d27962a902a72f68ee6b19986b602806c5efc4cdc856b4ebac72891917ffe", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/registry.py": "181c5594ed95f042cd6493810880f39804ff5383c1d673e5f48a382f25468f08", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/timer.py": "5cedf5f6e7f97b0e54baa7122eba13a31ff0bd357046a88c235eb512a7181c08", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/storage.py": "2fd45ef1c008baa9ae0185c65e077525df78e1c5fb155401cefc8022c5b9d471", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/stores.py": "8e290bd34d3e50ad173133926a9007b5930f440faff7eac00573fc88b39f51bc", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py": "78c1f60d5c4a6fb73acf24308586b1e1f95be25c373f6dd00cb4a04509604b46", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py": "446b3616c29a1b155619ff94d8460fedeeeb490a877abd0a0488b13f378d2247", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/io_struct.py": "d62d372fec05931b0c584e51ce2a874413799e53ea4d63d61cca69b6b19e77e3", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/rollout_api.py": "f61f6a43234e29fa985aed7adbb3f6bd81c03b7a6b9367461a9cc707afacf762", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/utils.py": "361613b9ee8ad2bfd25e19ae09f6ded30952d16b5bcd5f87bf2f424eae9210bf", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/weights_api.py": "be183aa4332472ca3a0d128e0b0a31f56b107bc44012ff351962f1462fc35dda", + "python/sglang/multimodal_gen/runtime/entrypoints/utils.py": "04afb89171c1807c301aeba6767efc4a6ec468437d16b8bc2c9337d8f5e3fd41", + "python/sglang/multimodal_gen/runtime/ipc_array.py": "a2c78346bd200520a3d29638a08edf0c6a4338a8b9f396d8c2357ce0004fb5c7", + "python/sglang/multimodal_gen/runtime/launch_server.py": "6c6c7c56a49299d8c6b0e5ce0e9aca59b5aca654d165b9526274dc0c1a1d46bf", + "python/sglang/multimodal_gen/runtime/layers/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/layers/activation.py": "9dc28da8e1c91e5489f4d9b02733e24807b150df1d9002990db9fabedbc0ee69", + "python/sglang/multimodal_gen/runtime/layers/attention/STA_configuration.py": "fded1886b3a0fd838f5bafe9a10aa0e351ec9f7aeaee50894af3c5a017f89a4b", + "python/sglang/multimodal_gen/runtime/layers/attention/__init__.py": "46c51ac1389ad58b4f46217454123de8d3f7ddf43e31c938acdf7a2f657c8833", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/aiter.py": "928da73506dfe0e3c1fa2b8c809206b6b489318e70a9c7fe35ea9365d95f5687", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/aiter_sage.py": "c022df1d60224c845a7c257e913d2e54769022b76f0327b95192285ab5c8fe73", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/ascend_fa.py": "5a61939216e8ad7d52fb0822bd114b224dae5e677acd7327734905916fb418e4", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/attention_backend.py": "12393e6ddc45229d38ceab55ce9a0a17ddfb1e8ca713de14cddf0dc48d6b6f47", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/block_sparse_attn.py": "93ffcbcac2fde37b53e7527cb8debc587e28038869e90045dfbfbf3c662f1dba", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/flash_attn.py": "eaf432dcd08afd649c62976b81802fb3c70fd338a434851a65db13b793b825b3", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/flash_attn_2.py": "38140528f6f6669844a2b746cb007c721f60c0b52df0801e9fe73bf0ade543d8", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/laser_attn.py": "8a13f75f0c27b4e686fba586b49f313da404789ef133b443778928ad53124f4f", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/rain_fusion_attn.py": "8c29c01bb8384ab729070f448b8f4444401aa1bd77b2a6484cbc87cbc7257887", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sage_attn.py": "fb8b9ac4f1b5d0c9f866cbed8f4b5405588899b6bc5a2a707be74215d0bd7bdd", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sage_attn3.py": "ce91c06a4eb6abb7fa027666274b23855c412f8e82721ca4ef4e89aa5c02d294", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sdpa.py": "49afb36bf827dfaf534e3e3b9cbece6e71a1db8b695829ba06bdb619826c35fd", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sliding_tile_attn.py": "e7c5dd336059ada2b7526463593d8989751cc822c600054c98e5136f6abe1ec2", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sol_attn.py": "996102079ecae4df164701a8d08deeaa66452006fb810daa35c8ae2fdda5e517", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sparse_linear_attn.py": "37e757c73e82e3826c919091f51dc7e2021312927c3ce4abcfc77626574cbcaf", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sparse_video_gen_2_attn.py": "4669d65f68ae16436c8969ab5c98ef5374f5d144aae30579c3864f8171690bb4", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/README.md": "6d68705da25541ee699796eff43b4ada400362c98818e4c4c01155014bd8b677", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/__init__.py": "39d2a968dde6bc116d17168f190f11f5666fed502611d099014778742339124b", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/kernels.py": "7b8b2943ed05f13a380aa1c1843973cf3b7c3c7af6d34d6fce74cb7958bf663f", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/router.py": "03330e28e03b059ce08a9d095f0212c1cc04ce11ab52feb220a3b6739add2407", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse_attn.py": "54c2946bbb4ffb37cd2d707b45ba015bbe294f8d675ac45bb792ac286f72c055", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/video_sparse_attn.py": "a6c80e39f2622b2f1f6d01b9267ff14a36c10bf05a8d8f1f0681a6a8ba33c68e", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/vmoba.py": "f3f1037eec6ecdd186df6226fa7e6161b8e6fae3bc3032307da2a70e9d759f6f", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/xpu_backend.py": "d867b65b5c5fc3e63c34cc77a09afe7ae6830f12730cd31021c1566241cfe6d3", + "python/sglang/multimodal_gen/runtime/layers/attention/layer.py": "879b43077a22be735c53ebadd4e9be4e33219f8139d7380c8c50e788ede1d661", + "python/sglang/multimodal_gen/runtime/layers/attention/selector.py": "68f9b6763b8b65c1362cbd2ee7df5f72135050109b31c3dd165a2243d2c98e8a", + "python/sglang/multimodal_gen/runtime/layers/attention/turbo_layer.py": "a603a836ecdb581a83059803f270bfd22ed01829732ff4bc602b1c40b6b6d48e", + "python/sglang/multimodal_gen/runtime/layers/custom_op.py": "9388052a00baf625ffa358c489ce643d9fb49759ba04bcd46845f0cb55580ba0", + "python/sglang/multimodal_gen/runtime/layers/elementwise.py": "c76dc89bcecc70752756ee4d79f6aa64b28b8746098b65e2ec80113f0b583a8d", + "python/sglang/multimodal_gen/runtime/layers/fused_scale_shift_gate.py": "aae43a406f2c2a4488567a94ce6537258541aa96a8d91d6ddf4268f4b39b3f85", + "python/sglang/multimodal_gen/runtime/layers/kvcache/__init__.py": "33d037000a3b740f0573069e6fae5b713b2334185604f5a3ce430c1946c5a8d7", + "python/sglang/multimodal_gen/runtime/layers/kvcache/causal_attention_cache.py": "628728f98c5ad29f85d5ad29af706d092d21930aafc026599124c33efe9452f5", + "python/sglang/multimodal_gen/runtime/layers/kvcache/qvg_packed_cache.py": "cc41601d83644893f0413156d6f7478ab664283ad4fa5cb09945664e22e313e2", + "python/sglang/multimodal_gen/runtime/layers/layernorm.py": "42a000bb3a098d32b106d04977c5fc513d0a1f52d5f131fcc793774280ed7362", + "python/sglang/multimodal_gen/runtime/layers/linear.py": "a93ff5a04c74ffe1acacbd3438273044764f81ff53e41081cf5134c50b8fc0dc", + "python/sglang/multimodal_gen/runtime/layers/lora/linear.py": "4864a0a17d3f3c1d2cfe68531867d07ce78dad05faec87a39226583c3e43899b", + "python/sglang/multimodal_gen/runtime/layers/mlp.py": "7592e9c7449b607040ff5c17aa78463d158f138944835f8ce26d94307cddee6c", + "python/sglang/multimodal_gen/runtime/layers/moe.py": "a12ec5824b9d17862fd4808f6c19ca6340c1bd7d4c61f61ed919ed82fccda1c1", + "python/sglang/multimodal_gen/runtime/layers/parallel_conv.py": "f9a95097322e80990009252953337d5dbe6a8ae5ff33eeb768e38bcb13b7b527", + "python/sglang/multimodal_gen/runtime/layers/quantization/__init__.py": "ef37cd8cd28bd5554e58f918f13883cf59b5408e110a6d798145432d5632a292", + "python/sglang/multimodal_gen/runtime/layers/quantization/bitsandbytes.py": "00c19985ebc02708d4f9354cd0754ccac13e09af4bbca86b90f47d0bd635ab48", + "python/sglang/multimodal_gen/runtime/layers/quantization/configs/base_config.py": "56c3943c380fbe0584c4f8bd75f51ad2e87605697200fceae944117cd34db9a5", + "python/sglang/multimodal_gen/runtime/layers/quantization/configs/nunchaku_config.py": "637d795cf3b26829373caeed22a7074fad44e331c952873676562e3905db83c2", + "python/sglang/multimodal_gen/runtime/layers/quantization/fp8.py": "a9f129870a6ba8a3ee1f86d53775f04a2fa27d736b713cc51bf42122e4928449", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelopt_fp8.py": "0779107406b1508912e6f3b854a81a4157fb85dde0a6f91f5ebcf1ed100949df", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelopt_quant.py": "1a76af8fce37bdd2521d24e82c54c695c064074efcc83c3e6cd03c90fc939cef", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelslim.py": "6c3aa92b21ffd8a734869ec87d2e5809f9e85d9b00942ae3a1e13b6d7bcb0d67", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelslim_mxfp4_scheme.py": "19c68dd5db6908eca3a733c73d1767707b132f8cfbc5b6a13e87caffd1c7c1f8", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelslim_mxfp8_scheme.py": "0d6fc7dc42e3765f07acddbb9444306dfd7fb64b4f859056a0e5d2f52e828a94", + "python/sglang/multimodal_gen/runtime/layers/quantization/mxfp4.py": "a59f4917982c88acae54f2e91b49ac9def4d0966bb0dc905f78b4ffe595fdffc", + "python/sglang/multimodal_gen/runtime/layers/quantization/mxfp4_npu.py": "5f2368d00347d7af10608b41c3ca737f8410dc7b1f53b19f993779a8bb9ec5a2", + "python/sglang/multimodal_gen/runtime/layers/quantization/mxfp8_npu.py": "1ab8788677b8e3bf5a39f5ea4234280f4df7d38558656980cf55874ba2bdae06", + "python/sglang/multimodal_gen/runtime/layers/quantization/nunchaku_linear.py": "d252165ceccc0d8fe728df9eb5fb8e02091878ef5df53dccf0bb160af10eecfb", + "python/sglang/multimodal_gen/runtime/layers/quantization/weight_only_fp8.py": "b92ea052c6fe113857f36f50541b40d6430cddee997f1189df05857b230016e8", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/__init__.py": "9af17cee919e0f0afb621e8e880df502cb7160590fabffcca5b64ff7cbef7c7a", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/base.py": "b590ca6cd7dc2cfb54357a19d49910ec0d5d975ec49d0874d992829ffd3d477c", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/factory.py": "1101cdfff76713a140c9b106e18705b56b5058535ca767082890a946a1e6de38", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/mrope.py": "2ac0f8d13ea663303095f8ecdb3d7a1520ab851a3534d29cdd9370f5184bbc74", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/utils.py": "7d05ab83063740a79559b411c07cd4f2191ee7a8952b5c8d6a73a5709b44a51b", + "python/sglang/multimodal_gen/runtime/layers/usp.py": "0ace6e1c70d7d5fe925ec44d903aafeefe96535ed8bb0e38b69da95ca116be82", + "python/sglang/multimodal_gen/runtime/layers/utils.py": "a2dbc990916cdaef054dd201c61301edaa738ba1d330ecc7caf2b42fb639ef5b", + "python/sglang/multimodal_gen/runtime/layers/visual_embedding.py": "d9da8fd38234c5f5deeca7d210d06aad7dc686c5e506212a60d65d0882dc88f1", + "python/sglang/multimodal_gen/runtime/layers/vocab_parallel_embedding.py": "9314f9ba2c7ef50bbc1a9e61037af62cf459a3963a7fd81db3de072b3e13e74d", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/adapter_loader.py": "a9dec97c947d5a7bce46526edd05863c32d5a5ce0dd44ac0cb955b9c8b94453a", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/bridge_loader.py": "6691b945a9d7f5f1dd5c8b391ccc63e5cb4507d923461bfa54530f1afa09d6c1", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/component_loader.py": "e0786c2eba8b48a1a6389bd4a246695b827ec9b1115579be9cc378135f2f367a", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/diffusion_decoder_loader.py": "3957341edec37d5787c3dd3b11d11a9927d449a7428e1c17193926c1a9be02df", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/image_encoder_loader.py": "1cd07a83cc47eec407a9d9210f0ec7dec50a2432710f62040a82f9a91b00c0b7", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/pe_loader.py": "a20bba36f057558380c1a1631391292959559558289f469e002cfe60d685e9c4", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/scheduler_loader.py": "aba7c83504f654bc3498e5820a5bda855d9aacfd3a83b667fe1c8bf29603497e", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/sound_tokenizer_loader.py": "b1937d0e7fc4f5ac68c6c7c3ef7acdb3b46fc980a4b714a4cb18f02f5b9ea533", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/text_encoder_loader.py": "4528730cb89f0a6ece895926e989274d8f82051f0dbf5bd64448446d344f42a2", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/transformer_loader.py": "ee3e50d928fa91be176223bb6fcc0e9c3a32b6a6e9414957086b718b88e6980a", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/upsampler_loader.py": "8535017e1755420fd95b0ce35af63514120fdf3259824063f5992b8e123cad27", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/vae_loader.py": "6df64e4d08020c4ff97880b18ab4183cc172e3a92638984b95d7cc746591ab78", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/vl_encoder_loader.py": "8c5d44a51e09e42047bf98eb09291136feaf912aadd96ee4d71dea1d590108d0", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/vocoder_loader.py": "999209b8c2987270ec45fe0a601d96da6d476f6c6d834f328a763f132b22c6e0", + "python/sglang/multimodal_gen/runtime/loader/fsdp_load.py": "5f08113b54f234f30ab1db404b730b97b58fd7ffde0792ee718eb99edb995b0f", + "python/sglang/multimodal_gen/runtime/loader/rank_local_checkpoint.py": "69988377a57733cecfb8b5b96f7e6ab9d208797edd9d61d2040cad25abafbff6", + "python/sglang/multimodal_gen/runtime/loader/transformer_load_utils.py": "d33c27f94139267ab733d9de0a6565faa0c6fd4dd34c6ece02dcb470b4a816dc", + "python/sglang/multimodal_gen/runtime/loader/utils.py": "dc426ac72030a31df4be048a762220ff909f43ee59a8c4d94bbfb25faeac65b2", + "python/sglang/multimodal_gen/runtime/loader/weight_load_plan.py": "c0fdc358f9c86507c613a11afc8af2725a2964c0799d5de640c87979dde146e3", + "python/sglang/multimodal_gen/runtime/loader/weight_utils.py": "9ed60494b361302297ad3b5c316a99a16cd0a6e30ac5a5b2c99cc554caa442fd", + "python/sglang/multimodal_gen/runtime/managers/cpu_worker.py": "9129530d59c1e112c93984a80f74a2d241434e4e93ee88edb7812ff5768ef18a", + "python/sglang/multimodal_gen/runtime/managers/dynamic_batch_admission.py": "a67970658b01e97a07208ca732f57923a51a170322cc20c56d05c09b6f136bff", + "python/sglang/multimodal_gen/runtime/managers/forward_context.py": "ec1d8deb655cbfd5d35a0cb5512728cab8a3290c92e81cb914453f855b7f53d0", + "python/sglang/multimodal_gen/runtime/managers/gpu_worker.py": "9360c8683df090e312e73b9fba6daf7fbceac0e64038f23ddb9050496b4e073e", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_loading_order.py": "b9475e14187a68a31d2788a4dbe9a169ae50dc0456191a3606fa066c6aa497c8", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_manager.py": "723abea1ae61d23b5e6af1819e7b582482a24f9900f83166a5b99c97331057dd", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_residency.py": "cd2cb0842d59f1e8b49325affca4e5d01551358d93c2afe6e19677b35ae1fc52", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_residency_strategies.py": "a541de018df77e94511bab2b758b657c47de114dcddb28a106726bf449ef25ad", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/layerwise_offload.py": "ddbea630f8eb6762a5107c2858003a1070f78f5d5618383bc2a87a8ca2070c47", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/layerwise_offload_components.py": "41ffa59ce3b01c95257dc6755a0dc0ec1a52c12378b349cff6ebe64b3dd68db9", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/memory_occupation_controller.py": "a21bb65a9167df86b02a4513c9ecf6cae1bd0b2d74941585961d2c7d833e642a", + "python/sglang/multimodal_gen/runtime/managers/scheduler.py": "5941b8bf6b8bccdc90bb7b53ad506215a8eb8eafe4bb4fd96b1e835191616424", + "python/sglang/multimodal_gen/runtime/models/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/models/adapter/ltx_2_connector.py": "710f57417f28eb4a343b598436de4916206ea5f5ee923a103cca4553edc06452", + "python/sglang/multimodal_gen/runtime/models/adapter/ltx_2_duration_head.py": "b6410dbee092def590e27c24148d165dc37af5b7160f139b275ed1d38346e5f5", + "python/sglang/multimodal_gen/runtime/models/bridges/__init__.py": "a4752c5a87fe7199c2f200a41bf6beaed51103fb0c8bb220587945f8332b82e1", + "python/sglang/multimodal_gen/runtime/models/bridges/mova_dual_tower.py": "2d863267a53296ccab8b70639e38743d6825a929cdbb3eb9a3f8ec4b8127f49a", + "python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py": "09bfa5b29d65481cab0f73148a0b93e150d44915d6bb78a67127ee476e6a553c", + "python/sglang/multimodal_gen/runtime/models/dits/base.py": "a2b301251870b280b084e397c971cc943c366fa419d058ede417468a8ef0a22a", + "python/sglang/multimodal_gen/runtime/models/dits/causal_wanvideo.py": "3689266cadd01628396e31113158061fd44679415812c60e52b006ec574adf4c", + "python/sglang/multimodal_gen/runtime/models/dits/common.py": "ff49004f0cd0e2554a0d3cd20eef5fe781e12cea9bca1e6fb560bc07aaedb6aa", + "python/sglang/multimodal_gen/runtime/models/dits/cosmos3video.py": "4080aa3de0d00bdc084336cad6d2cef6cd729d537559ffe596f40aa8c6418e56", + "python/sglang/multimodal_gen/runtime/models/dits/ernie_image.py": "dce5f7a888245a70d1a2d7e95e2cdc094e7558f05aa26effd9b1063ba3e5ec8e", + "python/sglang/multimodal_gen/runtime/models/dits/flux.py": "bd54b552882016cd03762d5616f1b69b69c103b9c6259c397bd652dad04fe572", + "python/sglang/multimodal_gen/runtime/models/dits/flux_2.py": "a47e92a208084baf1884f87447361b3992cd3f7f01559482a68d70f64db44c80", + "python/sglang/multimodal_gen/runtime/models/dits/glm_image.py": "2cb1e8b15a8c2b8d127cab6d697aebc7e3fc3899944daa2cd7b5b87e3d30950c", + "python/sglang/multimodal_gen/runtime/models/dits/helios.py": "88b1db03ec90430f6f95c8ddd1bb5985fe6e0c5166f111cc7d8d2c24446a770c", + "python/sglang/multimodal_gen/runtime/models/dits/hunyuan3d.py": "2b6b93a40f98e6451ffcc91d15526a4c52eb98e57df8e203783c778a158d755a", + "python/sglang/multimodal_gen/runtime/models/dits/hunyuan3d_paint.py": "6459c735a0b1f8d857a9b92aa76c33bc6c6fb391b5a5efd07453b5263ecff8a8", + "python/sglang/multimodal_gen/runtime/models/dits/hunyuanvideo.py": "1a688c928e44e335ca7979e41d96fa41dd84fd44a378b24a4c9c1513ee024186", + "python/sglang/multimodal_gen/runtime/models/dits/ideogram.py": "fb4c039364b191663b4f71ffb11682b044ac67b04f8a2e184f59f70b5222f345", + "python/sglang/multimodal_gen/runtime/models/dits/joy_image.py": "abb18fdc282f7d671784c47275fae907a6a5bc3f3e6a74348bc131609d4001ac", + "python/sglang/multimodal_gen/runtime/models/dits/krea2.py": "b94f77b11e881bd4b9e910f7cf58f42d0c2e310e3e8493f2b320a5b1691ac6e5", + "python/sglang/multimodal_gen/runtime/models/dits/lingbot_video_moe.py": "20cf369807ed2c7c3815ad9160d601dc598ade9f6ddf2fd8fb875d21c89f706e", + "python/sglang/multimodal_gen/runtime/models/dits/lingbot_world.py": "c5d9d06cef80d52fe7e0439a9dcb018e30ed39d08d08b5e903b215c1810aa919", + "python/sglang/multimodal_gen/runtime/models/dits/longcat_image.py": "a4ebf8515b0a339ba7b8dc62ff4f2943819d623d0cd761e3280889c562dc29f3", + "python/sglang/multimodal_gen/runtime/models/dits/longlive2.py": "5c1e10078bee0e9653e954e918c28ed94e1060e322b4d5ae8a657f95e93b1727", + "python/sglang/multimodal_gen/runtime/models/dits/ltx_2.py": "0c70037aa7038466fd8d2917868378c44c0cc0a907ab6a054bf558a0c58f4ea6", + "python/sglang/multimodal_gen/runtime/models/dits/minimax_h3.py": "51ed02981c04e53ff72302a9d1dca03f9957e28032c96fca7bd92987abe1ac64", + "python/sglang/multimodal_gen/runtime/models/dits/mova_audio_dit.py": "777055d2c2f37b247a30c086db7e6baab066f106b38c2cc7ab4c431835048197", + "python/sglang/multimodal_gen/runtime/models/dits/mova_video_dit.py": "c579c625265bf38cecba49f2aea2a11a924bce2d741a4059cf96a48ae2206632", + "python/sglang/multimodal_gen/runtime/models/dits/qwen_image.py": "917b33ca0b65a60eb1d0e6a7fd25fdba9b37363b648ea1afe6987f922f7b2f6d", + "python/sglang/multimodal_gen/runtime/models/dits/sana.py": "65d8daddf53d76ae011070d3c03e52c934baa99ae89d7522e40be9ab29aac290", + "python/sglang/multimodal_gen/runtime/models/dits/sana_video.py": "53c0da351d964acb5cd9db5e9dc8318929c1ed0e05c49c565113b2c0694b1e0b", + "python/sglang/multimodal_gen/runtime/models/dits/sana_wm.py": "0fe643a28ea0c79a4b3304f6a8a5db9a6a61ee82b56a6897196f64b0d6dbc33d", + "python/sglang/multimodal_gen/runtime/models/dits/sana_wm_components.py": "ae1a2a84d01f9faa9fcb05a617fda7da096b441617906c3575f4fbcf42c15830", + "python/sglang/multimodal_gen/runtime/models/dits/sana_wm_refiner_transformer.py": "5e196be390a04c772dbed3b87a18dbc3064a5a5f4aa5ab6607a00463b859ac82", + "python/sglang/multimodal_gen/runtime/models/dits/stable_diffusion.py": "cb909dc609c8702988e3a15819df0ad2d442ca710d9db239c15bf87ec730fd68", + "python/sglang/multimodal_gen/runtime/models/dits/stablediffusion3.py": "5a4f9fdfddc5f2ba63459ac24208b5749e766220d9aefc2ba4ccbe7f2c2796e2", + "python/sglang/multimodal_gen/runtime/models/dits/wanvideo.py": "aefcde8becfd2d74903677bfbed25584b56ecf5de5e2a076134f38dcb6a667ef", + "python/sglang/multimodal_gen/runtime/models/dits/zimage.py": "d9edb95f3aa774f2c6a366e4748d0381a9df86d1dd7d462e865d073155feb519", + "python/sglang/multimodal_gen/runtime/models/encoders/base.py": "f51334e5f2bb3b7656895698681d6bb98afedbcdeb97e4ad1a9e0558a26408ab", + "python/sglang/multimodal_gen/runtime/models/encoders/clip.py": "1458c21535566211fafeaba75349cd79a50998935b63daf878c1867bd09d6e1f", + "python/sglang/multimodal_gen/runtime/models/encoders/gemma2.py": "dc1f2c13ef034da1548cdc388aabb1237bb5a4b7828457f8a5bf3a413fe4e4bc", + "python/sglang/multimodal_gen/runtime/models/encoders/gemma_3.py": "aa056089c52ce99ce8f295fe32075cbaa35ddc33809ffdedac30ca0041404ac0", + "python/sglang/multimodal_gen/runtime/models/encoders/hunyuan3d.py": "89a92d6a3069869bcd5b359250dd766e3a9604e6722c917d90d7652b2dfc47f4", + "python/sglang/multimodal_gen/runtime/models/encoders/ideogram.py": "c1cd89f67bcafed9e2ab898d23dced908d0ed29b9c10107d0a1468eb421caed3", + "python/sglang/multimodal_gen/runtime/models/encoders/llama.py": "8a7cc03778cdf5a2fd55a0be58dda4e25ddfd28aba07f4224ed0368a8d6cec85", + "python/sglang/multimodal_gen/runtime/models/encoders/minimax_h3_qwen3vl.py": "bfa90ff49574e0274603d8a4e276b8c1095914234faf212469702ae0d5485982", + "python/sglang/multimodal_gen/runtime/models/encoders/mistral_3.py": "1896da5c12f01c97debe8939eaf5bffc25a091203211969c5f3f20c350f76897", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen2_5vl.py": "7aed7402b44d4f9b966b39329a4bffd838bb3a6bebf876b51eb9e3101db50cb6", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen2_5vl_vision.py": "d6fbc38058dbebaf73023f38978dd94176ef800923b30af6b93140b912ed674f", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen3.py": "54e36f7b16ca68cfeeb93623501e2ded8126e429448698b8868b5b1b6c9ca55c", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen3vl.py": "6c2945e4afe9f44ebb054e99f66ac624610ce9d5e1d92f5f8a02abb4309408dd", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen3vl_vision.py": "98aa9d4663426875b03127b9356e80b75d3c4eb1ff30fbfd52cdb07a4ab4a320", + "python/sglang/multimodal_gen/runtime/models/encoders/t5.py": "c40c16f5a23af923ba4f2aeb64fb7ec5db22cf537045fb323598846ac1ed0663", + "python/sglang/multimodal_gen/runtime/models/encoders/vision.py": "6a7d468c627b9723bf96345ee0cbb71089bf1114125aabcfcee785394fc8e2f6", + "python/sglang/multimodal_gen/runtime/models/parameter.py": "f0b76b8dd38967cac143f09fceb77759c13327c554ecc3721b71b1f7daf8dbc9", + "python/sglang/multimodal_gen/runtime/models/registry.py": "1db4e7402886571d1d2af74c47ca5f1f5eeafd33959e1faf6915536c5e877a97", + "python/sglang/multimodal_gen/runtime/models/schedulers/base.py": "91d08fbcf1717486863cc97c41aa3fe5a97f6254d0802cf8830b54c1ed530f60", + "python/sglang/multimodal_gen/runtime/models/schedulers/flow_match_pair.py": "0521c03ccd1c3b7b8c5d8d48365dfbcff6a6e6f465bc362fd9d6eb904759529c", + "python/sglang/multimodal_gen/runtime/models/schedulers/hunyuan3d_scheduler.py": "d8324bc70fef5d52f98604bbedabb492169daf4c41af1f085e46edb4cb76e8fe", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_comfyui_passthrough.py": "77401a8fff0a32cd1d8381c5219b194bf2d759c07881260fc70af4e6395b77ba", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_dpm_solver_multistep.py": "b51713e95535d2742bcd0248ea6880ca754d37ebbea37214136e7d91ec3c7755", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_flow_match_euler_discrete.py": "21d11e8b896f3f49973abc58e0dcab0bb342e9704282efa14c7b296fc0cf414b", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_flow_unipc_multistep.py": "c5993235bfebe894389d4b266a7f1b76b67c2506f34c05ed86c39c9087104d00", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_helios.py": "01b67c8ccc4ef199bb719e03c2e061e7c9e8a7e296270486eb027ade3ebd1a79", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_minimax_h3_euler_ancestral.py": "fbdb7faf8c3b29d5768562d523ad8a87ed4644ea7f322824dae7f9e246a661f4", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_self_forcing_flow_match.py": "872b8b9aa374f21841494ceba95add3637269821a0918bb8a4a57eddb954a4a5", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_unipc_multistep.py": "0239fa71456f0c80de99c83e6647e636a87287f1a68ef5185b47f1abbcb34e21", + "python/sglang/multimodal_gen/runtime/models/upsampler/__init__.py": "0cc18dc2663e115ac8b0934233260bd590df8d891bd48678188ebf7bdc1ef0fc", + "python/sglang/multimodal_gen/runtime/models/upsampler/latent_upsampler.py": "8a5007c84f245bb1a0080c565ff2c63404265432538a9ef10bb8115f4820ea9d", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder.py": "68bcdac692075fe5ce2303589fedb01d11cbb5ec47951e182af3944a0055d676", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder_dc.py": "297f9a3feb07ba887c111c56a3d1898d987fcb3066fd98efdeac6df1ff7a1aaa", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder_kl_flux2.py": "de46376e143caf2e00558c9743d5210e6be134a984c93a6f033caa926df9b896", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder_kl_qwenimage.py": "1c61768b7218898b82a3a1921edbe82afe9455398bf8fad2ade196a57edffef4", + "python/sglang/multimodal_gen/runtime/models/vaes/common.py": "3226ddddbd99df8753739eea8d5f60a555a9c000c8108244f042f56a39b6f386", + "python/sglang/multimodal_gen/runtime/models/vaes/cosmos3_avae.py": "070f26818115908d537c16a02c069fced80168214ee74e7b5c71c3b879a23bc0", + "python/sglang/multimodal_gen/runtime/models/vaes/dac.py": "df0998731a1d40093a8e61d294ddcf45db21e5ca41310d9f09ef6ee955180827", + "python/sglang/multimodal_gen/runtime/models/vaes/fast_path_gate.py": "e6ab5ac51af6ed16a22cb6c8e700c56175fc628abf6b966ea5d6f1a29cf974a6", + "python/sglang/multimodal_gen/runtime/models/vaes/flux2_vae_cuda_opt.py": "0bcf90fa9b7eed89ebd546b2e000d720d7b7347e3f83e6c9ae52b5c2479c6823", + "python/sglang/multimodal_gen/runtime/models/vaes/hunyuan3d_vae.py": "9d9df7a0ade8810005380cf80c568f1de22de6ff934e955b2e9119b3c13e94cb", + "python/sglang/multimodal_gen/runtime/models/vaes/hunyuanvae.py": "4f0622e3eb8704cad079e840581eec94a3ca185b08a4cab021adc896994de69e", + "python/sglang/multimodal_gen/runtime/models/vaes/ltx_2_3_condition_encoder.py": "a14a1bc3a6a2e5ddb6daf9404f4927aa4c18555eff688a84407bd8c0b63a550b", + "python/sglang/multimodal_gen/runtime/models/vaes/ltx_2_audio.py": "b9df1d6f0500d35c726229694bef284518140b9fe87f4d9a83fdfdb97107ebb3", + "python/sglang/multimodal_gen/runtime/models/vaes/ltx_2_vae.py": "2b9919336dd8930bf827b3c2903a28ce2e5c8ae456a2c2f0493f1ec49c98012f", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3.py": "72b08543587f41a359242ff49b2b34bba6f69dc5595524bd7b823c1b3eaabc09", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/__init__.py": "89480a39dda098dc895d950f6b1c0607cc61b2ebdf42f6f7329e44aa587a751f", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/alias_free.py": "40d8899a8e345fac07b970b1d26844f9a94f59bf474931a3f5446e3f4a1f6a2a", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/audio_vae.py": "8bbac65410bea451e76c98705f565d884e8fe5008b5b4873a31fc466930d5969", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/bigvgan.py": "08be3944c69d68917f700e24425c59aa776dc14f422e69f0be58f7026cbd4af1", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/__init__.py": "e6796d027b97366ff48eeff25bfd04e31c4fd4a4f4b5f4ee4b740b9166a8068b", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/attention.py": "4a5fc609c226c50be275cde8d8301d3973a67e94f71896e43411c2d7f8780999", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/base_module.py": "50a9a75b936b40308189515076b1208fc1fc2c6b342082fb71ad0eb40a98fb0b", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/conv.py": "587259d276178f64b2f9002a6cd82e19f547e20deb54bc8e3fd7e2a4c5f030e4", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/klvae.py": "4e855a369668e951751484d63801f4ce74e35b664a63d5e6270261e4c2073e8d", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/norm.py": "efd4e3f61c9381489e2926947981c24c471f6a16e7c08156f6d01c7dc4221698", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/processor.py": "d1fbb4f3125c79e1564b21392d67e7101762a53121268ccb82d8092a878488d1", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/vae_cnn.py": "792ee2176878d0f8b64b42d7ec63a927509dddf6ad864771d43a744981de13eb", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/vae_vit.py": "7eea59b9f87559e0309f4708d52398c987294cef757e729ff825fa0ebe904977", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/vit_utils.py": "1709aa4cd8a3ce911f317f58ea326de9aa63ef733b5387b1a77864b3e24f7a6c", + "python/sglang/multimodal_gen/runtime/models/vaes/parallel/diffusers_spatial.py": "ab25a8a2eddb90f7a3b9c341169f7ed3edd8eb26dc14ad95430fe6585a05aa7a", + "python/sglang/multimodal_gen/runtime/models/vaes/wan_vae_cuda_opt.py": "e866f38ea36176e1b7bf6cce547ca2076f69606742f5cfad3ff05661538564a6", + "python/sglang/multimodal_gen/runtime/models/vaes/wanvae.py": "e7ea14d19146d4455c4a2f30e512c8cb9d81523f7ee8eed80de5c6f45e41b48e", + "python/sglang/multimodal_gen/runtime/models/vlas/__init__.py": "94a562aee42ecb588af893eee9528bb565336d3b5049142403eeabf1d2a8f068", + "python/sglang/multimodal_gen/runtime/models/vlas/pi05_core.py": "09f4a75d1ae50f60f60025a48dcf89841cc7c69846380cc2f2f48aacc67fec08", + "python/sglang/multimodal_gen/runtime/models/vlas/pi05_policy.py": "3be6ce3afe0d372fe6a39a576aa6988832a8c34eb5e50c2a8f124a8ed9a8d1fb", + "python/sglang/multimodal_gen/runtime/models/vocoder/ltx_2_vocoder.py": "443feb40733b76ea7d3c14acc6cc08e60ee6c8feaa7e9190d930d6adcb12e239", + "python/sglang/multimodal_gen/runtime/pipelines/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/pipelines/comfyui_flux_pipeline.py": "9beeb875241f9bf039adff48a877094d4311ebd8d98902a6b59b7dd79470cb06", + "python/sglang/multimodal_gen/runtime/pipelines/comfyui_qwen_image_pipeline.py": "ef7e2eb33a6c4b226dc0ee7a79176ef809e617e6e5e90ca8f1e85e9e9df74984", + "python/sglang/multimodal_gen/runtime/pipelines/comfyui_zimage_pipeline.py": "1bc6d205ebda69464fd0548a7f9d30b22cf8115a857a9b39520f53cfc024fb81", + "python/sglang/multimodal_gen/runtime/pipelines/cosmos3_pipeline.py": "a51e9b1060fdbcc8aa8938ccdc184485070284434ba048d554e25ce5aaf294c1", + "python/sglang/multimodal_gen/runtime/pipelines/diffusers_pipeline.py": "d227b82d195936f9efb550683ab2af59e44e453b51716c847d1012f8aaadc187", + "python/sglang/multimodal_gen/runtime/pipelines/ernie_image.py": "e4463bee580d472ae31077d8ffe2be3363bae4e924000eebf08a393dd011902d", + "python/sglang/multimodal_gen/runtime/pipelines/flux.py": "a548029fb75faa7a638b9bac33f1c7153c19a5385525762ae10a0cc50f1f6977", + "python/sglang/multimodal_gen/runtime/pipelines/flux_2.py": "51af080813cc0f667d874d9b255cb519c5fc66bde06138131948bfbc7ac534b1", + "python/sglang/multimodal_gen/runtime/pipelines/flux_2_klein.py": "03bab0d7a6572b29fb203f2aa41140a54f77fb3e3ff90489401cd5a90933fd58", + "python/sglang/multimodal_gen/runtime/pipelines/flux_2_nvfp4.py": "dd93b28b5dde6f54ede886801f15a02366d0fe63a3a320298322c84ee8e9055d", + "python/sglang/multimodal_gen/runtime/pipelines/glm_image.py": "a217b6a4dac5f5fd019dc29e1868ddc7a305458aa3e664cc8002b4613630aa7b", + "python/sglang/multimodal_gen/runtime/pipelines/helios_pipeline.py": "877431bbc32af7f505e9a66f294527da9f0c68747ab7679d6a1ef832cfae01d5", + "python/sglang/multimodal_gen/runtime/pipelines/hunyuan3d_pipeline.py": "904af91f67269d4dc42cd288d017a1df50946cad50575aa09b7f1c5261a3329d", + "python/sglang/multimodal_gen/runtime/pipelines/hunyuan_pipeline.py": "4c158534ccbe998b01cd8677c2853b4273a7db4a900b288752d2f8e519922dbd", + "python/sglang/multimodal_gen/runtime/pipelines/ideogram.py": "632a931e1f13a3f1a33797bfd035b070c30e5550b567f63d0101d7e6511c4ef9", + "python/sglang/multimodal_gen/runtime/pipelines/joy_echo_pipeline.py": "97af44fc188a60095195ef2534f11c03815176351fbf9df75d8328ac4b4ef8dc", + "python/sglang/multimodal_gen/runtime/pipelines/joy_image.py": "48f87dd0b95933c15c411df6bfaf99ddfe489c8e7ebdf7754f47d91f9a1ef2ec", + "python/sglang/multimodal_gen/runtime/pipelines/krea2.py": "96cd5d14224a3f46169679ffbeb2c2ec366519d64df6f99c63f8178f579fff12", + "python/sglang/multimodal_gen/runtime/pipelines/lingbot_video_moe.py": "1315c3d65ad0c2f76931ffbbc35b3d4ea02fabdb45be5dd7df63dbfafdd0db7c", + "python/sglang/multimodal_gen/runtime/pipelines/lingbot_world_causal_dmd_pipeline.py": "ddd7b330f42392d0e66882f222d0fe8787aa978fcdcca48caa137099bce716b3", + "python/sglang/multimodal_gen/runtime/pipelines/longcat_image.py": "a21cad85cbc1a589d7a6a2626444e07febdbf50d7c2ee39a3352f88c02791d63", + "python/sglang/multimodal_gen/runtime/pipelines/longlive2_pipeline.py": "545338044488b1525f3b2f75ec7bdcca819541cd42ee84d4d1efe7aababa6141", + "python/sglang/multimodal_gen/runtime/pipelines/ltx_2_pipeline.py": "be45a325b798ab1283861da8529cfcc863cccb5e66475f8d0c76a3a9fe5c1648", + "python/sglang/multimodal_gen/runtime/pipelines/minimax_h3_pipeline.py": "df9e4a8821d494ceb2ab9bcc9961267a0d5e904785d04e7408e2e35e837d7d5a", + "python/sglang/multimodal_gen/runtime/pipelines/mova_pipeline.py": "6e830f3f3f7f33a01f964f486bc94682c3f1579700ab6186613deec7da98de85", + "python/sglang/multimodal_gen/runtime/pipelines/pi05.py": "c63ccc8decb441e1787fc303302399c7c659b760aacd1b86cc9c90805161d044", + "python/sglang/multimodal_gen/runtime/pipelines/qwen_image.py": "3dc4c341833d90bddf3632f3d7efacbbbc56f678bc5abe57b46387659398a727", + "python/sglang/multimodal_gen/runtime/pipelines/sana.py": "75c789f401fc04e031185cf267a95d212f7c8ef7fad1c9baf6aebd317a58359e", + "python/sglang/multimodal_gen/runtime/pipelines/sana_video.py": "33bc780a46275475cc9fa63769cdfb8bccfd43f62acad3d08ecb8fb15a392ca6", + "python/sglang/multimodal_gen/runtime/pipelines/sana_wm_pipeline.py": "efd5775c75494a02226fe0f2120c648a3c71b8db991fedeb146fcd1dd827ef15", + "python/sglang/multimodal_gen/runtime/pipelines/sana_wm_realtime_pipeline.py": "a70910d5e11b17b850d4b706cdfff5663052de6e934e1cc12e099bb96a6525fa", + "python/sglang/multimodal_gen/runtime/pipelines/stable_diffusion_3.py": "73ad4dfe624e7622bebdda2c7900c08140ae0ae7dd01f8139f32d5a418794242", + "python/sglang/multimodal_gen/runtime/pipelines/wan_causal_dmd_pipeline.py": "b6dddbb4274c0d03bf5a29f0b93c0d4a3709c11d798e5c01266d5d395e7b1401", + "python/sglang/multimodal_gen/runtime/pipelines/wan_dmd_pipeline.py": "bcd1e9bf7bbc44fefc8836f67c4074f4eaad1de9d51b75943a3620d76b74227d", + "python/sglang/multimodal_gen/runtime/pipelines/wan_i2v_dmd_pipeline.py": "eff86c1eb694e6c6df56d5bb7ed18214f26525d66363a2d3fd93f9f8eaa00e5f", + "python/sglang/multimodal_gen/runtime/pipelines/wan_i2v_pipeline.py": "33eb376b983824ff5ea9a7200d47b9d6414c9b030e0efa734de0096ca5e02b83", + "python/sglang/multimodal_gen/runtime/pipelines/wan_pipeline.py": "8deec56d8aff8307e51a601caf52fec92e888aff38e4203940a8f9afd09eaed3", + "python/sglang/multimodal_gen/runtime/pipelines/zimage_pipeline.py": "9a916192482a2ead84aec5e26074c119986c49b5cf5fc04556824f5f07558fa7", + "python/sglang/multimodal_gen/runtime/pipelines_core/__init__.py": "7a915dad966148fac6ba6ef0e8a2ea7b8ab24364ad798651fde34e36105bb686", + "python/sglang/multimodal_gen/runtime/pipelines_core/composed_pipeline_base.py": "adeed9abfedb8aa03eabb6e7c17e1be4677d8fa8c3c07c97da0041c50545b15b", + "python/sglang/multimodal_gen/runtime/pipelines_core/diffusion_scheduler_utils.py": "4441eb11d7d9bd216abf4f092ae50e7e88c571600cd3f261ae638198d9d723dd", + "python/sglang/multimodal_gen/runtime/pipelines_core/executors/parallel_executor.py": "4e2279809f573c2bc97a7282aa19aeaaa904907d87c40965c440e64ec4a20c1f", + "python/sglang/multimodal_gen/runtime/pipelines_core/executors/pipeline_executor.py": "a611faa15b912209cdc31bf6e53e2f25c8921e161767d2a60108825b4de5c38b", + "python/sglang/multimodal_gen/runtime/pipelines_core/executors/sync_executor.py": "7b56b40f7a16f7668a046b7bf7cb5fede338865e9fab9e93ed6505ce4f365df5", + "python/sglang/multimodal_gen/runtime/pipelines_core/lora_format_adapter.py": "bd9cbafe43b461ce72f8c23916af0c225d8b93b6e8ed971ba7b9050da91b8b76", + "python/sglang/multimodal_gen/runtime/pipelines_core/lora_pipeline.py": "795b5e5643c5f409ac4d3c5ca9ecb949e0306624c9530a1889075e19ede4d9b6", + "python/sglang/multimodal_gen/runtime/pipelines_core/schedule_batch.py": "1f0316c81a5e78bcf4e517b9ebdf112781a0457795edb624acebcebff8104a01", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/__init__.py": "c625f68f3e66d4fb3c67cb61938e249c78d91ce8d0a0511d48f72d9ca275da0b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/base.py": "f241b98bdc302cd5166c865aab43578ab7bdb0192fedec9e3d72fa927b159c90", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/causal_denoising.py": "a9288d122f3570db0c1830479a11dcab45b81c54a3eef3af3ccabdb787bed7e5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/comfyui_latent_preparation.py": "2dda6124c913c7c136795f00f87291dbd2d26b1ff9d0a5aade1595c5dc1c1bc4", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/condition_encoding.py": "4e4ec28b2f34dbeb1b55a33bb03b271426882e2f45956af85553e67ecc71ab13", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/decoding.py": "366f19a971272faecd7593959252738255be7cd511844589622ccab1d8d56b7d", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/dedup.py": "74e5599aafc01f380a362135518a0738a818bf36f743beecc660065a6d4261db", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/denoising.py": "eddf4b7c56f8327dd32b3bae96f4c4bfc00a2a2c3130d51f8493457ea89af886", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/denoising_dmd.py": "2cabac8977c3cd85cb01e8115a06e289cbcdc50710c4a1b65b30905723ffa910", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/encoding.py": "c5b05e6fb51f89b9acc9bb8c3550b7a74d7d99160ea8159c9c19ee8d008defff", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/image_encoding.py": "0399e820f586e01b02ce7691c0e35787b70d8d945cf6f87688ff60254369bf1b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/input_validation.py": "98fbfba3712ab1c02693f45a8deb9be6deff5ac7fc69a55613e53cd271cc6ba5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/latent_preparation.py": "4a3e4e5969e6d5a94b3a7ab31e9d3ad41c115baa8578130a3c67c8f9f1fa8064", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/__init__.py": "ebd231430fdad47b9245706acb16104c53254e70509649f253b659be62f413d7", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/cosmos3.py": "9ca060ddc6dcf5a1b0c03d78bbcd05ac143b6ecd628d110b945a82dbe0e5542a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/cosmos3_action.py": "4cc1f9f7782b1c7e067f16abd42f30678a10c9e50ef3c74844733aaca22291d2", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/cosmos3_guardrails.py": "7f7287f0bae16ea441ca55f14973cffeeac9766f9721485cda2e937e34f94af5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ernie_image_pe.py": "97104d1be95cdcdda1f474eb9a02888fbd08779edb62ca62efc0c7725495dfdf", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/glm_image.py": "b9e09a44cadf9a21eda5e620db33a73d40fa3adde7a93351802d95ada27ec600", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/helios_decoding.py": "858260a1493175f56808a1de788da255469a4bd5db49ddc9366b172c7da4e448", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/helios_denoising.py": "e07ba169836ed182d502cb011e56543beba751f5baf40155dfc1211ee78b2f8c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/hunyuan3d/__init__.py": "f40587c9be218a7ccde841bc977de8d85c5e5b55c949a0d5e81c659488e67e13", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/hunyuan3d/paint.py": "bd40ee8797df95d2a58bf1cbd0108e7ef8f13222a9142b20f9c828d691d3c58f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/hunyuan3d/shape.py": "6a2104cc36081c94280333ec46052e4d0dc3b1237c3031ad3d3b67ba01448656", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ideogram.py": "df557487a415bbe227954a178c395c26fb99e102d72862d9d7dfa397b914ba9a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/__init__.py": "de8741eeb8db145fc04d02006b4a1cb2832f36187f7efb0612bb0b879a010347", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/denoising.py": "c634d859385927f4a4d02aeb88c03f53172202a290a71c76aa10c13d9b24b0cf", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/memory.py": "0fa134d57ed89a80b2495c682fbebf1a8a67fa527df9830bca0026f1251c1f4a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/setup.py": "7439f7996d73d6fd0760b27193676ff202de33ed632e73278ccc788d63a8f306", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/krea2.py": "b95b1aafeca065e81d7815f8e6ff37ab492ab49ba063c942d24a0535d5cd5ccb", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_video_moe/__init__.py": "f2a03b7a4cc32cc59d40d805052c29d18d090ef9c7d8d6fc5f58d74f4734c5a8", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_video_moe/text_encoding.py": "8110862fd7037db5bb7606fd403d4b557bd7772d09481bdf916b716a230c3153", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_world/__init__.py": "ee72d57db58de7d21d89553c80e262f3a3fe18a0dfad92085891838e191bd5ea", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_world/constants.py": "295fbcdd46ec9bfe7b8a2994c67ddcc66ad42a1441e9c0cab4f13dfdb059f326", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_world/lingbot_world_causal_denoising.py": "d1dfc2f4901d31e6678152ba7f18105f15846b861a2068757372d73c45c5845f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/longcat_image.py": "f49d8ebea3a51c5970870c6bc093bf95586ddfb8338d96104ba58178f9eb6795", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/longlive2.py": "33512ab40646e6e517c82e99e8516d6608b26fd637539dc4e33e869d52e088b7", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/__init__.py": "4948a3b70126453c1dd13d3e2bfb29a31db3c84fb2bac601430363f2dfd7726a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/decoding_av.py": "0977369c7cd77b1e3c1c5251899d1f077153c7a91e46130a960aad76094acb6c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/denoising.py": "82ac9294fda80ceb56f7586e39b14cf92a04505911a5c70904fa7006c3ac0a16", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/denoising_av.py": "cf7db0a4378df0b3baa733924ff6b1af21688d65ceb3210295604b5a704b1c69", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/duration.py": "cb606e0b84ee08bd076de6c9786edf7098e7e45bd0449d5ea56e31f7026cf54a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/latent_preparation_av.py": "22f195152cb797198c270715ae168272d07d21fdf81b722cd44d493c2c365057", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/text_connector.py": "f45e4246aff0bebc5755940d00523538fdf94d32dcf8af9cf7bf2444accfd7fc", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/upsampling.py": "33284244363812abb74dafd626c27d8f2e4a5cda692190355a353551a6f77204", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/__init__.py": "763487795767fdf28fed18a6cd8f020fbf0647b6f8ecbde8dbf8c518cc19bafe", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/canvas.py": "e3b8513260bbe1d1d15cf8835f0146d9e958f4a6950826c30df23ded8d22d892", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/condition_noise.py": "4e2a4046ec6b3899e474a3352ef73c480d57e104f242c1e06c4819b2d1a221e6", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/constants.py": "583e94f14e3de084046af5218ed6456d1122d5e6051062d1372b35657235cabf", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/denoise_loop.py": "af19fcd37935da6193dc1329410edbdfaef25ca763db316f40bbc46fb6a48ba5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/keyframe_encoding.py": "c8aeeffcb0045402ce11dd3eed156df9188729e6bfee92f6a49ee95d27e93bec", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/material_io.py": "d75427ecbcf227a61f140ae45eccc73e30d001be0e70e90b6d2ca76bc8b4868e", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/packed_sequence.py": "8428954a3998429ff565b6a06e0c678ce0dd1b35ccf0492b26dbbee512f80a99", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/packed_tokens.py": "5441c9c3eb183a7694902f093c0ec5c9ffcf4351b4f8c64011cc75a85aff29da", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/prequeue.py": "91652d61cf0a7c552ccf166cbfcb9877f6f2ef2186ff078dd0b4b9fa105db4c1", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/presentation.py": "7c8e4d4a22c0933be79196b1c6b446191d020b55ba7de87be2781e81fd838f00", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/reference_encoding.py": "d0c8ae24984618c3f8b1f5a0eafdb077777784c1b94437c1f5e90b3e1e13a3e9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/release_metadata.py": "006910e9437a7250a7c72c7e7e1029e0b6a5e1a4be1a471fdf6c8fc199f2885f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/request_validation.py": "6fb8c16f336b24d9bd5abb52a7a1b822885b53fcb8a6d6398262718b62a99433", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/resolved_plan.py": "03d85dfb8819f6c52e6cc1a779adf9b515618f4dc6c97705b517d93ae972fad9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/__init__.py": "e0e3946d1e14a6190032baf047f920efc9cdd428efcd350bf9b58ba7ad7677aa", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/audio_encoding.py": "d50ee17293a1ac07e253ad259cc728f023c77ef56aac45289d4be057247f373f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/decoding.py": "a1ea299b0430c54ff0c7b26a338c168cc7ee9996fe748b08a2f73579728a7507", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/denoising.py": "c812008e49e42b762c1cea6f72e1df89574e905ee4de737f606afa205a0e8fec", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/latent_preparation.py": "8eef36d7a41665b80550c75a93566dddabf0ea3f15c6f66c3ed41262c135b368", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/replica_broadcast.py": "8c249dd8a295e1d3c989ddbc745258632a9017432230b362f85a215b13c24593", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/text_encoding.py": "f299b2f26598a04d5e70d8f5f659b9c45cc89abdb136cb466559c14a7ba17db5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/timestep_preparation.py": "efc5ce8ef4f05af58c4e5079b8ec1232f8847c5aaec7dbe5299312e3ebbac3d8", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/visual_encoding.py": "a52754f8c1ccb6370ac12c1fe8e98b2f28f76145540dce72c9a1d0e27d9946d9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/task_profiles.py": "0313922cc2d5e2b5af76583aaa96a114ccedf582de3eebfbc05abd79a84aec0d", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/time_request.py": "c63ae32bfc7e3fde5cdc7a791ceb5a62d9e72f30c9d08b6af773571c126bce90", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/video_adapter.py": "637bb5c97fb12b1b347845df366f8d0239735dc43b1dbd998e0ace1018d2baee", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/mova.py": "79b1beb782edcfd1d72565f6924def1e676001b35b7dae41bf833c53d3e943ea", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/pi05_preprocess.py": "907722ab1b870f37380bef6ca018c9fb364143d3e6db3c9afe07de8d6dad5a9b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/qwen_image_layered.py": "4b50c4fe30b5c187f7820f5a7e71e30fa79bc6e2215a49fdb8eb24b4a4879c33", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/__init__.py": "d07dc00c83ef44d83f9b649b7efb4c750e23601a435fe5c5fc6b4ec4f6250016", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/base.py": "13757608aea15e1d4183d2be4b6f2c3341c0d336e0282624c3e4c6d7f3fef21f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/parity_probe.py": "5017dde841c6b3073983cc7877f1b55663ef20a8acd8acc274f2640c86d9917f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/realtime_chain.py": "54ce38eee977a8fac6c12fcf89bb0d5b0b09c884a13c5511d07f1162078ac2e3", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/realtime_stage.py": "c4664d770fb65caedf02e1bc8d8458f3f67f711e347b240b2c94e3be789423d3", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/refiner.py": "41ec01eb88b0607164f953a53f5ad7fc9ace96e5d2ebead573d9684cbd80cb8b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/self_forcing.py": "52dbfb8187e6bdf72565a27f05c6724e360067f101b30458e03e6a92aefd377c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/streaming.py": "7556d57853d3a8880b3c7becd0f0342316e7a7c8a15c8c6347df60d8f451424e", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/streaming_refiner.py": "eee37cc2b25e637be9b1a5b41f021c21d53058d9123ca26e451bcb84dc63aa39", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/wan_ti2v.py": "1ef1e949e4281b4d66270ff1b46c0494e833b1e3057284a17e7fb079f483a42c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/denoising.py": "96a4afbe87e09b25b47936edf0d7a4a7f7595095103d35d57ee2bf7b1eb016c2", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/flux.py": "51445836cc46bdd17057fdc785a746a7ad1e6c20998c05d873b5d195358d7e82", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/flux_2.py": "90666826b8268bf1c220547e526b39ad916e091ef3c005e71a248fae283931a8", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/ideogram.py": "199950972f3d0320035a6448e435280f4afc9f2247af1be5bda38ff2a2183e72", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/qwen_image.py": "674b0f88531a624c24465a111b5da1bc2e088c17535d75dd54b230ba0250232b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/spectral_ops.py": "decd473c34592ad614f49eaaec1948860b89a30e188c60f63773de408e795f06", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/upsample.py": "67f79e1d35cf767c7d0893bba92554d10b46e74c35aa0b3601f1831673b55be9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/wan.py": "01e20f8f4ad778a1cd63ca358830ec03c49438ec68d19fca398925b5d817c2e3", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/zimage.py": "02d7b39de22f513243b2ea38e691b12fba01ebe376dd893047eedcda15af99cb", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/__init__.py": "4e797ef67941ae4007d47b16fb2ae8690ebfa20e73c21a94cbcc6ec82c629b70", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/base.py": "5709aae23ec0677bf87f79de569fcc4a82cabdada048389084dbdf373e10a01d", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/input_validation.py": "4960abc43e241570e3b8821e5f1e1e7d02f5371cc099292a8b52d1627aeed676", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/latent_preparation.py": "b2e9913b190da21732267e61c7c2270818634e3c8efef99a17c20fabb11c338b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/text_encoding.py": "c255839e213e174b3de65397f3e74decabdbaff33a9a77310496617b16bcaf97", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/vae.py": "c3d377fdd3ca540ba132a0b0f37d8379c7a87892ce68cd0e04801763729cc4fa", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/text_encoding.py": "db0622740e6d6ffdfad700cbe9ac5aebd79b9b7d4fca2585bc80670fe9c7567a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/timestep_preparation.py": "1967429c4319b340f37598ba34602025d11b3bc331f1177d2d93d9a1b582b445", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/validators.py": "2c9cd061911c1bd701a2c10294ad081168a12d895f19cd0349c30936348812e2", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/vla.py": "e31a04dd06e3f5d5ff1f76d4c3f7b22e231033f92a41cc403c38dd7800b47d18", + "python/sglang/multimodal_gen/runtime/platforms/__init__.py": "5bb4932af140e12b2c3bb25df663b648d7dd31ca9caf0bc11ca1550549c6b65b", + "python/sglang/multimodal_gen/runtime/platforms/aiter.py": "7a49bc177acf80e4555090af7590dbed1e07cc34616b746ce9f1a92ed48e9509", + "python/sglang/multimodal_gen/runtime/platforms/cpu.py": "d8309690b0430ad0b2c24090dd98e2c9f8fec4e8621e06ffe6f4f291a9d37f6b", + "python/sglang/multimodal_gen/runtime/platforms/cuda.py": "75e193d697ed7c92eb56b57d255270b0e66cae1d07ed1beaeb34c2275502e2f4", + "python/sglang/multimodal_gen/runtime/platforms/interface.py": "c930fa459065ba6e0376f40fa79e901cab6fd88b1a9c614ecdf211ddb46aeb0c", + "python/sglang/multimodal_gen/runtime/platforms/mps.py": "104fe9a5c7cc645a56b0752d06107ef96053d856f19165872ef2f8ddf986dfd9", + "python/sglang/multimodal_gen/runtime/platforms/musa.py": "311867736d12a2577c791281290444c9dcaf1e0047eae804794e5802b94477b4", + "python/sglang/multimodal_gen/runtime/platforms/npu.py": "fdbbfc977a3136add00574f1859d9f2c3a43cf1cd6439f700c1ca0dc891f0172", + "python/sglang/multimodal_gen/runtime/platforms/rocm.py": "fe9cef509a49647a9f3cb8b65fa1d5cb2b86d4d7a0d6327989209899c592c06c", + "python/sglang/multimodal_gen/runtime/platforms/xpu.py": "ddc912e9062e44a2fe550a2d5d37b22534eaf2fe5fdf125206fb30d13b1a1371", + "python/sglang/multimodal_gen/runtime/post_training/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/multimodal_gen/runtime/post_training/gpu_worker_post_training_mixin.py": "e1aebeb72bef4c1ea5ba989952aa05e8bde09a5af3e0d5e9012433f783077e99", + "python/sglang/multimodal_gen/runtime/post_training/rl_dataclasses.py": "c4cfb89c970281779e76bd8121fac8492fe013b97166f62d0b88f851b4d9a066", + "python/sglang/multimodal_gen/runtime/post_training/rollout_denoising_mixin.py": "10305a821b163434eff8416bdccce16bddc5983526d8d300ebec6e4988d8447c", + "python/sglang/multimodal_gen/runtime/post_training/rollout_scheduler.py": "aa8f161c0fe0609be9e3de959e40df57c53b276575689f782a113fb1f317a4a2", + "python/sglang/multimodal_gen/runtime/post_training/scheduler_post_training_mixin.py": "095f61d7300510896007c403a88a6421e9c82aa2b294e6d48efc951afd3f3f2a", + "python/sglang/multimodal_gen/runtime/post_training/scheduler_rl_debug_mixin.py": "ceb15bac24baea41a718a4c538ba1a98f2d07d32a579ce4f70407386121df58a", + "python/sglang/multimodal_gen/runtime/post_training/scheduler_rl_mixin.py": "9ffa667d04fb58ed1f92339f8af3d13858ac942b026362e8dd94dfe420d0a6e3", + "python/sglang/multimodal_gen/runtime/post_training/sp_utils.py": "c24b4c63676632001857b19ba96aca5ede62c7e3e0c058c627dd472c12c51464", + "python/sglang/multimodal_gen/runtime/post_training/tensor_update_checker.py": "d848b68cf1a0998cdef6d5122bd6ede88bb191dc9625fd2b1d7584e2289549d3", + "python/sglang/multimodal_gen/runtime/post_training/weights_updater.py": "e186916d3a674d5fe63a37843617de10adf77728103062cbdb87c1832cebadfe", + "python/sglang/multimodal_gen/runtime/postprocess/__init__.py": "20ee20c21e544591bb88333128438e87c26a9a9abaa78f9547e131b67ac9d920", + "python/sglang/multimodal_gen/runtime/postprocess/realesrgan_upscaler.py": "a7181cdf15394b92ca5cde3b638fdb9430b21ffaab302e7b255556135b44e749", + "python/sglang/multimodal_gen/runtime/postprocess/rife_interpolator.py": "cdd703be5e99188602b2d7c00ff65e65742987b10fe9a42a50989a3f96c75242", + "python/sglang/multimodal_gen/runtime/realtime/__init__.py": "bb74a0238ddd0e18db8a608b28b0a95773af8976fa7411ec4cafed7c56233ab9", + "python/sglang/multimodal_gen/runtime/realtime/control_signals.py": "62ffad1ea2a6fdb326cb938972af040a77820f1a06d7e7f1a673a9e54a47a048", + "python/sglang/multimodal_gen/runtime/realtime/session.py": "c88d017f2bfcbf643ee8d58eaefb7ddfbdebcb91321567ef9489dde79141755a", + "python/sglang/multimodal_gen/runtime/realtime/states/__init__.py": "55e92a843e0c48d0cd42cb2ec58b5a276421d22e78b0b3bcad320cd0f6a678bf", + "python/sglang/multimodal_gen/runtime/realtime/states/camera_control.py": "07f930c494a88b588be5d19eeaa995e1e135b8994f2aadedd31591ee4b01951b", + "python/sglang/multimodal_gen/runtime/realtime/states/causal.py": "4cae131ae8996d587653a3f133e9635ab091b929704f797fd5fd31f9a3b0950f", + "python/sglang/multimodal_gen/runtime/scheduler_client.py": "840763aba125ad921e8110d3080a1b423dcbe7f15adc875997986d12ac96d18e", + "python/sglang/multimodal_gen/runtime/server_args/__init__.py": "ebdbb25077de0323534a461552a1fd35cd0bf37883f3af853ab31c6774cdc210", + "python/sglang/multimodal_gen/runtime/server_args/auto_tune.py": "e81265cf01d8118292a177bf142be1ad3ec0e6b101ba01e37e03983371c9507b", + "python/sglang/multimodal_gen/runtime/server_args/disagg.py": "42cd66c907417cb2f2ea6175fd730ac78110468877b41c72d8f01373b248d5f1", + "python/sglang/multimodal_gen/runtime/server_args/server_args.py": "7a9fb391c014b1f08c0a495d6f689f26ea554c61ca1680ee57d6e5f7b672f3e6", + "python/sglang/multimodal_gen/runtime/server_warmup.py": "01636abcac02acec198bcd97daf1610c5e93c90cdc8affb8034d10c6ce5b5f03", + "python/sglang/multimodal_gen/runtime/utils/camera_geometry.py": "1f83ee08bf6f55f3f59e07a6a0c01c4eef23f5f4a29bb307101c5727a086cd1c", + "python/sglang/multimodal_gen/runtime/utils/common.py": "3337dfa95b8821723c1d642b3f5dc4f00e24c19b7e739665a71705b6423894ff", + "python/sglang/multimodal_gen/runtime/utils/component_load.py": "b99183a600bd3fa8e9b9ce2dd569b8cf4b3f0e4aeb4a594cd562e4001ccbac9a", + "python/sglang/multimodal_gen/runtime/utils/condition_expansion.py": "577778dcf46e171f944747e7e583b67b3f413a4a09a0cebd9adf9610873bd1ee", + "python/sglang/multimodal_gen/runtime/utils/distributed.py": "22de4ef9e9c8beb9f18f3e938956d67bbf98f0ea75682712388a59a270f4cb85", + "python/sglang/multimodal_gen/runtime/utils/hf_diffusers_utils.py": "827f328740f0f6ea0b0760412ee615cc8aa9a51a9eb2eda509fee859327a0a1c", + "python/sglang/multimodal_gen/runtime/utils/image_io.py": "fdf1f4c36faee71bdda18a90b9eb7877d321fd382c4034a1e4e048b6af5adeb0", + "python/sglang/multimodal_gen/runtime/utils/logging_utils.py": "9b10037166b203ecaa859710481a5e1d6c1993ecdd3001d6804df0ff69c62385", + "python/sglang/multimodal_gen/runtime/utils/mesh3d_utils.py": "dcb94dac457c7e58782915115e5eaf4a012370363e8566d89ad29eebdbe82ba7", + "python/sglang/multimodal_gen/runtime/utils/model_overlay.py": "dc80fe7529e39587e5b3cbb9d76d4c6f74d0d8dc6f1f72e0c3e69926115540d7", + "python/sglang/multimodal_gen/runtime/utils/nvtx_pytorch_hooks.py": "0fd3943870f48e1b342c74c43d54713b89d0bc51b1c19c1c2777dbf9929f9cea", + "python/sglang/multimodal_gen/runtime/utils/perf_logger.py": "d5de095f14cfec2258d3f72b18f5754a1d0ec567736a6407ee14f76ad2dbe522", + "python/sglang/multimodal_gen/runtime/utils/precision.py": "2941476e01609abb128c4cd0fa1a7c554f575ba69ad16b558903c5cc8a3edb53", + "python/sglang/multimodal_gen/runtime/utils/precision_types.py": "c6ebacdf38bc674a57a95b31f4fd0bf7ef1025a2432a83030573383c27f5e6de", + "python/sglang/multimodal_gen/runtime/utils/profiler.py": "fb9935d1d4e22f2b4329dd247909c3a46c1aefa35a88f5645bcdc2fd708ba6d9", + "python/sglang/multimodal_gen/runtime/utils/quantization_utils.py": "d12d7cda40415371c406516ef911ed5e670b993cab25fdad30ec4827f5dc6246", + "python/sglang/multimodal_gen/runtime/utils/realtime_video.py": "dd337946b5039d47b896b2d665e0137dc703d89db4d7abe9ab3e50d714f90acd", + "python/sglang/multimodal_gen/runtime/utils/request_logger.py": "ece900b3123e8e6340a62bc7d10afc0cd35b8a62cd3315b421cee8ad48aabfbf", + "python/sglang/multimodal_gen/runtime/utils/torch_compile.py": "67f01e9dfec936624df2fe77232ce9af57fec1618f7b02c835a244266aebdfad", + "python/sglang/multimodal_gen/runtime/utils/trace_wrapper.py": "7811b8bc666cce8f1847c2cc4a009a3d4671eb34642fb61ea2cbb210acd2406c", + "python/sglang/multimodal_gen/runtime/utils/vision.py": "c731c2f579c3be880c4810e60883c3a0048bae6583dc05bd8e3318baa9b67e47", + "python/sglang/multimodal_gen/runtime/utils/weight_attrs.py": "a803a937c1bb2dddcb675213b7a75baad0d988ad79c62d31b35db3430463fb47", + "python/sglang/multimodal_gen/runtime/vla/__init__.py": "72611bc6b62a2a01eb7f593b973d90affc93ffb78885d3a23b36a6b2563737fd", + "python/sglang/multimodal_gen/runtime/vla/cuda_graph.py": "c9b6d3d07727dc53914b80f7311bee449cde52ff2748280d420702f361c2ecc9", + "python/sglang/multimodal_gen/runtime/vla/observation.py": "f05173db6fa20ae11929b32fbd4f895a8f94b1173d412098381f0d75ed46ed92", + "python/sglang/multimodal_gen/runtime/vla/parallel.py": "1bc23d893e8c9cb9887a4d8822dc45add7589fbb80324cbf72d6be4166891221", + "python/sglang/multimodal_gen/runtime/vla/prefix_cache.py": "40ace0b366e9673b6414695765b3f2aded8f2944779275ed73d9439cc5a5ccb1", + "python/sglang/multimodal_gen/runtime/warmup_request_builder.py": "9f63342e9453603a56786a93dd6ea3ff5b2d06b9ecfe6a901c9c51f1dcf45491", + "python/sglang/multimodal_gen/test/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/test/partitioning.py": "127c20a8b3301d5825e29932c28eb74ef129ec20d9c16e77b3a13d574940fbdb", + "python/sglang/multimodal_gen/test/run_suite.py": "5785b26c1a621cb7a8ba7b506a98ff07a239293310bc4f45a531cbceb5f74fd2", + "python/sglang/multimodal_gen/test/runner/__init__.py": "17587a799b45c0a19d8a9d2c1bd563ab2a1ef0ff62b4a79cabfbc1c8c2f8545a", + "python/sglang/multimodal_gen/test/runner/pytest_runner.py": "522b5141b729b12260723da698dcf82b75a3bee88320e6e9edaa02002b173bad", + "python/sglang/multimodal_gen/test/scripts/gen_diffusion_ci_outputs.py": "3067dd3d119780a9d86ff6709459e4658ae0f3d53e0e7d5e6555e01d07db5783", + "python/sglang/multimodal_gen/test/scripts/gen_perf_baselines.py": "adef171719472280f161d53eb72a5d43277fd6128cec9346c9300a2900095099", + "python/sglang/multimodal_gen/test/server/ascend/perf_baselines_npu.json": "4437ceb952fe205a1da70bbe6ea309895e6b951b674bf89b1d78f961a6cab18e", + "python/sglang/multimodal_gen/test/server/ascend/test_server_1_npu.py": "adedacdaf2f2d26439a30b18165a5e84b6b273521384012a0a6524956be0356d", + "python/sglang/multimodal_gen/test/server/ascend/test_server_2_npu.py": "d17e7a94ac9b712cb330d6d70f76aec3d93c1eaee783e9f5fdd4c2fab1eceebd", + "python/sglang/multimodal_gen/test/server/ascend/testcase_configs_npu.py": "add9064c389abdb21b274932bc5aff35164d18f7be9518d6bd1f413549fad2dd", + "python/sglang/multimodal_gen/test/server/common/__init__.py": "a33a6e1266b4ec92e3a20d365cac1bd96612545a5f5aaa1cda1309b6f741fb53", + "python/sglang/multimodal_gen/test/server/common/case_fixtures.py": "16b5e8d20a1e74f6efc0513cd6347343baa59fd249a44ef29e4e09fbba68fda3", + "python/sglang/multimodal_gen/test/server/common/slack.py": "ec3beb52a4e8c51f221b471b0eccf9a21a3259ecb3b5b95768e152da6bedd473", + "python/sglang/multimodal_gen/test/server/configs/cache_dit_scm_config.yaml": "7be6aaa922d1256c7eec2ea866433fef59b83eab5cce616e392dff412b12fc5d", + "python/sglang/multimodal_gen/test/server/conftest.py": "c0e7af08db1f33060e06be7b1b83b2b5238c57805a54434d7907de4f238b7a5b", + "python/sglang/multimodal_gen/test/server/consistency_thresholds/5090.json": "2f8dbf71209a5697c55e3c43093652612d05c1d883dd2a6924bc1de029e07218", + "python/sglang/multimodal_gen/test/server/consistency_thresholds/b200.json": "c19f6c9403ce1b2e8ff22311d16aa1e50ae310cce3242ca80d66c22ee3b651c9", + "python/sglang/multimodal_gen/test/server/consistency_thresholds/h100.json": "b39b85a3987e8a611a9fff1d61ddd70ca8843bcc4a1c6fa9623c6ef2862163d5", + "python/sglang/multimodal_gen/test/server/gpu_cases.py": "e78fc306fad631050a8d1e5f6b311dab17e1ced9e53e52aa657a6ec19b28aa55", + "python/sglang/multimodal_gen/test/server/musa/perf_baselines_musa.json": "76bb570e6005c4c9602c1c9998ed405f10e97752ae73e803bc133a16dea14967", + "python/sglang/multimodal_gen/test/server/musa/run_suite.py": "17da70de107c4250d1a52294e9fb7599756a402f731e24cfa8e06b8f2d360792", + "python/sglang/multimodal_gen/test/server/musa/test_server_1_gpu_musa.py": "77a53681073e5807c153b8c8d743cfb7fdaa2075a6c34e5a122c5a77594ecc4d", + "python/sglang/multimodal_gen/test/server/musa/test_server_1_gpu_musa_nightly.py": "5ef291bfc18c02f1ad701a8b1265a1c4f75440eeaa95d2c19619fe4306ec5225", + "python/sglang/multimodal_gen/test/server/musa/test_server_2_gpu_musa.py": "ce2456d248bdcfe601529bf320965120721cfbaa15cfcee3d202c46565b4d3a3", + "python/sglang/multimodal_gen/test/server/musa/testcase_configs_musa.py": "b8a993d183b288d23f45dc30e084b31d20be88004bf4cec8ee712962cdc23f0d", + "python/sglang/multimodal_gen/test/server/perf_baselines/5090.json": "9260040f51700f6e43e6ec6ce39b366b3090427516a54db4b625a9d1cc393ba2", + "python/sglang/multimodal_gen/test/server/perf_baselines/b200.json": "89f04a7307863fd2aedbb4070b1d70fcb436af644347ed57180922c25ac20f29", + "python/sglang/multimodal_gen/test/server/perf_baselines/h100.json": "a41e2d3ae76e4188f62a5043bc6e8f27dad53fa5950f388a0d2f84398673e997", + "python/sglang/multimodal_gen/test/server/realtime_consistency.py": "248069269b7a98d4a1581afff21c2637ee5fac06666243746041beec8977ebf3", + "python/sglang/multimodal_gen/test/server/test_request_logger.py": "806c3ecaf732740503bccbbfecc21e17eb6e93400cc0010bafb1c3ba729eb5e8", + "python/sglang/multimodal_gen/test/server/test_server_1_gpu.py": "8ece23a8aa163fa347966610f694950f69cac3b82f90adff377aa09a7b13a836", + "python/sglang/multimodal_gen/test/server/test_server_1_gpu_5090.py": "880a6e5b8857285f28917a3e737f77e049df5720d94ab2f6c00051cbfcc61db1", + "python/sglang/multimodal_gen/test/server/test_server_2_gpu.py": "3c3c48d0a91b4a8f6f7ad0bfa694ce2c025386d46a71c3c3156d648cb8cfdd9b", + "python/sglang/multimodal_gen/test/server/test_server_4_gpu_h100.py": "677aef54687fd5c5f498f562784e362763d5d885c1ab2309959ef4fbca418e94", + "python/sglang/multimodal_gen/test/server/test_server_b200.py": "a2fc33120d704e64e89d5c5713704ca52dc9106e5f89e563b19d454119a46e64", + "python/sglang/multimodal_gen/test/server/test_server_common.py": "c3d4e392b135f9dfa290a20fd42fd955739246ad433516875f45d38436a85785", + "python/sglang/multimodal_gen/test/server/test_server_utils.py": "cdfcac431a5e37553332f55a8649b023e8824e827a037cbbb59a231edf0368a9", + "python/sglang/multimodal_gen/test/server/testcase_configs.py": "02629a142a0ba96de2b628121e0bdabb3120f03e475f37284452eb832f8733a4", + "python/sglang/multimodal_gen/test/single_test_file/__init__.py": "24a42a7936cb2adb6b925e7751516cdc351ee72b4b7b9cb009da2018f5f587a8", + "python/sglang/multimodal_gen/test/single_test_file/cli_generate_common.py": "3f55cc9522e6612b2928a8ad1d73c067ec6a91c895d2b58dde54d2ecf6977eb8", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/__init__.py": "1c95aa916035e3af308a2fabd8fc9227325f85cef2560279e48db633f3702f70", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/config.py": "068e239a444766c3a8fdf561d92c203796629d2087b23a3ee6f228cdfa2086ee", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/engine.py": "f1fc4fb903fd56b4e33465b6faa61380925e3a0260e4a6b709270efe8893c155", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/hooks.py": "b66b3c788f840ecdd70ace046b282bf5bd51d15f8840b1539d0cecc6300f473e", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/test_component_accuracy_1_gpu.py": "1649af1159df0f358137e4a6101867154076d8120a2ba4d1ce6158901bd0f97b", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/test_component_accuracy_2_gpu.py": "97c9f6209dd47bc547f9678ce0101794160f9392dbc97c2d7a05902d7faa41fa", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/testcase_configs.py": "db538500a798acfeecd27c3151a918dce33c8552cae17684a21d5217e65c3dfc", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/utils.py": "5c642f9dc49caa230728745a269a090241191bfc1c043dae54c3ad8fe0189926", + "python/sglang/multimodal_gen/test/single_test_file/test_ar_models.py": "a23638ce14d90e6986928cfcfc968af6eb2788dcb9b3195a995c01b1dc5e602b", + "python/sglang/multimodal_gen/test/single_test_file/test_diffusion_bcg_tp2_zimage_turbo.py": "a824db2c8d1c46e91f7109a7476424919ca09057fef12944ec0ac1cb08826e01", + "python/sglang/multimodal_gen/test/single_test_file/test_diffusion_bcg_zimage_turbo.py": "5b56b8c2e1a751c8405c267c4a40b3bbf39a84125e6b70f3527a0b91a800f899", + "python/sglang/multimodal_gen/test/single_test_file/test_disagg_server.py": "bfc41aef3576630bc0dc4d8cbc614b8dab337adc698d79ba0a060828c98ef694", + "python/sglang/multimodal_gen/test/single_test_file/test_dp_serving_2_gpu.py": "0485ac2be9f9b9538af9b4217b061e4dfd24d7fd87b28ab879ce20cf981e9018", + "python/sglang/multimodal_gen/test/single_test_file/test_generate_i2i.py": "ef65c19885923d141a3e62cef060ae2e5ea63ef31ec28db8d53f84535a3b4d34", + "python/sglang/multimodal_gen/test/single_test_file/test_generate_zimage_turbo_cli.py": "f0a66ddc1cae8b5451d6d4cc64afeeebe2ad745e0924c331d1f20cce4f4107af", + "python/sglang/multimodal_gen/test/single_test_file/test_ipc_a2a_2_gpu.py": "5676488aa36a01cb4465a94db240ea536439f484af282e26e9f2a0166c952f12", + "python/sglang/multimodal_gen/test/single_test_file/test_pi05_e2e.py": "6aee29b2a863dc63eb5e21b3a3050d3b36915b2f3106bb6557537a1046a40e1a", + "python/sglang/multimodal_gen/test/single_test_file/test_pynccl_a2a_capture_2_gpu.py": "00763779cdd7af3a94629b1da95a23a05371321cb88105d125ae40a00841f4ba", + "python/sglang/multimodal_gen/test/single_test_file/test_update_weights_from_disk.py": "b0e1468d6deb8a501f8fdce1ba625690eb1b2a0c476f157f015a2c12bebcff29", + "python/sglang/multimodal_gen/test/single_test_file/test_usp_replicated_parity_2_gpu.py": "7e0129fe1c081c55a471c4bebe17a737ba53362a2cbf90e2557fe2704fef43c2", + "python/sglang/multimodal_gen/test/test_utils.py": "17c3be6aaf3e392f6b6171cc976d06631b142a7483c588b840e2411c04c22b42", + "python/sglang/multimodal_gen/test/unit/conftest.py": "2ac87ea8d2fa630edbc3672ceda2e3837badb31dbe97e3d12d2ec8004a96fd8d", + "python/sglang/multimodal_gen/test/unit/manual/bench_patch_embed.py": "4525980fe6eeb24c3120724758bfb0f47020a56d92d4f7163095fd6f7c394596", + "python/sglang/multimodal_gen/test/unit/musa/layers/test_musa_rmsnorm.py": "79f8bc273acecea5107f4ae5bed7a949b6afcb3574c54356e25b780b75cc0044", + "python/sglang/multimodal_gen/test/unit/musa/layers/test_musa_silu_and_mul.py": "bd9dfab06e2d7279be68f4bab2722fc517e683f9c56c6fcd550b289a06e4ad45", + "python/sglang/multimodal_gen/test/unit/progressive_resolution/test_progressive.py": "a3501a5a78df433f78ce3e40e8c2885cc4ef16f85b64088ccf5abe55d003ca55", + "python/sglang/multimodal_gen/test/unit/realtime/test_causal_denoising.py": "1163d8ee78e4d6918aaf22f4b7d12132509073864d633c2152b1c336a499a5c5", + "python/sglang/multimodal_gen/test/unit/realtime/test_lingbot_causal_denoising.py": "a1e26a1d832b073f81c94b5fdb155997dfe3702bbc55461217559ecb8874b902", + "python/sglang/multimodal_gen/test/unit/realtime/test_output_materialization.py": "f31a490b9ae2fc0d908267455e1a889ac5de28f1c29b7ed94286ccf36ff67fb4", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_consistency_harness.py": "5dd4268658b93df53c0ff6f950da100ef6513b69abe15ede8b7740b5058373f6", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_control_signals.py": "ccd8038b430fe8f2773e9ed88d4dad3e1d309cf0c1da19faf8445be3c32245fd", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_output_transport.py": "72829e0c0d6931a520f5e7b0ab13740f9a2c058b26a2ca6d5add756cd8d993be", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_runtime.py": "5cb2f47955643016c3a046cf5afa64004a472ca57dfa9909b34c1e09a84fcc74", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_vae.py": "cc58da5a5bbbfbe9490a271d96a67be8a8200e28d888e396c569a3d78a69db12", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_webui.py": "fa8e336bf234a0da55a939b8aed22368efc3348b8fef0d664c17e389779cfa04", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_pipeline_config.py": "6f6c7f7d054872b91ff6343d0f6adf23998c97bf42dda8c33258fd6565d0b2d5", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_realtime_chain.py": "1d6de8f81a1b7a5116daa5fab95d32aade85fdc403ec7f72cfc2954e79d8835e", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_cached.py": "a98e85518d66ada93f21e09e957f7cceaf38629c08b52657733a58ddb44e7327", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_forward_long.py": "6f6fe0a962a18dbe1421a71f677bd5053c2e6a09e49211dc4deefae7bb16b421", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_realtime_path.py": "8d2df2a9789005b200ff9c447028867d81cb639ce0547b1bdf4034bd4a001c9c", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_stage.py": "90a1af040050667c96c5a6617a2f2223a7d390cd08946263795bc69bbbfcf1cf", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_vae.py": "5cf1d8883ebf87e1cbbcc2c2ff701676743eb51aef90e0ad05f1f54beff6e95c", + "python/sglang/multimodal_gen/test/unit/test_adapter_loader_offload_target.py": "578ebe6a29f8b283677e08ba928d52959a17e992e7402866d1b1ea1c5ce94a3c", + "python/sglang/multimodal_gen/test/unit/test_attention_backend_selector.py": "2513e4878d6db0ac403802fd5da6f2baa9e99a1d3293761e0c1212b09eb84c3f", + "python/sglang/multimodal_gen/test/unit/test_cache_dit_integration.py": "9fc9d62e39d14ec41463c90f475b3a718157f73f53f0aae6836c36bea1b8035c", + "python/sglang/multimodal_gen/test/unit/test_cfg_gating.py": "1e20054ec9ee3ec24cbe0a78c9c1932efb035659720a7a2e02a40c9a90e2b371", + "python/sglang/multimodal_gen/test/unit/test_cfg_parallel_warmup.py": "bb20413567e84e8a7a6154ff68d8987c2bab64f1043927e7ec34d79499c01cae", + "python/sglang/multimodal_gen/test/unit/test_cfg_policy.py": "7d24b78ba63d88bcd7bc36b3970f83aae0e8af83ec20c15176272cedbedf1437", + "python/sglang/multimodal_gen/test/unit/test_cli_generate_common.py": "1347c119117717ec3d49edd4f601ca2391b4f68544c0175648d8af68e3dd2bcc", + "python/sglang/multimodal_gen/test/unit/test_component_accuracy_inputs.py": "1acc11ecf4b244dde2577d3ac712af182849af7b7a131aef99139b7a6faae550", + "python/sglang/multimodal_gen/test/unit/test_component_accuracy_parallel_runtime.py": "3014e8a0499abc002aaa636a33893484aab81662ba7020fe53cec9ce9ab9182c", + "python/sglang/multimodal_gen/test/unit/test_component_loading_order.py": "8a7c6b214e32d4382e43cd8948ab97b21f3cd2d83741bed1f2e970afc9ff6202", + "python/sglang/multimodal_gen/test/unit/test_component_residency.py": "67fcb9b7640bc5ea5bf5c4ba08e0afefc296154a0fa2bf34d8a43776f570fe90", + "python/sglang/multimodal_gen/test/unit/test_consistency_metrics.py": "0be386f51a19b61c27e452fac37c60b25b4331f1bc451e52b490e52f09d0cd45", + "python/sglang/multimodal_gen/test/unit/test_cosmos3.py": "42e0b5a3799d999faf68e1c706ec79c854eddad99c85103d8c6129f44c141d91", + "python/sglang/multimodal_gen/test/unit/test_cuda_attention_backend.py": "f3f0ae523a8b4370330da57362e085f74174b8698925ecea52df02749ad96bd5", + "python/sglang/multimodal_gen/test/unit/test_decoding_stage_parallelism.py": "4fbdfbd05f5b3b7c6347b23881b72460c64567a2cb86f641077abf8225e38c7a", + "python/sglang/multimodal_gen/test/unit/test_diffusion_bcg_padding.py": "dd78c121383dcae2c165d3836322e83c4c6df763ce502767917a5d550424c0c9", + "python/sglang/multimodal_gen/test/unit/test_diffusion_bcg_tp_graph_capture.py": "19a636b99eb07712d9f97a59cd9a038837f8f5b2bf9556b50c6838bebcbf0691", + "python/sglang/multimodal_gen/test/unit/test_diffusion_generator_shutdown.py": "28cd08a46b5595daa5f1bdb39ad3317983d4896921c87ba906460614617d9810", + "python/sglang/multimodal_gen/test/unit/test_disagg_roles.py": "27102c5d53420519123ec89e85b5bd852f84ca57012d4035d12c93768c340022", + "python/sglang/multimodal_gen/test/unit/test_disagg_trace.py": "8c7142b84da8444091fec6db64f6da73fbf09503fdad472fb78b2d54d8740495", + "python/sglang/multimodal_gen/test/unit/test_dit_config_boundary.py": "ae7d407efa9399850a1435b98bcf1569e599d73cd6e3d42b89289c7cfbb0b4ee", + "python/sglang/multimodal_gen/test/unit/test_dp_routing.py": "076f2ee98e4e2690bfdd4fb85d0162500197a27819f859c4bbbbbe05174e5638", + "python/sglang/multimodal_gen/test/unit/test_encoder_world_folding.py": "cc5b26ea0db3e4041affbe497b8f4748eeb2b321cfbb2b36ea096ce8663e207a", + "python/sglang/multimodal_gen/test/unit/test_ernie_image_pipeline_config.py": "b352aaa77c5d10ab3b9f7a43c690f167372c770322c11edb2e9c74be4406d85f", + "python/sglang/multimodal_gen/test/unit/test_ernie_rope_geglu_fusion.py": "86d4931d5f99910610067c4d82dcd6813278f0482c817be23c237c8c13969854", + "python/sglang/multimodal_gen/test/unit/test_fp32_layernorm.py": "272897d7c62651e3f3a1edfc4b0f084b8464bdf182f459dafa665204167336fd", + "python/sglang/multimodal_gen/test/unit/test_fsdp_load.py": "b3afe1b8aa1e19d4365f5a73afc75bd054d361aacd640f708adae2f561442a53", + "python/sglang/multimodal_gen/test/unit/test_glm_image_ar.py": "a87d294fc4a4a3ab99fa2148d6f3f5bf7dd49855fa623fe29ffb354d3aad729a", + "python/sglang/multimodal_gen/test/unit/test_glm_image_multi_output.py": "2827c181edb5cb2b297160bb007212f530a047034a4c46d31e4914d19480505f", + "python/sglang/multimodal_gen/test/unit/test_gpu_worker_cpu_threads.py": "4f54f1054b81d715106ddb25090bd3b65665aa2680a63c5a22162d4d62dc02d0", + "python/sglang/multimodal_gen/test/unit/test_health_warmup_gate.py": "e327f6f299eb3470c03c0266f88ad958d7ecd54d3907ae60ce0dda9e1474089b", + "python/sglang/multimodal_gen/test/unit/test_helios_denoising_profiler.py": "fec0ad51a1d3af2ecef97242790cb5f1e0b49ecf9ee8c4c08852166a1aee663e", + "python/sglang/multimodal_gen/test/unit/test_hf_diffusers_utils.py": "a92df55b375b10163786a9d88495c0ec942c4433aed7ca6cea242e5156a635a9", + "python/sglang/multimodal_gen/test/unit/test_hunyuan3d_native_texture_models.py": "bf691073f61a320301720cc910c241851be0e7fc1b4e48129b7f7ce87a755a0f", + "python/sglang/multimodal_gen/test/unit/test_ideogram4.py": "13686014594d1ceef12f6668d43c3b0929dded27c918555d6bb66cac5f8a48f6", + "python/sglang/multimodal_gen/test/unit/test_ideogram_rope_swiglu_fusion.py": "1a580c0c600971e3f9af450f0d3cd13a5eef73230e983905fd2eedd92272cd52", + "python/sglang/multimodal_gen/test/unit/test_input_validation.py": "e2974f836d082e646826fb0cf2fa82d00e78c6a294330351676993e7e32553c9", + "python/sglang/multimodal_gen/test/unit/test_ipc_a2a_lifecycle.py": "6dd8d8bde7e0f3d75a2ad7db46e1a6c75a35ded5a3f3772fe51a9b297ddcc95b", + "python/sglang/multimodal_gen/test/unit/test_ipc_array.py": "48e111472631328dd37507c105ac937f877d201a9bf9e64fccf3e0068f49d7f6", + "python/sglang/multimodal_gen/test/unit/test_krea2_fp8.py": "6626ee3f00bf29c67b247be39c5b724f9d37a90bcb9b28a2ca723cd5cad1e5ae", + "python/sglang/multimodal_gen/test/unit/test_latent_upsampler_group_norm_silu.py": "cd3e5cca062518d6c03c9e9c43fc56259b30be20041cec5286b4d5a9846081f6", + "python/sglang/multimodal_gen/test/unit/test_launch_server_shutdown.py": "a1717d0b2473e40a95b15a3b2b755da9ac2d89667a581e0125073758de288a9c", + "python/sglang/multimodal_gen/test/unit/test_layernorm_cutedsl_dispatch.py": "44a9ba2a8805f68e4be49b83333a232a6665dc9b5ea193a5b4a481f615457ddb", + "python/sglang/multimodal_gen/test/unit/test_layerwise_offload.py": "a67b25e5d6503e03632d9ff4c26f2b1b6ad0b89202ca977c549bb23a2b2273f2", + "python/sglang/multimodal_gen/test/unit/test_lingbot_video_moe.py": "4f7aecf27ed3eb8c16e90ff18faf37ae57459d95d1fd4e19ae71073617625844", + "python/sglang/multimodal_gen/test/unit/test_logging_utils.py": "382884ea99823127654dc15792fcad74073a468651bad714560f87100b3b3e0b", + "python/sglang/multimodal_gen/test/unit/test_longlive2_pipeline_config.py": "553188dfc039669b9956a47daa5013b4c8c8fafd6d7f930fa3504d5de8cafb1b", + "python/sglang/multimodal_gen/test/unit/test_lora_commit_as_base.py": "363492884902832084a9bad92052ccaabe416bf4511929c3119108a6f6e676a6", + "python/sglang/multimodal_gen/test/unit/test_lora_format_adapter.py": "b2c1b2c0300b6b41f58029162768a29bc8fb019dfaa806bc86feca3b156f6740", + "python/sglang/multimodal_gen/test/unit/test_lora_inference_mode.py": "46d22617d42d50d2b6e12d765d27da90067bc33f22c042149cd560b0d400b8b9", + "python/sglang/multimodal_gen/test/unit/test_lora_pipeline.py": "3277b68c2c1437dc3f4898c9ea634418382e348937de6f9bbb07477203254148", + "python/sglang/multimodal_gen/test/unit/test_ltx2_5_config.py": "4228ae199153304dd967bc4d99ff33992bd604eb630ac96b4a05d879247f0caf", + "python/sglang/multimodal_gen/test/unit/test_ltx2_bcg_coords.py": "7a154db58df5e29e79c9121450f5e51c3c8a22fb479b15f6bc6add01b03bcedc", + "python/sglang/multimodal_gen/test/unit/test_ltx2_modulate_mount.py": "811f10ec75e86049beacda79e481fb5b44686e2fddfbd6fec1e391cb9040bbaa", + "python/sglang/multimodal_gen/test/unit/test_ltx2_vae_channels_last.py": "94bf38ce6c1ba11b34d212a84a1dae790a01f672ac21b21ae6f870728c6704c3", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_adaln_cache.py": "1257d2c83d72f22b28d23f6a73f176311185d5800ecb3c63b3c2691a3f8077ad", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_admission.py": "c1d7675c4cd36fae3f9c3218ddcff1dc11ddbc173dfe573ec80b32ebed3ae558", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_denoise_loop.py": "789fdba13794a31536874c77b271704f7920a2b7b3e597874ddf008496a4092c", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_dit_contract.py": "d1e0e39708c11ca25bdfdc6f55f15cc9a65118ee1464032b8fb7913b582caf67", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_encoder_device.py": "4279b1f78def8f649fe15ce37c44ebc289a777b86068bd5962e64bf3538104cb", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_media.py": "0e5b6fa5849891f82241e020b82f56f517f2ad3a7b1ae786b6910e6a13014b86", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_packed_sequence.py": "ac522c4b66cb122f1a20dc171a43c3163f859522c28dbb106f67c3dce4b7dd36", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_vae_parallel_modes.py": "c224d20e4fefc3fbc53985ee954a7ae96e0232f3e167dff006d2337e2f03fb0b", + "python/sglang/multimodal_gen/test/unit/test_ministral3_generation.py": "8a191b73b8913833c5ebc3bf055241c5b316de01a2c950e06093b5201698aad8", + "python/sglang/multimodal_gen/test/unit/test_multi_output_grouping.py": "5fa6a37a9cf253ea8293355ffd5d4c6b3bf62f2684f21e284cd5e7df3a38a4a7", + "python/sglang/multimodal_gen/test/unit/test_nvtx_pytorch_hooks.py": "570133cc614254a71e53c300c064e566b805f4146d1e0ba477c2ae3647d89266", + "python/sglang/multimodal_gen/test/unit/test_openai_image_api.py": "0b4fdafc55b8a37145df35bf3afe236aece05a2c3916bf1cf0787e3eceb53b20", + "python/sglang/multimodal_gen/test/unit/test_openai_utils.py": "1faa2497375fbafa513b06e3be292b40cd632a8573d34054eb531c575e1e8ed8", + "python/sglang/multimodal_gen/test/unit/test_output_saving.py": "44de3435b4a3b32b53aadc07e4c43e31f638268260d2499c8cd30b4c33fa02b2", + "python/sglang/multimodal_gen/test/unit/test_parallel_linear_weight_loading.py": "1078ab19b38d2a05d50d3cee3f7130b67de32183ef5e9e05d05adfbf8e17e069", + "python/sglang/multimodal_gen/test/unit/test_pi05_action_api.py": "ea32f5fbbdd93ef9c336e7f3dbf4e7d90829c0916fad49132a09336c27d88083", + "python/sglang/multimodal_gen/test/unit/test_pi05_prefix_cache.py": "63807e8798a896c1e9c0bf6a013dea53c06520df14f0347662602a39a814a420", + "python/sglang/multimodal_gen/test/unit/test_pi05_runtime_helpers.py": "2a37459d826e10db7f42346681f482f9bd3fb8b09819be7149159a6194f1f808", + "python/sglang/multimodal_gen/test/unit/test_pipeline_executor.py": "1982aab00c76005a0f620ce0f34960bbe0c27fa66053cca7d114d76a0c767e71", + "python/sglang/multimodal_gen/test/unit/test_pipeline_stage_profiling.py": "7c2b0f47030fb343c522ce209f746316c5c86d21d55546a362d747bc434dedfd", + "python/sglang/multimodal_gen/test/unit/test_platform_detection.py": "98cec8438a7fe11bd34c125ad74f483c460c0ea8a4fee364885292c528523f4b", + "python/sglang/multimodal_gen/test/unit/test_precision_consistency.py": "659d79f1395bd4713bce9041159387c996761d84d5464ff6fbc207caa8250f6b", + "python/sglang/multimodal_gen/test/unit/test_qvg_packed_kv.py": "fc70624be7a3bdd27265dd65db47de11428ff8ce42ce1fd79ce05fa1caf5a728", + "python/sglang/multimodal_gen/test/unit/test_qwen2_5vl_generation.py": "e422d7fecf3bf95c694321b879007107c4d0fccdf7b222356214d14a873252b5", + "python/sglang/multimodal_gen/test/unit/test_qwen3_encoder.py": "bc809d7348a5a85867f76503890d2205a2c10488e46e57fab5844086784bdbf9", + "python/sglang/multimodal_gen/test/unit/test_qwen3vl_vision.py": "3f70dfa66e018234987a65344e3ef4030425b602e784b41fcb3ad3cf9ffcce83", + "python/sglang/multimodal_gen/test/unit/test_qwen_image_layered.py": "5d12f06487dc2260186d53388a5b5dbddd20de6a9541943b8ae9c41c1d4f63f2", + "python/sglang/multimodal_gen/test/unit/test_regional_torch_compile.py": "fd9ae1eacaeb7ebe007b6be16fd0d74cb2450675e3bc7cc3249684d7d339903a", + "python/sglang/multimodal_gen/test/unit/test_request_manifest.py": "abb547707845f2c2b3c8259072be646f78e8ce1fc5cf1079568eddc89b02e2dd", + "python/sglang/multimodal_gen/test/unit/test_resolve_prompts.py": "86d83ef7c1a60b7b7595549fca6a6968ada97feac167669d8d5046f2077107b4", + "python/sglang/multimodal_gen/test/unit/test_ring_admission.py": "eb65b85e26d0bc109290a36b4e3d6f1e79296b8ef2883feb05f86467d8b9320d", + "python/sglang/multimodal_gen/test/unit/test_rollout_api.py": "230b4bfb1c36f1eade7eabbfc8f80eff5b527e192cdcc9384729de9b4556876a", + "python/sglang/multimodal_gen/test/unit/test_sampling_params.py": "572464bd87c88fb9e94bf2d5c60c95486245ed994b08286dd6e968a5932def60", + "python/sglang/multimodal_gen/test/unit/test_sana_video.py": "9b299bbb59f8bcab505731358b069f1f022f42b77959a062dfb8d10135b8af04", + "python/sglang/multimodal_gen/test/unit/test_scheduler_client.py": "0e0f89b7b436f92728ba6cfdec6aa04498076352533b512d714dbe54590ab325", + "python/sglang/multimodal_gen/test/unit/test_scheduler_rollout_unit.py": "45f0fea54e357584202c4ff576fd4d055db938eb7de2b8e7f769962885477c1e", + "python/sglang/multimodal_gen/test/unit/test_served_model_name.py": "640511a9bcbfcdb8fde83aa254840740e937af6fc46c0683ad99e0e99ace6bfd", + "python/sglang/multimodal_gen/test/unit/test_server_args.py": "7d43d677fac5c74597468e3a8c15943b99b5f8297463e37b1b9dfbf4271fcdbf", + "python/sglang/multimodal_gen/test/unit/test_server_warmup_progress.py": "34969836322f4605d1f130d70861e011f8632bbb3360f5fe2ea845ebd148547a", + "python/sglang/multimodal_gen/test/unit/test_sol_attn_backend.py": "60c62121cc51c11ce3e22e47826c041f794851537a65cb9e417ac332751220da", + "python/sglang/multimodal_gen/test/unit/test_sp_shard.py": "21260c6afd868f720beb75070e84c4a8ce9f8142d87d37d43e5ba8c165dd6205", + "python/sglang/multimodal_gen/test/unit/test_spectrum.py": "1ef56f3a12733299ecc05101a1be6fcbf17c4eb150c46eb75dd5499e588fc736", + "python/sglang/multimodal_gen/test/unit/test_storage.py": "432d4874dadf9e6efca474402935cac087536fed28f81c5bfce702c9a8b24fa4", + "python/sglang/multimodal_gen/test/unit/test_subblock_sparse_attention.py": "9639bcf0dd78d20092e8a6d75ef4d0adcfe69217a2531f8dff281c259516d407", + "python/sglang/multimodal_gen/test/unit/test_suite_partitioning.py": "d234973ac26244662524917c2d2a7d8086c0101f6c57d42d6f74dc0f4661c677", + "python/sglang/multimodal_gen/test/unit/test_text_encoder_loader.py": "a907c40435b3996ae022ddcf5160e3689227c538f9c4f1652db159714b061452", + "python/sglang/multimodal_gen/test/unit/test_text_encoding_cache.py": "f5911a1f91a27cc78f171deb1449d0ce7acf270b98550c6ba60db5543df74687", + "python/sglang/multimodal_gen/test/unit/test_transformer_quant.py": "dd81b12b3f01e27d03b4428bad4dad730e063537cdf20cf4a23d1927146cf37b", + "python/sglang/multimodal_gen/test/unit/test_turbo_wan_backend.py": "44ef6c562cdf022231b42c1fd74d3c67d05a01cec4cb3036d58ea9ebbd5f0c88", + "python/sglang/multimodal_gen/test/unit/test_usp_attention_kv_gather.py": "1922296471236f1d0a0c3a8332ff5c4424f406f8bad0877a55885e39b7b27204", + "python/sglang/multimodal_gen/test/unit/test_usp_attention_replicated_prefix.py": "325c9e94eccbb59fe573581ee7623a82e3da845c1f422be82691014cb0c8bed6", + "python/sglang/multimodal_gen/test/unit/test_usp_ipc_a2a_guard.py": "583a816b34ea8be2fd127dae3ee4c41e30c2474d2f60be99635e700847bfcfac", + "python/sglang/multimodal_gen/test/unit/test_usp_packed_qkv_a2a.py": "d2465417704b06b8cb1fbfea6da468d7ed1eddf424862986e264cd84ae5823ae", + "python/sglang/multimodal_gen/test/unit/test_usp_ring_replicated.py": "2728cd0df270cff9fbe030522a6ce313acf8e01ebbd2279fba50c7553dd6379d", + "python/sglang/multimodal_gen/test/unit/test_usp_ring_tail_pad.py": "f5c8e11db115f8c45b5a628372a59ec2ce4bc3e0a3ccb63a57d717007c0f8c43", + "python/sglang/multimodal_gen/test/unit/test_utils_parent_death.py": "cb6431dce85fbb346cb9fd87a56ead1ef4872732ee46f3392c3970c2ba028b3e", + "python/sglang/multimodal_gen/test/unit/test_vae_fast_path_gate.py": "539323a3a03f0fcecaae3c62005722d231e3646399dd32fa837e63f8e282634a", + "python/sglang/multimodal_gen/test/unit/test_vae_loader.py": "389d55dbcb259e58f9ee8cc613e7e42f1e7f1a8e37a6bff6ef5dd545076ec9be", + "python/sglang/multimodal_gen/test/unit/test_vae_spatial_parallel_decode.py": "0ab8f20f8c3c7736037b33295cf39f12c3762954e82102bb971d8069c6090702", + "python/sglang/multimodal_gen/test/unit/test_varlen_meta_host_build.py": "73e5a3cd4df4a2ebfd0ef6e287887274109120b2b17c2a7f63c3e139a45220d1", + "python/sglang/multimodal_gen/test/unit/test_video_api_profiling.py": "476abe2e34bc93da02e9b9645820339e75d4c33469272d01209725460b85a9ae", + "python/sglang/multimodal_gen/test/unit/test_video_job_lifecycle.py": "3abb207002925a08463a464f35e4836f2cca917d9ebcbc87f1babe60f3adce06", + "python/sglang/multimodal_gen/test/unit/test_video_sparse_attention.py": "8f77284fe1a7a77420e6bca8971d753eb1c9bb611e23725d2cc948e5ee6c5fa0", + "python/sglang/multimodal_gen/test/unit/test_wan_attention_backend.py": "f5b062daac1235fee733df482b165c719a6fda0c4097e4cd7f51be4abb851d51", + "python/sglang/multimodal_gen/test/unit/test_wan_pipeline_config.py": "8ee0a9d78dee527469bf9566a93990ececc3c97d8d25491eb40f31cb9a6a5419", + "python/sglang/multimodal_gen/test/unit/test_wan_temb_table_slices.py": "34262645c636b4e739371bb6244b3e9b3b8a7ffc03396c458e1989808f2a7b58", + "python/sglang/multimodal_gen/test/unit/test_wan_ti2v_helpers.py": "27d32547c702c450c8c1d4ccec8adb1fe80c24ec929012743acf96f5e071ed93", + "python/sglang/multimodal_gen/test/unit/test_weight_only_fp8_dequant_cache.py": "cef60ec2188bf588c91df47f95351ec909a019efa83631f5e01519b9e0c3f503", + "python/sglang/multimodal_gen/test/unit/test_weight_utils.py": "7a6ad15a3fa4d37eaaaf5e5a143c2c9a3383d5f610b9c4124deaa61c605b9140", + "python/sglang/multimodal_gen/test/unit/test_zimage_pipeline_config.py": "95fc4164eccf66b6434df6d80ff930bcf791d72f55b28b1a77127270324884ab", + "python/sglang/multimodal_gen/test/unit/test_zimage_qknorm_fusion.py": "c0ede506f9e2c1ed0585e8ebfa26508a8354ed91d031aa4a8a728d0605c1a64c", + "python/sglang/multimodal_gen/third_party/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/third_party/pynvml.py": "79ea49facf590fa182e0bf77c6855a845e4ab3141bcbfce6770ecc13a80da252", + "python/sglang/multimodal_gen/tools/build_minimax_h3_adaln_cache.py": "1116d5878e2255bade2b020a7c49618f691086cafd86f75870271b958de5773e", + "python/sglang/multimodal_gen/tools/build_modelopt_fp8_transformer.py": "c30c1acac5b2c6086498c81487bb8bf482cd1dd9b32a5b0829a553c1aac942b7", + "python/sglang/multimodal_gen/tools/build_modelopt_nvfp4_transformer.py": "1a43b877e0124b7f90242d7abcf6054eb9606387b9509bf3af83ce9116be506f", + "python/sglang/multimodal_gen/tools/compare_diffusion_trajectory_similarity.py": "0140a3da68ba10cbee834f0a96d9d163a6b519ed151048fe67c179302e18377d", + "python/sglang/multimodal_gen/tools/convert_hf_to_fp8.py": "911372836e00b7f34e9b757d68531c0420cfb5b77e13a3a2c850d5d0a1c153ea", + "python/sglang/multimodal_gen/tools/wan_repack.py": "a64a833bf6c573a1bb837c59089916d96ae617186c2cc656a8bbf2d0d3cb2d97", + "python/sglang/multimodal_gen/utils.py": "05642a8530529531bd17bc047014ea7e7d1b1843a5cad0546d7ea06e1e7f1bf6", + "python/sglang/profiler.py": "976f4b38ef11112ed5334a3c4920026a44ead0bfcc16a105c142bb061ef1bace", + "python/sglang/srt/arg_groups/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/arg_groups/arg_utils.py": "6abaa9be570c10b0d9e17ab1a324a07902aadffad5cb9c9b737ee885132b1eb0", + "python/sglang/srt/arg_groups/argparse_actions.py": "455a006dad5caa73ff089e705e5a217c1b56e78c405c4c284e8ea8a5cd55ab38", + "python/sglang/srt/arg_groups/deepseek_v4_hook.py": "b5c7090cba19eb8613a5a2b2440911c92e6e60040fafb6a68104f3540bbdd7b3", + "python/sglang/srt/arg_groups/hisparse_hook.py": "c23d69f90cbaba4459ebaaf5089a4a18b9e82fa749fdb5394bfd495068b7fc2b", + "python/sglang/srt/arg_groups/kimi_k3_hook.py": "28edb2663343894cc7bd7a5d3782ce5b871841f7203c61e1070a7312122cfd82", + "python/sglang/srt/arg_groups/overrides.py": "d3a1ccc96359d544b124ca9d666e161f2de4cdbfa649b8f0239bcdb6fe3f8692", + "python/sglang/srt/arg_groups/pd_disaggregation_hook.py": "5d4b5330a5375828179ed50f2708d68de90ecdde804832b252919b6a05a2a17e", + "python/sglang/srt/arg_groups/speculative_hook.py": "a97e3a7b427328559fa99e2078d2fec38d8380a6c8c17bfea898cb4eee2e8123", + "python/sglang/srt/batch_invariant_ops/__init__.py": "e277fb7cc6addb8f34f40a7692db170d4fe2e3474ec740fd6aa2b89415748ff0", + "python/sglang/srt/batch_invariant_ops/batch_invariant_ops.py": "9a9fdb89d84f8c392ae9a46f46c0a846b332e78f4ae77c24f240f8db55e6a6e4", + "python/sglang/srt/batch_overlap/operations.py": "4fa10e000917528813f53ec522a9bf61b90cfaa47f90436a2ec62c59821d271c", + "python/sglang/srt/batch_overlap/operations_strategy.py": "a9c4b5cbe65975058a68982f9d40a9a6afeff34daeff3bc162a91ec617dea47b", + "python/sglang/srt/batch_overlap/single_batch_overlap.py": "3c23bcfe109466ca63b46a925ac1ae1711c8d0703683673b3982c41b732f56df", + "python/sglang/srt/batch_overlap/two_batch_overlap.py": "ee395ac23f7722b9fc42ae05d4a64d23b2dc5d118ac90a3a8ffc48f3e8352a37", + "python/sglang/srt/checkpoint_engine/__init__.py": "15a5b6328c26066c089ec2e09e1f8278d2cb3f9b4f9155eda44ba3b4e6f25bd0", + "python/sglang/srt/checkpoint_engine/checkpoint_engine_worker.py": "67c1b669a4a36c56b0bbb1d7297014e55638c157b6ca5ec15b617a045f6dc187", + "python/sglang/srt/checkpoint_engine/update.py": "222774bdb2b632b4a9165c9609b445630053da8a549d478f9a4e6d60391901d4", + "python/sglang/srt/compilation/backend.py": "7c51043151a1050c0b870a4eb04a5ed477a2620c6c19b6f52766735968636fae", + "python/sglang/srt/compilation/compilation_config.py": "0eb0d6586ad6d28a194ffa084e5d4b326caa317cbd09d0d8dd809219d75aac41", + "python/sglang/srt/compilation/compilation_counter.py": "168ddfa11af24e4650290321ee9d1085412c57023a0976b592fa7101490dc1ec", + "python/sglang/srt/compilation/compile.py": "e80a9f13f23cfd073fc0a1d6075e8c8593dc26be9c7f2362611fa8937b5983f7", + "python/sglang/srt/compilation/compile_phase.py": "969248e4cd4a86b922bb2b09d429691b19c6a4333a86198a9388c445b88d5a7f", + "python/sglang/srt/compilation/compiler_interface.py": "8c66f1f363c9c76d7a4e74aa0985fee6506a24f3dc8678b5a62e3a9485f6c17e", + "python/sglang/srt/compilation/cuda_piecewise_backend.py": "1d7258fa1773fba3d0355a54f92a9f11cd866b37c618e9f45e0123462145b9b1", + "python/sglang/srt/compilation/fix_functionalization.py": "14c65bb9aac87a6046279ca22abdfbaead820dfe7f2f16e171588563e63a6be2", + "python/sglang/srt/compilation/fx_utils.py": "abf64f0e11f3d9243cd706c95d338559c3979c7d1e88a529949aefb905e29714", + "python/sglang/srt/compilation/inductor_pass.py": "8a54a6c65cd352c2b2fbd49107b10c8cb0587d90de3c45aa4e5f8cdc6c2fac74", + "python/sglang/srt/compilation/npu_piecewise_backend.py": "47bf1f91e134235867e954ee1c7a04ef25c36c5dc38ec4bae31c425a022f7497", + "python/sglang/srt/compilation/pass_manager.py": "8d36e29702bb5cecd1d666e9ef6e79ddbff11bdadbdc4a0dda1b7a16bba11744", + "python/sglang/srt/compilation/torch_compile_decoration.py": "86c7a5c495632bc42d22719f87f0ad0c8fadd52f189994243eec41d80b47ed28", + "python/sglang/srt/compilation/weak_ref_tensor.py": "3085290d6076f83aea4cbcccd221adbb55636367da1b9721be31946c68934cb4", + "python/sglang/srt/compilation/xpu_piecewise_backend.py": "ad31b9caceebb23503a5bdc093c4c14b278fcea505ba2688d94f049bf85428cf", + "python/sglang/srt/configs/__init__.py": "388f9df4bb3078eba0f03048b4a8bdc72325c1f2a1c7ac16720beb4012cdd1e5", + "python/sglang/srt/configs/afmoe.py": "7ab65afe8a3afb6934916907313ba8aadc3db3b733bbb5447399c69ad8e98cec", + "python/sglang/srt/configs/bailing_hybrid.py": "95fab0e74aadb9927a92c09d345beabf941228f2b8317110e4db2707873a3a9a", + "python/sglang/srt/configs/chatglm.py": "a1b9af316a8cad3ebcffc83103e3d1a748cae081ca3364f0ab73c5b2089526ee", + "python/sglang/srt/configs/cohere2_moe.py": "e62e7ae6f6a851ff94900b8f106600575e08768862f2dbe97c502aaf0222c36f", + "python/sglang/srt/configs/dbrx.py": "b5d848917010975cabd0cc6a166b031b51347b6a6e4534ca9ba513c803412da7", + "python/sglang/srt/configs/deepseek_ocr.py": "49d86bde31f77bdbadfa81b161fd32ee77834768819baa446dbc9da2c385426e", + "python/sglang/srt/configs/deepseek_v4.py": "9adf7030a4f6a39459934d28bdd3e7fb8def1f524bb91ce786212f4d404c326f", + "python/sglang/srt/configs/deepseekvl2.py": "d75a2c667ecfe3c591b5c2eb67aa20ab4d9386a9f504f85c98d29c97f334d059", + "python/sglang/srt/configs/device_config.py": "141b372d33a2f0aa3a7059f2f8bf0b1c30eda6032c69bad30f87b7c47a6af1cd", + "python/sglang/srt/configs/dots_ocr.py": "23093622e7984d04cec4fc3a4479b4c525fd850579f62de805a4dc8c6061c134", + "python/sglang/srt/configs/dots_vlm.py": "436a9a3fae6c6022869a0fdbbdce20e726fea5ab1d64dc78c679e5ceee847755", + "python/sglang/srt/configs/embedding_model_spec.py": "0fa197fbb5cec16b4bc6a0a02088fdd672a01ab77044ec68251fa74ba7177b32", + "python/sglang/srt/configs/exaone.py": "a25dd4679414f075e5edd34af38945f451138d4c51d2d0937ecee477f66f98e7", + "python/sglang/srt/configs/falcon_h1.py": "b3530c0499b64677ec0602d9d2c334421a6e9e2bb31265bbad55894f652e1622", + "python/sglang/srt/configs/granitemoehybrid.py": "1c5628293eeabcfa742dddbd9f29835dc698aecb0e9df9ab954c7af2af99cc0b", + "python/sglang/srt/configs/hybrid_arch.py": "48b4bcf47cffb2cd71b835588979edd3b80c6539a3328567f35f36f550a8b7ce", + "python/sglang/srt/configs/inkling.py": "cb0fd450818a2c0667bfd387423f7a46b97a976616d3fddfd933dd049ad62c6f", + "python/sglang/srt/configs/interns2_mobius.py": "a8dd86da6d06667293918acf21315f6d41500ac1f23ada810cfbc8a7c62dd41b", + "python/sglang/srt/configs/interns2preview.py": "988c6190727a5a3fae89184dacb8c0670e0a3a0eaf7cd6e05d6372ff8db34940", + "python/sglang/srt/configs/internvl.py": "1bd0d64b0414ae1bd48486ffe46dff08c9041ae93adcebc58caf6c2ffb925733", + "python/sglang/srt/configs/janus_pro.py": "3575df5c35a1ffc9d0a885d578b0f29343575311972a780a4e111107531e4e10", + "python/sglang/srt/configs/jet_nemotron.py": "832c015209fc1a2f5003781b730a0fca5782e942c98a0c13fbc1a4eba4586522", + "python/sglang/srt/configs/jet_vlm.py": "503e645fa2ae2940aa619addeb6c8f6ea8752d9bf8138674c9f2f75762efb3fb", + "python/sglang/srt/configs/kimi_k25.py": "30210e7ef5c728c69ee4ce6975903e82a22216ff896c63f2758468cc753e7af6", + "python/sglang/srt/configs/kimi_k3.py": "e4e9adeccb746c358880e1734a98073ceea58acc21353dde2a33107ae76896ce", + "python/sglang/srt/configs/kimi_linear.py": "25d7c7fa629626e49a07cb78daf63aab5f7f32456a652ece2813bc24c2491685", + "python/sglang/srt/configs/kimi_vl.py": "6049ff02df4d0ce0e816622c1c6f33dc8092b5c7f991412feae895b63a70e737", + "python/sglang/srt/configs/kimi_vl_moonvit.py": "871d91b7825215bbf2d8751378b8c1a607bcee6f0ce884c086ab2074d7ff25de", + "python/sglang/srt/configs/laguna.py": "f4c9139ec09cc1ea1fb92174453c003b8998d0a0a8717b34aa51653cd6d080f1", + "python/sglang/srt/configs/lfm2.py": "0763b5bb25964872d4c6833f401b2baab08425612b5b75fd7253d643789c936a", + "python/sglang/srt/configs/lfm2_moe.py": "a948fc589dea7a31d54102f1186fb31783b18afd7ec09e7dfa2a85567ffbf1d8", + "python/sglang/srt/configs/lfm2_vl.py": "9ca6f220a548849f04109a215bd8bfd17a98a35d58febea044046d5d90b5be7c", + "python/sglang/srt/configs/linear_attn_model_registry.py": "34478d80112b8ef8ebda86b8b85b5a7ce04359fa2baf013cf19432b7e7980606", + "python/sglang/srt/configs/load_config.py": "b404a18d3f0153f43dc24b6c28c6a8932ac76e19dd7b710efe755ec96e2b6117", + "python/sglang/srt/configs/locate_anything.py": "30223f8d0865ac98815ec9967fb6ed8abe3f5af47ddb547df86e84aa7f742042", + "python/sglang/srt/configs/longcat_flash.py": "b791b526e912b4c43660912ab5e8dc642575ea2416942c366e2bab2d041be8bd", + "python/sglang/srt/configs/mamba_utils.py": "820627a476130e36e8c9aeec2f1ded01d0c068369149e014cc0ef074f1e90808", + "python/sglang/srt/configs/minicpmv4_6.py": "4ff4f19844846a36feb303042ef257e6ebffdff0173f74fd3ec449e4336f226d", + "python/sglang/srt/configs/minimax_vl.py": "85528b038441724e90aea555d9e8d28575810b9f078889fe4c9fbb7ad4a8a915", + "python/sglang/srt/configs/model_config.py": "f3c7f7648bb80ba1ed07f839376779136d98f04cdd389f80112883720b741712", + "python/sglang/srt/configs/model_config_parser_registry.py": "4f11ddb4ecde882e267f96eaceb6e61efc4b38f72f9f977d91fb8d113c45c2e9", + "python/sglang/srt/configs/modelopt_config.py": "a6be10fc9e06d457fec32db805847359a374508df8aeb78679fecdb7a7745f73", + "python/sglang/srt/configs/muse_glimmer.py": "c814216a3470abb67abea26bf82bfc2fd2963980e43527a1188741650ad3607b", + "python/sglang/srt/configs/muse_glimmer_processing.py": "e822f8d7fb526e6ab8188ed47702044b24782da062327a08ef10581f9a8ac59e", + "python/sglang/srt/configs/nano_nemotron_vl.py": "b7ac0cb5eee99f39cf744d8ef98a0c98311bcb371d01e5c6d9638d3104c31a35", + "python/sglang/srt/configs/nemotron_h.py": "9b6c4a801032da1b5404fe5f04e5aee1c9d60252d0d650734d9eefe2eb304889", + "python/sglang/srt/configs/olmo3.py": "1d000a323ca4883ea4cd80af01885b7a874d56a82a34ea1e1bfb6f9bbe3c3313", + "python/sglang/srt/configs/parakeet.py": "09efe3620d488685e1a11c2236028642ceef182ff152aed3520e70f3f44d6141", + "python/sglang/srt/configs/points_v15_chat.py": "a9a9dded631cdcbf7ac20fb0cc0f58aa7ccccfb65433aaae02e4e18ced6b7ccf", + "python/sglang/srt/configs/qwen3_5.py": "72592dde421a945050b7f3e16ac0ffc9836dfadba16fcbccc473bf1ee9e9f1a8", + "python/sglang/srt/configs/qwen3_asr.py": "3ce79252169d974a777a3c7226d6a4186696143c0d1fd039f19249b10cd1d719", + "python/sglang/srt/configs/qwen3_next.py": "071ce509469c3d3320a7c7dcdb58702a53045fa9856d1c858501e2740b9c5df2", + "python/sglang/srt/configs/qwen3_omni.py": "843096226e123f12de5d1ba6dc62c3f0080787ab57da54bd7b094d0f638fbdcf", + "python/sglang/srt/configs/qwen3_vl.py": "3d5d16958d65d7de6d3268ccdc30b8f7508853f1ff0bba9606c0ef5be7b426fe", + "python/sglang/srt/configs/qwen4_exp.py": "ad2a5a26bb76b8df281b4c27271b827eaa9d0df3e6561a5e593f3f3095acaa0a", + "python/sglang/srt/configs/radio.py": "bc6557ca461e83c76b938949eda17d65cc8d0596a93e7ee54a94bd1d85660966", + "python/sglang/srt/configs/step3_vl.py": "fceb609f29b9ec356007f919ffff1cd7f62ce6049a940fcad19b958dc1b9d53d", + "python/sglang/srt/configs/step3p5.py": "3c816182ede55d65fd9200be63fb1cddb55c2eaf54fde830d5e0da1ac46eee91", + "python/sglang/srt/configs/step3p7.py": "5f2e2f3a538f38ea1b4d67ff4cd2ff72233b00519765df9c4a67dec332c1958c", + "python/sglang/srt/configs/unlimited_ocr.py": "12897bcb503f2f5e7ddfdff85323aab335d58734aac87cfcb4ae6828bc03bdad", + "python/sglang/srt/configs/update_config.py": "31a2609836edd20659c5876687e75bc4b42f1ed44c647ad2920005f722a406fe", + "python/sglang/srt/configs/utils.py": "25ffe3de229612d00dde2dbb96a0f7c945ea77f7f0ab6700dca16972dbd1f5dc", + "python/sglang/srt/configs/zaya.py": "16935923c2cf235182682fa6d78618e1f44513a7266ccbfbfa3737112ac0174a", + "python/sglang/srt/connector/__init__.py": "704cb5da6e56637690e5716243bf910e72f963c4dd83f7a3a253a5c18af05a8d", + "python/sglang/srt/connector/azure.py": "3242adcc7b713499b0e2bc0bc47aeca55c2bb2b53fb8f2ed767b69a7de5f8208", + "python/sglang/srt/connector/base_connector.py": "2c22ac4d7ff25877253ebccd341d5f2f054237cac80ca65a661a87439e01f4c5", + "python/sglang/srt/connector/redis.py": "2b77c94a6dab66c77447f2a42025778c858ab6bc315c4d6d624b569e8bcb6f3e", + "python/sglang/srt/connector/remote_instance.py": "42f3ad17a899487ffcda88dca0464cf5eb01420909a8baa20098e06ca84b8042", + "python/sglang/srt/connector/s3.py": "867e4ec3d63a22d4bc44c243c274d07b941a890ec728c822c20804f509d47b03", + "python/sglang/srt/connector/serde/__init__.py": "cee95ec9837e8eb0f288f8978d36d0280dbb9656f81fb1ee0d365c070acb9355", + "python/sglang/srt/connector/serde/safe_serde.py": "5d28dbf6646fd47a9e1ba262c3adf710e41896b708db7436d5496e62a3d96960", + "python/sglang/srt/connector/serde/serde.py": "9f9f48d8c5cb6bb582c8dffca4477c2feb1c264ee53219845fe18e508845d190", + "python/sglang/srt/connector/utils.py": "8ac4efc5abb3d7ff27a39316ea9f01c23d87f66424c1e6913bf452c003c0ed1f", + "python/sglang/srt/constants.py": "763bc7110ea28b1454768f722f10b58065618d3d160b2c5b9746fd95f6595008", + "python/sglang/srt/constrained/base_grammar_backend.py": "6bf74add13594e0f7bd26f069be39c734e0edc01cf480d4f601df7c76806434f", + "python/sglang/srt/constrained/grammar_manager.py": "dc4c94674191877a689c671713c739ab4693675f4fd26f68331a4751ecbc1903", + "python/sglang/srt/constrained/llguidance_backend.py": "34150debf617586cadbd3aab921cc151118c99d088e09c1beed71f4940cd2fd6", + "python/sglang/srt/constrained/outlines_backend.py": "ffef75513c79b201136730343165a9ee7444e159faa50d4c7f77bbbb95470dda", + "python/sglang/srt/constrained/outlines_jump_forward.py": "766dcf56cc31da813f25f02ffad3ddee2acc23de550aae1c653f8017e3a1c77b", + "python/sglang/srt/constrained/reasoner_grammar_backend.py": "6087173aaf0434665bdb57a4c8105407a44a7dc31fab4f9e66a19ed6666c1374", + "python/sglang/srt/constrained/torch_ops/token_filter_torch_ops.py": "019bb1e4b1c1f9d133f4fcd3849c81f58677e6b6fe21c697828c8e3e71753041", + "python/sglang/srt/constrained/utils.py": "6435eec8a8c66077cfa37661720c597bba64fd06f8fe29415765a36c34572837", + "python/sglang/srt/constrained/xgrammar_backend.py": "841651917a3a302c7a08ce1743aa284b3914e96b95c20cdfbf61df84125b21f2", + "python/sglang/srt/cuda_vmm_utils.py": "51b28fa463a48d89834efb7001fb10f86d7246e02d886479f9b51b2f80041562", + "python/sglang/srt/debug_utils/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/__init__.py": "ba899925697e772004b7006a273ba4b921c355042b6c7ea774b4ac582c8a3904", + "python/sglang/srt/debug_utils/comparator/__main__.py": "03c35164c976258d62a689631670a8708950e892904587c5f434406ae6a21238", + "python/sglang/srt/debug_utils/comparator/aligner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/axis_aligner.py": "5bd5cb33219bc892935ea5dec5f1c76dfec5bcb083f2027c55fa859a1e35e574", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/executor.py": "6357cc1ec00fd970650582d5b9e67354bab72be3b4b3e8e9e3f004b8af1405da", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/planner.py": "5a2ebf4b06c3d3b873ac557f0ceb88ea3607ea88c6395a0f9b741eb5dfed5bae", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/traced_types.py": "1b726e91f716ffe5619e5cb24c66ec51943ee222cd496dc3322c38614c66273d", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/types.py": "e7b05cacd428ef416cb1ec841742f9407980c23dec611ef2ed395ed9134d708c", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/executor.py": "d5358363b28da93650eed8ab53d08759064db776114cd062ec0656ef3e7acf43", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/planner.py": "706bdd7b9ad08ba66229438196cf430d7e981c9454b2f82414c66acd978cdfd2", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/types.py": "07b9f9ff535aa2a0784dcb3da9e73ab325c5a81cb896992866f782a86bc37737", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/concat_steps/__init__.py": "7fe61fc5a08193360663da64a88b72ef8fcc3f65b0158f6bc669a6cfda0c7a72", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/concat_steps/executor.py": "8dc2c35d646be7e17bb51f4d1489f881251923dbdfa3fb6e0b1dcf21ce0b925e", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/concat_steps/thd_seq_lens_loader.py": "83856e6b531064768ac1acc07f70ba9ff60187976795de390fedc57cf1674aff", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/entrypoint.py": "4b3bac51cf0d92517c72bc0a24f9bb96673bbb11a37c3a209ebbe9524b4d3e36", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/aux_loader.py": "16aba02f0575409def056b015df45d8721e4a2c95884e6ea373f634dad1a0909", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/aux_plugins.py": "928733bcb4f435bf3ac4cde31ef52ef92703f151806fb261bab70c75acde46a0", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/executor.py": "5385ad7e3ba6dbcab9ec4e7f11184b5e965e298925ad2e016ea035c941a35089", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/planner.py": "4b7a26f545265817541d0092beb8003da2ca358c0677134d6d231f2636e75dc8", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/seq_info_builder.py": "f7255824a0e700cb6fc189afa4c33f75d4aa841c4a5aae379bf6c2b89f89dac7", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/types.py": "52fc9981a45d10033b41df08b962032da6b0f8b18a999f5e4649ec6d0c166669", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/executor.py": "3d675494348bbd827361e6dd16fa8409b516991ca29cf8cfd141c070074ffd1f", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/parallel_info.py": "b329865a2dc4b496a6909a08b25f0d95aeb0c19dc963cce9fa3286f0ddc875b0", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/planner.py": "d9dd33cf4fa77c633d44b6ef0d86557d0dbf12f4c817088e36d7882282179f04", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/types.py": "4d496ecf4478a23a85bb10094f383c762aa7a84998ba36bda157077f4affb5ae", + "python/sglang/srt/debug_utils/comparator/bundle_comparator.py": "8fc478891082c0fb26910d4e1a7d04120e7f11cb95172279d6774be561398b4f", + "python/sglang/srt/debug_utils/comparator/bundle_matcher.py": "0d76a932b2d8c3fe645764aefcdbcc786680db752f3b33cfef43e1a7928a7ae5", + "python/sglang/srt/debug_utils/comparator/dims_spec/__init__.py": "56c9da9703564fa42dbcfb01543a5e7f5e2b1acc0df035667edd731b44575cf6", + "python/sglang/srt/debug_utils/comparator/dims_spec/comment_parser.py": "6483ebf41a165e05c68d3e0562328a15cd947e5ec43cab12e6d6acc65af9e57b", + "python/sglang/srt/debug_utils/comparator/dims_spec/dim_parser.py": "b0520f348fc496a2a30dbecc9fc17162691626ef43912bf293e7c088f3099408", + "python/sglang/srt/debug_utils/comparator/dims_spec/dims_parser.py": "be475e593f7047b5c20ccf1dabbd71016ad946990c18ed884b5fef7ae75986c9", + "python/sglang/srt/debug_utils/comparator/dims_spec/modifier_parser.py": "532b1c1d6322f0cf91fea7d0e3410a1110064107df4448cc13faccfc5c7bdffd", + "python/sglang/srt/debug_utils/comparator/dims_spec/tensor_naming.py": "529602f555d92b3742ae643c4da4d50e338b09cbef8de3f3429f72d530184b3f", + "python/sglang/srt/debug_utils/comparator/dims_spec/types.py": "382ae1758d94e30f30c8f479213300e37b483fef2b7021613548c8c504bb463d", + "python/sglang/srt/debug_utils/comparator/display.py": "77408d505b99430652a9e7d4011a116dc31848c205765a030291e9ca3e7ce916", + "python/sglang/srt/debug_utils/comparator/dp_utils.py": "84400e5e24870b45bb571df3ec368807f9ab1a8581e814e210ba6303c9b968c8", + "python/sglang/srt/debug_utils/comparator/entrypoint.py": "9ab81ec2b9dac39036af50ed9fccfe5e3b5b6470e707b76539364c574c845ba4", + "python/sglang/srt/debug_utils/comparator/log_sink.py": "1ac2c147568fc654f15c4873021fce2caff54f739dcde1821baf0286bf4aea97", + "python/sglang/srt/debug_utils/comparator/meta_overrider.py": "401f7d4046dac7ec8ce37dc5db0159de9c7a9e52608b9083eedac86852630a60", + "python/sglang/srt/debug_utils/comparator/output_formatter.py": "3467b9dd45ad860149e8b3fd28f5b6b75e10123641373d1bf06945727837b222", + "python/sglang/srt/debug_utils/comparator/output_types.py": "e44d68b341983720d47ad2837ddad20e107b6dedc95ed2aabba0e3c004b03927", + "python/sglang/srt/debug_utils/comparator/per_token_visualizer.py": "5cb7281c5a069ec59683ddc235bd25f734583d60ddb4ba72886ab44092389708", + "python/sglang/srt/debug_utils/comparator/preset.py": "6c3e37ff7740c70fb107568ee052183da9ba9f81524e843eef8d1e7da19a9eb6", + "python/sglang/srt/debug_utils/comparator/report_sink.py": "a99936f8c3f16d96fac1cfa21daab1855302ae66128c8671122cc238d9097911", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/__init__.py": "cd2a1d53637ade9e059e68f035b9cfe128cd818e04aca67c34d7a28232c5aeb9", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/comparator.py": "9145cf7268a7d62d229774838743c8903902d53834ad6ddf1c877430841dd986", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/formatter.py": "29103f1001727bc9c76f9da509cbab3bf061da9d6294c289ffc9a2b5d685bd3f", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/types.py": "75ab76c25508b582f692a0b7cb1f3671b38407251e22e0d2e5126f497310170c", + "python/sglang/srt/debug_utils/comparator/threshold_dsl.py": "12f8d64c54531eba8dff66c82b5c94f7cd5eaa19cdf3a490b6b43c035c9015f3", + "python/sglang/srt/debug_utils/comparator/utils.py": "f4fcca8b10e2800d5ceccca1ac7835f79c4a98cc6be3cd6a3945f80127c40681", + "python/sglang/srt/debug_utils/comparator/visualizer/__init__.py": "44943a29e99fe88b4581f4b5bf6297f70d0a2240964d6401f8d4664dc4eed897", + "python/sglang/srt/debug_utils/comparator/visualizer/figure.py": "4868cc81a725f1173204c74ac3fb9565c487a641a73b02d0f85b97c74a10712e", + "python/sglang/srt/debug_utils/comparator/visualizer/panels.py": "7d7f11aecd0b88149f95efb7cad0a28e4c2cf136d6256b7e7cae5a7d66a90a13", + "python/sglang/srt/debug_utils/comparator/visualizer/preprocessing.py": "8c95090499deeddfe00ba4c4374f2b9342b6b95825637c49a6e7c956d75442eb", + "python/sglang/srt/debug_utils/cuda_coredump.py": "3c988b25ce932682ed7107187597eebd0b9ac507d6fb8f164bbb3caa32808ff2", + "python/sglang/srt/debug_utils/dump_comparator.py": "85d69da52a5df9f1cd03f77da52675e34172378f3c6a6dd9595ecfe9ec97955a", + "python/sglang/srt/debug_utils/dump_loader.py": "1b362653debc9b64028cb470ba5b4154a4c9ced321ce2e28e430b0dae41b45be", + "python/sglang/srt/debug_utils/dumper.py": "57d9bafc9dea9d42e8abb7576c6010f070a065655f07ad66456b49113e261f86", + "python/sglang/srt/debug_utils/log_parser.py": "5dbfc6315d4d785bf3159749c6fced6008c75aea1aa8cf8a00b85c8817cbe409", + "python/sglang/srt/debug_utils/model_truncator.py": "23b64417aa8f9aa8c5c18e24cb813816da16af1a079fa81e5513ac14b1516a0e", + "python/sglang/srt/debug_utils/pr_fix_toggle.py": "4127ecac4471b48749d7396d77be1599169906d425b88c47642b1bdfad6a042a", + "python/sglang/srt/debug_utils/schedule_simulator/__init__.py": "be50bbf5e92de060a8cfecc831bcdb8609bd0f490db225f8802fa3d1a8eefb2a", + "python/sglang/srt/debug_utils/schedule_simulator/__main__.py": "6a22701f5fa52c27ffba46d8ed6f00c6588cee1189cac2b6eac09fd7d63d13e4", + "python/sglang/srt/debug_utils/schedule_simulator/data_source/__init__.py": "0053b87e19565964b92f4034281183dc8658cf1965aa6622cd5bfba9a5e5d22a", + "python/sglang/srt/debug_utils/schedule_simulator/data_source/data_loader.py": "8b0145833ddf087466c7bd52f43ca6570c265ccdffcfd9f58650761f37622a60", + "python/sglang/srt/debug_utils/schedule_simulator/data_source/data_synthesis.py": "2db55c12bdeb311fc836b26d697b5f20a323bd49bdc279cd56f33efe71b2d1b7", + "python/sglang/srt/debug_utils/schedule_simulator/entrypoint.py": "cc9efd82716dc6af909257b54bbf0b34496c797ebd1aa8c47f2bb86b2569f4d6", + "python/sglang/srt/debug_utils/schedule_simulator/gpu_state.py": "14b3a6961c92dbd7e12c7378e8fb3cb271f1d656d9691e2c5e2cee6fc8148f6f", + "python/sglang/srt/debug_utils/schedule_simulator/metrics.py": "6924f565b7a383a0d3ab535bf5b7db06b862adc7f08b24d7ed8f3c9e741c5ea1", + "python/sglang/srt/debug_utils/schedule_simulator/request.py": "4c131bdf9ce5ad0a1fee449ad75b8149d7d56fa917567cbe483ca000af43d6da", + "python/sglang/srt/debug_utils/schedule_simulator/routers/__init__.py": "7dd9829746d315b52eace6e42de74235f7bc4e14b78e8599ecd332eb3347f3dd", + "python/sglang/srt/debug_utils/schedule_simulator/routers/base.py": "130391a3c01b4a0b171029460c689071f883c3072d891c8adae4828f56322e1a", + "python/sglang/srt/debug_utils/schedule_simulator/routers/random_router.py": "b8b249cd5e5f39ab41b9e7f2e09f8ba4d65cdac86d61054e1aaae427c24a3651", + "python/sglang/srt/debug_utils/schedule_simulator/routers/round_robin_router.py": "01f001ae738dfcc4827efaec81812ffc0d5876519dfac2f7d6bc88b3c9760ef3", + "python/sglang/srt/debug_utils/schedule_simulator/routers/sticky_router.py": "641f0cea9d16f4f1ac3a8532acdc0a612fdcaee452caf723a9d1f6a72c065b07", + "python/sglang/srt/debug_utils/schedule_simulator/schedulers/__init__.py": "db56bc0e85b416a109523bf79df4d75dcc5867fa9e9876d4df1a275852a93b2f", + "python/sglang/srt/debug_utils/schedule_simulator/schedulers/base.py": "3d6045e82080d978fa3d4b5d25f856b98c9a0fff019b93982c99d50c88e8c97a", + "python/sglang/srt/debug_utils/schedule_simulator/schedulers/fifo_scheduler.py": "77b9cc73f537206969673037837310cd74c76633e28c9d8c25cf0aae59a287e9", + "python/sglang/srt/debug_utils/schedule_simulator/simulator.py": "8ca17b8189bc2607f859b64da6d48b3d04367b972b5f37197cbce5aa90b2f9f3", + "python/sglang/srt/debug_utils/source_patcher/__init__.py": "ee249b365a88fa36dd5d6ef0640f67514e96a2acb960b7931b471d931d3844b7", + "python/sglang/srt/debug_utils/source_patcher/code_patcher.py": "5e77ac348627d6e8356d5f31171daf83760a3d102717f1c7f827236f33d82d7d", + "python/sglang/srt/debug_utils/source_patcher/source_editor.py": "32d4c2da0ce8084b62a08e98111c22a7439bf5c0bf8508a5ec18a6d993b7425f", + "python/sglang/srt/debug_utils/source_patcher/types.py": "4bfdb4296d54f9a845a717502f41c292e7f0b6cc0c5c35971197e89d55a4b975", + "python/sglang/srt/debug_utils/tensor_dump_forward_hook.py": "bd5e33a56fec09580c4e97e09b8c64cf9201692ed08478d10fd73bac688a1c13", + "python/sglang/srt/debug_utils/text_comparator.py": "34b25d8d48a45bef9b5a719058878525eb32baf6765678b64b9ddf2040fe9bcb", + "python/sglang/srt/disaggregation/ascend/__init__.py": "fa5c6789c6ba7d962660da4ac2613cc84494a50e52c5fd83899a011f36e829cf", + "python/sglang/srt/disaggregation/ascend/conn.py": "fd2545df9bbf4d35d1e09217c5652781e1249f5c8ca25a700865b7dfb8c58e70", + "python/sglang/srt/disaggregation/ascend/transfer_engine.py": "f51f8e1476bbbfb219e41e75e768d5afc73d5ba84612ca9c31795480e347be4d", + "python/sglang/srt/disaggregation/base/__init__.py": "e15c14bf4696c709952f5d38f572bcd9a2d33719add1663944fcbd962fb0c959", + "python/sglang/srt/disaggregation/base/conn.py": "c3d84c421281ed0c5c4da6309a1efaafc5f66a802ce8a778c63c01903cfeec0b", + "python/sglang/srt/disaggregation/common/__init__.py": "ef297e1062cc54a46905468617fee5c00b30d89fe6aa9459574db7f151b10fda", + "python/sglang/srt/disaggregation/common/conn.py": "dc28d75e40b63163334b78e097b5eaa07ed768d596ce4c3903297cd20a3debf3", + "python/sglang/srt/disaggregation/common/staging_buffer.py": "85eef58786fc4132772b378a712600d1ae23834d4d8b1bfef553cb26e730d739", + "python/sglang/srt/disaggregation/common/staging_handler.py": "501a6476d345a1c795b2bc5cd56bfbb54e66e1696f882172602b74899982908e", + "python/sglang/srt/disaggregation/common/utils.py": "257f4d3df55e6eb3e1368186a410a6f73380f03444faab9af5f6966ceb986c5f", + "python/sglang/srt/disaggregation/decode.py": "28b8406736abc1601ccac6e1e73ee5827bc3eb7527c3e34ea824ba91a132bc52", + "python/sglang/srt/disaggregation/decode_hicache_mixin.py": "9c7775030f97c542024e48da95af001a392f52ee589658a38635ea0303f171b2", + "python/sglang/srt/disaggregation/decode_kvcache_offload_manager.py": "fb202374c211c3cad7a6ca39bbf00dee4877268e9e3c14dba9f506a3d190502f", + "python/sglang/srt/disaggregation/decode_schedule_batch_mixin.py": "c9bce6e98d54c415794eee6c75eeda96e168c64a8bc526c06e2f3960c01bb40a", + "python/sglang/srt/disaggregation/encode_grpc_server.py": "e48a34147806d9a66904b43fef34766c34355c213acef5356309bda8ef6ade4a", + "python/sglang/srt/disaggregation/encode_receiver.py": "54f11034ba24bc73ed50b7b5b44186feb371e7a005ac18885c2d0444f8d87ef1", + "python/sglang/srt/disaggregation/encode_server.py": "f990cc97fd1ba474828993f16a3455b25d21bc570ced5c39e3751221956c06f0", + "python/sglang/srt/disaggregation/fake/__init__.py": "9513a6c428234978b619d68e1eb1cdfb3d6c9ca4c075c3f56ddc2da0b48d612b", + "python/sglang/srt/disaggregation/fake/conn.py": "b0d6a7889317b68308bc258a56bf2b72b8feae7b4ad37a272f9372904d204375", + "python/sglang/srt/disaggregation/kv_events.py": "656a6340cbccb758720b3c63517c078f943f5a438a7129d12a545d0d292ff8fc", + "python/sglang/srt/disaggregation/mooncake/__init__.py": "d1382a9007502356329db1d8e9cd10212bd5a0e4a4fb44b0088ab9ae33d29a01", + "python/sglang/srt/disaggregation/mooncake/conn.py": "5bfac4cc28ee29368d4f73e317be2c2bcf637738f28f03aa5ee81017bb9d45db", + "python/sglang/srt/disaggregation/mooncake/utils.py": "485af0e04627b3c9924c140791365e334d8320d004808c8abf228dec7240f65c", + "python/sglang/srt/disaggregation/mori/__init__.py": "0420a96d3e9123efc762c340b0024959679de25e95c997b8e72e2eac030a0800", + "python/sglang/srt/disaggregation/mori/conn.py": "8f540fb0a31fa521764cc63da0e794a6707fa77684703ae2ea029ebdd2b4a385", + "python/sglang/srt/disaggregation/nixl/__init__.py": "a8e0d53c8196517297ab8cec44870c62802801e83a9c120df6f7503a554c00d1", + "python/sglang/srt/disaggregation/nixl/conn.py": "b682bc4f567d08734ea1c97de69c2356fa3045c84365503d8c138c0f7c7660d9", + "python/sglang/srt/disaggregation/prefill.py": "fb3bbb73be9c15900d06fa0a35ba4404d0942b86532e1456a61a00fc58a8b1d6", + "python/sglang/srt/disaggregation/utils.py": "b10628773d806f4b36afa25ad58f37390fe3d230392842e0f8c749e95bf84c4a", + "python/sglang/srt/distributed/__init__.py": "8c539ccadfb01403cc05401ff739196a535096dfb8aea993ea908a073d44e2aa", + "python/sglang/srt/distributed/bootstrap.py": "7516a5dfd3850a561fbccc272bf8762fbb293ce3f9101c662dd1d3cb28033ebb", + "python/sglang/srt/distributed/communication_op.py": "cd887fe137e5af7a7d52a8c6005abf82ce374717445259996306ca9b8a5eb0c4", + "python/sglang/srt/distributed/communication_tags.py": "b7d784c0f7d7f780b58097e9dbc81d6d99348c1241416fc55ebf0192edc00539", + "python/sglang/srt/distributed/device_communicators/all_reduce_utils.py": "df4c56d0dc1293c41caa3bc27779bc58eb2823f89aef70b21911a90a259864e4", + "python/sglang/srt/distributed/device_communicators/configs/__init__.py": "c6ee6b29d0caf265aff5dc0d03fc7cffbf8a0c855064c2b053cbb86ba0cad85b", + "python/sglang/srt/distributed/device_communicators/configs/custom_all_reduce_v2.py": "45d3ca8df482cb66363498e3d8fd80821adf2adb3f37f6ad083aa7263e655b7b", + "python/sglang/srt/distributed/device_communicators/cuda_wrapper.py": "a04c2ccd99745529e937479d5ebc6e1c71f6b24837572711e1c60af27f3e01ab", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce.py": "fe4ef6eee5003f0422accd49db00e2b4523e516645aeba2a2a63d545cfbb8de5", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce_ops.py": "f184bca25226c0f50faa293cff0e5014ffd38037631c614c86fee28827278ce3", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce_utils.py": "92445ac35010cbad04da7777d0b4f7d83f941845a1a527535de5337671030a38", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce_v2.py": "73c91972c29b06bade34438dcab21b21db70bee65722f264bf907118f223131a", + "python/sglang/srt/distributed/device_communicators/hpu_communicator.py": "9bb3dd5f928a696cd54daac574ac3e07ab62de2266adf2040721162bcdb90144", + "python/sglang/srt/distributed/device_communicators/mooncake_transfer_engine.py": "14b672668a09728ad09afbe826780657db40641d06a0e0c645c8a70fd5be3054", + "python/sglang/srt/distributed/device_communicators/npu_communicator.py": "379821f6244ef5eedc22fe732a214223a45a2a0f4d62e5c097f6609cd3889f46", + "python/sglang/srt/distributed/device_communicators/pymscclpp.py": "acf231612b176dd5c9775ab02d00b00ecb11cb521b238e6ee160164453c73c03", + "python/sglang/srt/distributed/device_communicators/pynccl.py": "54552a59dca74451e5553d8684a0ab112a7c8abf5b7b4c6ad524322f30a1e6ac", + "python/sglang/srt/distributed/device_communicators/pynccl_allocator.py": "f48992132d2c46396e201ec0d8aa8375d9e50b20aa7460f1421cb000e9cd99e1", + "python/sglang/srt/distributed/device_communicators/pynccl_wrapper.py": "e1d5df28ee32a5fe19238834107c6b2c9b2b33b28e8300d7fa337e28d4ecb4b5", + "python/sglang/srt/distributed/device_communicators/quick_all_reduce.py": "67e08aec7f57047e8d0158507cb1501b87809c1469b71740f630a9077d10d427", + "python/sglang/srt/distributed/device_communicators/shm_broadcast.py": "c7c43695929f1c89e42c7913b00b7c18a0edb9016604cb823d46ca4d9ed8554a", + "python/sglang/srt/distributed/device_communicators/torch_symm_mem.py": "e014a5da40b1ccba8595e583591afaf600d425043035f1f8f24067267ff9b87c", + "python/sglang/srt/distributed/device_communicators/triton_symm_mem_ag.py": "9dc59d39cd9cec94b29fcb430876a1f4ec1b6672812e1087cb230eddaf508184", + "python/sglang/srt/distributed/device_communicators/xpu_communicator.py": "10a5cca32a8927562ff45d3c8ea40f9089222c56055ae909134fb05d321ffba7", + "python/sglang/srt/distributed/naive_distributed.py": "197ec21e151bf6b210b9a20f5f84d89b4d52ed741d057bdda9a2683ddc45c802", + "python/sglang/srt/distributed/parallel_state.py": "2ac5574bb2eb79c7f2c5db31f1ad8f98d45f7cf97356019b2e1d5a80ad2c2997", + "python/sglang/srt/distributed/parallel_state_wrapper.py": "910ac5af01eb34f2c2a5abf4699f5a40f637989d727bb3beb657e68e7ed72e8b", + "python/sglang/srt/distributed/utils.py": "4a77a5f0b658e3917524c608ab6671e7802ca317593238c24c3572340632dc87", + "python/sglang/srt/dllm/algorithm/__init__.py": "d82c8387e0e9273285b1af703124ac82559103dade001a6d5ce539250091e63d", + "python/sglang/srt/dllm/algorithm/base.py": "897aa76dbb78e5788bd3498832b852153042bc7afa65aa81ee935a981144af66", + "python/sglang/srt/dllm/algorithm/joint_threshold.py": "6737b59f5c15413de1cac22d1097ee53dae854406dff61d58a6fb18d826c14e4", + "python/sglang/srt/dllm/algorithm/low_confidence.py": "a26bd3ef20ca6d930b775289f72faac1ed1f8e9e2ccdbdb850378eee9a43746b", + "python/sglang/srt/dllm/config.py": "ce954cf0983ebb9ff3503f00e2fc2dc423c21b0c530ae23dd56856038a6fd057", + "python/sglang/srt/dllm/mixin/req.py": "e226b29777fded0e6748416d93c08f34cb6513f0ed77a696f4422253b9f659fa", + "python/sglang/srt/dllm/mixin/scheduler.py": "6886f4c1420ad256d796bf7f3f5fd31c1a2fbada26ed8cf985a30edfad1e6d7d", + "python/sglang/srt/elastic_ep/elastic_ep.py": "b6c63a9ff106bc957ce75bc2152e7d847e5360d4dc88cc8d82faba48273578ea", + "python/sglang/srt/elastic_ep/expert_backup_client.py": "66efd9f51210cc2aaef5b68eec866a72d5c60e41223b4917b55aaae3fe2adde5", + "python/sglang/srt/elastic_ep/expert_backup_manager.py": "683e33cf46ef9ba7a87950c4b6dc04cc2cd6a78df6f7069c491a348e769be0f1", + "python/sglang/srt/entrypoints/EngineBase.py": "e9cdddf9e4a9e74663d445b69458ebd24f69a43f63e42979fe0923cf96140473", + "python/sglang/srt/entrypoints/anthropic/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/entrypoints/anthropic/protocol.py": "ca5ee76a2f4fa02fbeb4f2bd43cab2914a36137a0f0c622aeefed81cef16b2dd", + "python/sglang/srt/entrypoints/anthropic/serving.py": "4ed918fefb7fe9fe3906faea105ff8b67fac15d987aedfb39e33f305f94dee6f", + "python/sglang/srt/entrypoints/context.py": "cb408e9626344f07a572dbaed8ce88d51a979be07725f4adacff41e33478ddb3", + "python/sglang/srt/entrypoints/elastic_ep.py": "1f86efb98f7b364f56d41c784226bac6ff6d05809086bc8bcfed8025ae0d5590", + "python/sglang/srt/entrypoints/engine.py": "50aba0ce9763a3ff574ccc4be9ebaaa5d3e741045ed1d42a10f6a906c8b4b773", + "python/sglang/srt/entrypoints/engine_info_bootstrap_server.py": "42d58f530ec46f50f88e09d8e5c42d9b014e51ca023343fbb042758d854b2c6f", + "python/sglang/srt/entrypoints/engine_score_mixin.py": "904b711fa54795a19cd3ab0691205ba373ca9fdfee0a8c6b4a1e07f670253789", + "python/sglang/srt/entrypoints/grpc_bridge.py": "cb30520b01dd46e51c79c3812f54014b2f3376e96167e6916137396828a67d94", + "python/sglang/srt/entrypoints/grpc_server.py": "4b62f049035c16f717974ddb8145201f205bf06dddcffe4eebead7c7a7e71e28", + "python/sglang/srt/entrypoints/harmony_utils.py": "68b50da39f22701e1046b18f539faaee3ce26d8684ca1d213ab7abb7facc39c5", + "python/sglang/srt/entrypoints/http_request_decompression.py": "69442d129fe79f4449268c3804f0203af9a86dc616f997fbd729ab66f43c0e9c", + "python/sglang/srt/entrypoints/http_server.py": "5dbb62c787b120d70ca62241400705d34c4b7cb3e3100e1032c25989638e1f2a", + "python/sglang/srt/entrypoints/http_server_engine.py": "57b03db3ebff5207daafbbefa20c1138a8efaf00e6c8c0cbb843ccab448c5bbe", + "python/sglang/srt/entrypoints/ollama/README.md": "25ac552829f224e0fb0100d8c9391a7e028b89a975ff58170230fa9a5438f35b", + "python/sglang/srt/entrypoints/ollama/__init__.py": "786b829e3671aa72305b1948175314c7f631609b2ca3973bbe74790149eff0b4", + "python/sglang/srt/entrypoints/ollama/protocol.py": "08f1e67f0ea75fdba42cba0230bfdeb8fca46fff0b6226088d97ae70609e51c8", + "python/sglang/srt/entrypoints/ollama/serving.py": "b9b23646ef92565e02354b9c2599aab2acfccc57eabc3f53e0e25043230a95af", + "python/sglang/srt/entrypoints/ollama/smart_router.py": "6e83e521aa3ef6c98c74e82a1336594099531e106687e68b60f8ddf87d0bd968", + "python/sglang/srt/entrypoints/openai/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/entrypoints/openai/audio_chunking.py": "1786fe94d17c4e4ae07311b4d2f8a772e556832847dfc0f7c80a1297b48612a5", + "python/sglang/srt/entrypoints/openai/chat_encoding.py": "4cc93655ba72dabc45b40a23a107c76c2208cb7c5c612193f6832388fe2c624c", + "python/sglang/srt/entrypoints/openai/encoding_dsv32.py": "67ddda353a0026f4e3268255041e473934359ab7b8513e527821eea06ceb4e91", + "python/sglang/srt/entrypoints/openai/encoding_dsv4.py": "764dcfb28a57c3196975475747cb525ccacb4110556e3d9d35f038d6283ca527", + "python/sglang/srt/entrypoints/openai/protocol.py": "0d4ab08ef507764b1a477d12ff63ca6a70c48151b1464881c29928a87e392165", + "python/sglang/srt/entrypoints/openai/realtime/__init__.py": "6f1c7f2781cd8ad335bfb2cfe7cd29d040595b4ac86c972ca31d336e8438b597", + "python/sglang/srt/entrypoints/openai/realtime/handler.py": "d847da4ddba5c26fe01533aaf36a41778dc0fe28cb7f3f35fd6b5d27dd8ffd04", + "python/sglang/srt/entrypoints/openai/realtime/protocol.py": "6e1f9ea317f4c20bbe8ab8fcfa89aad849317115df619a179c0e8737a0071b1f", + "python/sglang/srt/entrypoints/openai/realtime/session.py": "3689c4b302059606ca144e782dd171f14a173881fb58365adc66021d8e17ce87", + "python/sglang/srt/entrypoints/openai/responses_compat.py": "72bfe1e5e45073d57f09dc90ba7b2ea6b87df932cfbcb67ed8116f25c5830037", + "python/sglang/srt/entrypoints/openai/serving_base.py": "3d0613b92abae51e8566a11ae80a2369a46422b49bd63c4cd6aa593d8a4bdbc2", + "python/sglang/srt/entrypoints/openai/serving_chat.py": "07ccd04de5f716277d2df873f66bdc4c03d13f7e89aad105c6dcba979ff47931", + "python/sglang/srt/entrypoints/openai/serving_classify.py": "b05079d8e3930397653a4ddcdef560250d6d7cf3a3af0cd749a9e7ed7c679005", + "python/sglang/srt/entrypoints/openai/serving_completions.py": "67f08075f21481b03e246327c7453f57ac001d0f3e78f5a9247caa553e1942e3", + "python/sglang/srt/entrypoints/openai/serving_embedding.py": "cf1b283df88e1286b7f803f2173bf89499c65e25c93462bc299b2c64539d77b8", + "python/sglang/srt/entrypoints/openai/serving_rerank.py": "5242cd42c8ccba74fbdf13e2c7eee63b5551e3d6bef09933aba213d690cb3329", + "python/sglang/srt/entrypoints/openai/serving_responses.py": "e65084c831bb3755bcef6a3288587582c065538857b58d09c8d2c2bc3ecf696c", + "python/sglang/srt/entrypoints/openai/serving_score.py": "203748c564cd979d03d54dee44140c63caef59490d1ca508ccb1aca3f69ffccd", + "python/sglang/srt/entrypoints/openai/serving_tokenize.py": "f1791dbe89245cf80f2ae3c3f052e944c0b602deaf45909a31d2e4aabfc95711", + "python/sglang/srt/entrypoints/openai/serving_transcription.py": "0f15eac62ea22d5cd531f19e9419a5db61f6a3109a25f0e6d87e84d215c4128d", + "python/sglang/srt/entrypoints/openai/sse_utils.py": "a04b5b4548067c8932466aa99f9758d7a87d547f6a1843f9d104bbbfe3ea2ac4", + "python/sglang/srt/entrypoints/openai/streaming_asr.py": "2cacd66732a167beb72521e614ff1b704c6e09471fc9795c2baaf2a139aa2a19", + "python/sglang/srt/entrypoints/openai/tool_server.py": "910ad836c563cdc4a27412f9fefae9febad1cb1f095b2d7108a8e993e14d846b", + "python/sglang/srt/entrypoints/openai/transcription_adapters/__init__.py": "058c8a2dde5657747cc591f0933d986fc7b99f6cbcec761aaa611ea692bd2ddf", + "python/sglang/srt/entrypoints/openai/transcription_adapters/base.py": "5a9cf360b2dd1f8991094b3653a571e12f688d3e04d5740df51516ad86f7554a", + "python/sglang/srt/entrypoints/openai/transcription_adapters/mimo_v2_asr.py": "41db26f4d8b2f2485b95e17c15c289c0c9d2c9d27d8279ada178da4721834c35", + "python/sglang/srt/entrypoints/openai/transcription_adapters/qwen3_asr.py": "6095a17613e443f06060ff2a4536fd5aa0894293e554435060d9e2c4c6445b47", + "python/sglang/srt/entrypoints/openai/transcription_adapters/whisper.py": "3569731f715a293275cc11aa8ccd237d1431c2102efab8843b289ce25040000f", + "python/sglang/srt/entrypoints/openai/usage_processor.py": "883c4c3ba95eb52fa57d5bf732d128063bac0b032f484776331220f61b7498a5", + "python/sglang/srt/entrypoints/openai/utils.py": "6057816db2a0851dada70399266f4c678b0a56c576e145d3dfd442e2b2300624", + "python/sglang/srt/entrypoints/request_headers.py": "dcf5b40b22cfb44e56041a329b80abcc6eb420de369d40bbefc0830d99ae5c55", + "python/sglang/srt/entrypoints/search/__init__.py": "f6993cc104837ed956524568f6bdce8cba587aec7acc5be478b2027834223ad9", + "python/sglang/srt/entrypoints/search/exa_client.py": "4ce2e0c3dabdf567757664030c1960617e3e94921ab514d106b7aac68ceb3deb", + "python/sglang/srt/entrypoints/sidecar.py": "3c1426b338f234b3806862ad298132fbaf8c7c2e2c6e1b7a361a70568d7c421b", + "python/sglang/srt/entrypoints/ssl_utils.py": "3f56a50ac45d549fcbbdd670d8a456593a66ed07203007dafe8c80fe86416342", + "python/sglang/srt/entrypoints/tool.py": "2867140746cfde17ba0e7b82da4bad255226fd97df376c40922cd4fb704575b3", + "python/sglang/srt/entrypoints/v1_loads.py": "528deeb3210d8ea9039b9e20fbeff28d326d8efe49d16c55ef662e8091c22bd2", + "python/sglang/srt/entrypoints/warmup.py": "39213d17c3435842a715ee46502f2a664ecf5bd3d1efa829ba721052938f2f06", + "python/sglang/srt/environ.py": "aa2cfbe7c61e27607ef443aaab7988e1fce58d995711e4b2f4f3ac9bb86583ca", + "python/sglang/srt/eplb/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/eplb/eplb_algorithms/__init__.py": "69f58f4c8c7e6eb9dc70dd124cc9b3564dbabfda6318d1b66d658822ccbdf323", + "python/sglang/srt/eplb/eplb_algorithms/deepseek.py": "7c42cd0cb0f03da5dc68d13d38833f2986625ac96813dae4853521341cc5219c", + "python/sglang/srt/eplb/eplb_algorithms/deepseek_vec.py": "573cb921aaee6b5560547ce304d65a555fefb752d8d412ed273ecf9b307bd359", + "python/sglang/srt/eplb/eplb_algorithms/elasticity_aware.py": "c7a69bf06fc209a5279050e623a25dcd0a9a3485f21135b5a02b02c783cfc4a6", + "python/sglang/srt/eplb/eplb_manager.py": "d0d4a739edc70f2f7972a361cbbd6b72f31233539bd56024e96f22ac5fa8b019", + "python/sglang/srt/eplb/eplb_simulator/__init__.py": "1c865a5eab2fb0e08c309f35752b3569f4866791ba3a239912d1e996dcb3ce36", + "python/sglang/srt/eplb/eplb_simulator/reader.py": "3a5b16aacb97a95418ecf7efbeb3febec9765b0d8a838bc3fcaf4196d33f407a", + "python/sglang/srt/eplb/expert_distribution.py": "74ae213a2295777d56208d5f593bc603782c7992bf91e60a3f1395ceb6d7442c", + "python/sglang/srt/eplb/expert_location.py": "879172c5669cd1a7950a37440698393b4419c073d826fe3bce39d5854bca2ed5", + "python/sglang/srt/eplb/expert_location_dispatch.py": "c7f6b68fb9c6262ab781de8c31514580f36046732ecf75868e3fdc0c6a9e11b0", + "python/sglang/srt/eplb/expert_location_updater.py": "b1e03dd4a8dc42d3987c16e3b0fa6dafa40e21f1f0363763bb673cf67a03199c", + "python/sglang/srt/eplb/lplb_solver.py": "3201e927a9513f92f6410fc25fa10e7804e21a05156f7c124ce936b2d3abc3a1", + "python/sglang/srt/function_call/apertus2509_detector.py": "10b776d3364f3bce87d8564903ae0b7f266e7cee2912f610f64299862f855b15", + "python/sglang/srt/function_call/base_format_detector.py": "0e56a1402b1d27dd92c5299f4bdeed3bc4499660df3c910c473a9691ba23265a", + "python/sglang/srt/function_call/cohere_command4_detector.py": "008deb2e5c078d5371a571479988c1b001f8b162287ce225b041484f0498b1a0", + "python/sglang/srt/function_call/core_types.py": "c0b52c5bc99403e8be212cf94140cbec48eaef65be2b51c88456bd5a6fbfa00f", + "python/sglang/srt/function_call/deepseekv31_detector.py": "ec6374c040a86dd2021b7ea7b989300299dea623fdaa3c71d6d9aa3f18e845d7", + "python/sglang/srt/function_call/deepseekv32_detector.py": "a7d6263b1e9d5ec3742ca399d1df2f7d4ff91a8d8c079d953035a976b6090a4f", + "python/sglang/srt/function_call/deepseekv3_detector.py": "a555137527cd524f51a888ee49224d4761856f5b4a9d93d3ca77abfb755c06d5", + "python/sglang/srt/function_call/deepseekv4_detector.py": "d826876e0b6229ff5d363da16b6c954c3211a080d72edb81cd56b0fd477487ba", + "python/sglang/srt/function_call/function_call_parser.py": "578defd8404b88a6dd4786a19fad9777e889898b4211a7bdde2f6ac7c11a4531", + "python/sglang/srt/function_call/gemma4_detector.py": "712146a24e1873fe5d2872253a1688399a8929f7d5c04094e2027428ff767d99", + "python/sglang/srt/function_call/gigachat3_detector.py": "f544d3bf51e1afaf9c8fe62878c5ec9e929c1db2eb9b1e4040daeb0be81c413a", + "python/sglang/srt/function_call/glm47_moe_detector.py": "93c882d0d3d5613c792a4a20da22a9e54d4f36ebb828846dce05a1acb81d83cb", + "python/sglang/srt/function_call/glm4_moe_detector.py": "a8daa4f4ef6d45aaf612b0e0fd3f922e5b52a406ac85abcf7c2cc2e39857ed81", + "python/sglang/srt/function_call/gpt_oss_detector.py": "5c81fe623acd20c19106ce946d8d902a285769babba43e8ddc4c181a5a9da3e7", + "python/sglang/srt/function_call/hermes_detector.py": "5dc30e64c7ccd453f3b5fc50be0321c3bb404dac3e689ad4cc384ab2c45de27c", + "python/sglang/srt/function_call/hunyuan_detector.py": "546cf13fa2951d89641b02394fb4da0913baae82d5f5e4db7e2f48f76126b329", + "python/sglang/srt/function_call/inkling_detector.py": "52273f962e652026e86324d2e6320225e10cd24cf1b002674d1d7e1659680d99", + "python/sglang/srt/function_call/internlm_detector.py": "a2339f334c5bcc7fe36d7cb7cb3b7621918eed857397df47e6f3ecee28b38133", + "python/sglang/srt/function_call/json_array_parser.py": "7ebbff7e8ad4fd1ca0f227b9edc345715d637387301710fb8ab619286a31b934", + "python/sglang/srt/function_call/kimik2_detector.py": "92d6dd3751ba1bdcc5ef64eca0db87c1e341d0f81bbd764664ac6ff38f08f839", + "python/sglang/srt/function_call/kimik3_detector.py": "423aaa042a963f7b3c091991c9a356d23e2f161c05d0e3d4dfa07da17be87838", + "python/sglang/srt/function_call/kimik3_format.py": "65b893bb3314c02ef2537cc4a8c85b3d798101a5cebebb548a2cac1caa5a3a63", + "python/sglang/srt/function_call/kimik3_structural_tag.py": "bd00d77898be7f6231f165eaf716f0c0cb71cff66036495e261fffd39f462aa1", + "python/sglang/srt/function_call/lfm2_detector.py": "2d2307a9c62a48ca553735b4018d0b02471f08e8ef2eaa0a53cf82b18a1ca534", + "python/sglang/srt/function_call/llama32_detector.py": "e83ee75917cc1921c21ce899e0103af4b94bc492195f87843364580dac73eb5b", + "python/sglang/srt/function_call/mimo_detector.py": "2b4ca63e1de0b232c69cf26609e87d0da9a8a3be9c4acd29f0db62e2dbb0db45", + "python/sglang/srt/function_call/minicpm5_detector.py": "12fc0378e86b337706ee1e64e3b3c96b8550eaefda74a97e8dde54dee954c1e0", + "python/sglang/srt/function_call/minimax_m2.py": "fe1dba10e3d9a76c3549a20c2b8ba1b609eefa4a817197abba8175b725a724fc", + "python/sglang/srt/function_call/minimax_m3.py": "cbd83122df28c1ef6d6ab34007bd7d64eb56f902614fa3bd74e5c681f2fd0e65", + "python/sglang/srt/function_call/mistral_detector.py": "ecb2637d1766f096c698b6b8eaadeb6e772aa3487d6566f61f665c145dd73336", + "python/sglang/srt/function_call/muse_glimmer_detector.py": "c7becee4831996d4b3bab24659ed45c10980b1d341ac4f05ffd567bc76a5935f", + "python/sglang/srt/function_call/muse_glimmer_format.py": "91126a99c959c98e287db819411b099a6db3fa0d9060bb736694e33d8b89e8e6", + "python/sglang/srt/function_call/poolside_v1_detector.py": "3bc52645891d5c9bf97c3796f5dcabdf1bfcdcac0f4483aa5786da5bf950d295", + "python/sglang/srt/function_call/pythonic_detector.py": "47e6f58b88db14870864985f51e18965b39332cfd5df293de3d26be7e778c6ec", + "python/sglang/srt/function_call/qwen25_detector.py": "e4ebe052024b4236819932ee3d54941fe2db9bb9107711ec33514d1d68c3c9e4", + "python/sglang/srt/function_call/qwen3_coder_detector.py": "4cea43b633e46ca164492ebd3a26892dbc602e29856024eaa05be65551ce4541", + "python/sglang/srt/function_call/step3_detector.py": "7ece8be2b2f8dcf9285d405baffdf69ba3632cf799ef5a1a942a73b2ae1d1cb6", + "python/sglang/srt/function_call/trinity_detector.py": "868f345fb3129456073497949c913457cdc2d54ec90885d71e302bc85114fca8", + "python/sglang/srt/function_call/utils.py": "fc55c1b3d63a3631841aa1b6b5979cb0647e6ba27a4f5a1f1a1573f46eca8c25", + "python/sglang/srt/hardware_backend/cpu/quantization/awq_kernels.py": "6ab92cf54daa765c6cf55e9f2daba16698f41821abf43a455697dc075d7d79ae", + "python/sglang/srt/hardware_backend/cpu/quantization/gptq_kernels.py": "e0c95772981e9927040988cf41c4e17fc563fe49d45d165da6b600f39bf8bf0e", + "python/sglang/srt/hardware_backend/gpu/quantization/awq_kernels.py": "055053ba8cb17a66a6b86feba08cf9abd0ffe9c01b8be71c2a9e0a990a53d83b", + "python/sglang/srt/hardware_backend/gpu/quantization/gptq_kernels.py": "375085abdd2f4abca3d5831045d5f11d012c1877e0a19f79ebe89593b5568370", + "python/sglang/srt/hardware_backend/mlx/aot.py": "01860d8645b7ea869508430728a97378d657cc2ad1d3589f8bfc244d9d7f832b", + "python/sglang/srt/hardware_backend/mlx/kv_cache/__init__.py": "be7e9e48cb7e6128073c59633331b702c824e7663247988be2c1fddc2678a19b", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_contract.py": "ae36edbde00e162f81bac8b58d9d57081c7606b0204e4d949e7b2345030aaed5", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_kv_cache.py": "b356b0fe2b6c9669a0b531a83cd40fbbe8f7920ba04f4bc8ff127fdeadb40885", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_kv_pool.py": "d4235abf8d7e899e58eee3cc432840549227329aec7524b7721c97846291626b", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_wrapper.py": "c8485033ce1a3363cd6288bb3f7717a3be6e27a7278a9e6a451c0bec22ef7105", + "python/sglang/srt/hardware_backend/mlx/kv_cache/auxiliary_state.py": "31bb2cf55d87f0493658d4a83ec621a2bed590ed47f272534c603d4e62bbeb7a", + "python/sglang/srt/hardware_backend/mlx/kv_cache/layout.py": "e4f3b27e74eb8118c928479e8c1fcc880b3798331b2bd5088bc648af0b25399f", + "python/sglang/srt/hardware_backend/mlx/kv_cache/model_patching.py": "fbdac75437d50d7837c755d7e8950412f49f018e06c2a03c0d982d5bb793285e", + "python/sglang/srt/hardware_backend/mlx/model_runner.py": "48495702c5f080f2e8c063e1ec4d39d93ed7172c6c3eab5480dc7d8d30e46fac", + "python/sglang/srt/hardware_backend/mlx/model_runner_stub.py": "9bad79c3ab1910673856f71d51226bde7c43091cfed4bbf4ad3367ec31ff69d3", + "python/sglang/srt/hardware_backend/mlx/models/muse_glimmer_mlx.py": "e9e2d4dd21a92e0747f6db685bf0518e3d50ea489c52e7f56ef28833d9469339", + "python/sglang/srt/hardware_backend/mlx/moe/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/hardware_backend/mlx/moe/fused_swiglu.py": "7af9920968fbd7186909fd6af144b5233cdb43897f3d446f59e4e77d713569b4", + "python/sglang/srt/hardware_backend/mlx/parent_watchdog.py": "73280296edd1c553cc0df6ed963cd6a17e293291fad1bba300600095be870c31", + "python/sglang/srt/hardware_backend/mlx/profiler.py": "6d344b577c9905922daab260320b936a2ff05a1e0191667a493f48a1f17a2f0f", + "python/sglang/srt/hardware_backend/mlx/remote_code_gate.py": "2fca7faf07b67d8d336e216369562fb3001e21d7366b1dd7799bedc0893f2cd5", + "python/sglang/srt/hardware_backend/mlx/sampling.py": "e9dd918cf5a1bf3fdec697371e393f0335fa333d2eef415047314e4407e9dec8", + "python/sglang/srt/hardware_backend/mlx/scheduler_mixin.py": "61fb35e2492e80a9907fb3e2683e5598d2afd2eff25a0570f41416424ec68288", + "python/sglang/srt/hardware_backend/mlx/tp_worker.py": "b069bad13eb10965c0a4cc3790085d661fcf921b1c301cea12f2738c0c472927", + "python/sglang/srt/hardware_backend/musa/__init__.py": "98c2f352233b032b0a4192efaefb25f2ec3fa153d996dc78c327253723069897", + "python/sglang/srt/hardware_backend/musa/attention/__init__.py": "98adf994f3345c498e7477f82245508600e3f5ded2205e2e6af5c0c80eac616b", + "python/sglang/srt/hardware_backend/musa/attention/flashattention_backend.py": "e95f13b232edbcc785ea63164b186cca3b05b4a64b12adccf14ad19f2e856282", + "python/sglang/srt/hardware_backend/musa/kernels/topk.py": "d9ea6fbfa6c362d419d75b47ca12e1e4a01c01db8d8ccc474e45ccc8eb732496", + "python/sglang/srt/hardware_backend/musa/layers/utils/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/hardware_backend/musa/layers/utils/cp_utils.py": "b63615113b1142ee6667e182a0fad19507eefafb88161f4eea877d41789e126a", + "python/sglang/srt/hardware_backend/musa/utils/patch_torch.py": "d5c2492e9c3389f33cb7ad75ee0f1fc3f62853436911d17962b1f380d2662536", + "python/sglang/srt/hardware_backend/npu/allocator_npu.py": "7c96bdbe2812af59e8f7dd77a085774520ee152d4b051c8e41fb2b87570fa568", + "python/sglang/srt/hardware_backend/npu/attention/ascend_backend.py": "97cba7e5b180bc767998e6150ab89565e16da3180aa666463029b04162e10b4f", + "python/sglang/srt/hardware_backend/npu/attention/ascend_dsv4_backend.py": "b4e74210398435aaee4d9a107649780bb65d3e4ded7e548882d4065a9f06368e", + "python/sglang/srt/hardware_backend/npu/attention/ascend_gdn_backend.py": "b62bf1c59130a56567613206da62a3ffb77333c6943f703267b79c3f1f829337", + "python/sglang/srt/hardware_backend/npu/attention/ascend_hybrid_linear_attn_backend.py": "b2796ba9128da3666433cbaf4ca74d2dfdae63682444abcddfaa1c8255fefaf3", + "python/sglang/srt/hardware_backend/npu/attention/ascend_kda_backend.py": "7fa11a8f05da1b2cbc61d849f50ed23077b5c76d81b25fabc71c05ce8c57f19e", + "python/sglang/srt/hardware_backend/npu/attention/ascend_torch_native_backend.py": "980526716059fb4ffe6eff2a64e6b7e068fcd10f5b2c6075a87e52b04e541e4d", + "python/sglang/srt/hardware_backend/npu/attention/mla_preprocess.py": "b74303957f7b04b20dd17f5830ac5619aa60e1cbb49b2984100922b9ea42c05f", + "python/sglang/srt/hardware_backend/npu/batch_invariant_ops/npu_batch_invariant_ops.py": "594866569d8461e8fca6cb10f86c0200a9afa30a49c22009a3a320d5d5352f73", + "python/sglang/srt/hardware_backend/npu/cmo.py": "2d92b479bfbe32f61c4e6fd3f8a90029917721e7242933bdb7bcf8c43ec17200", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_allocator.py": "de50d12a6c3ee42cbc3ef70078c50d9ddf3ce6fe81044a8da2ab3dca006cd0e2", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_common_hooks.py": "912a18d6e6cfa1da8be500338261df2023d61c1caa43ccd0230e5016388098f4", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_memory_pool.py": "27720a07a169a7ae33cde62f50e73b9c00c3bc365c89b9531a10ffc646b2bc89", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_req_to_token_pool.py": "b08f5e7a7731d64a3bce64f2914789ade1b6a6785deab997792ff80bd2f07efb", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_rope.py": "dcc1e6845a6020ed6f8c38379bd2bb987cd3889223fc669d83bcaa5b492323ed", + "python/sglang/srt/hardware_backend/npu/graph_runner/eagle_draft_extend_npu_graph_runner.py": "158d5c2e4bf741280fdfacea70880877c90aa4810c01f7d5a46f2d4aec57cd91", + "python/sglang/srt/hardware_backend/npu/graph_runner/eagle_draft_npu_graph_runner.py": "5948b09510d88f528819f5c85d1537dae396e9f3cf0634a0a107768a629622e5", + "python/sglang/srt/hardware_backend/npu/graph_runner/multi_layer_eagle_draft_extend_npu_graph_runner.py": "6e4bc0551977692c7905555a78c9899b4bd9d38d4c012ca28f92d3a6b89ee864", + "python/sglang/srt/hardware_backend/npu/graph_runner/npu_cudagraph_backend.py": "4c2a2a4aa41d5076ca2618f259697f5d4e2a18b362d891b43a63afd0445f391d", + "python/sglang/srt/hardware_backend/npu/graph_runner/npu_graph_runner.py": "b664301658e30e0e59607210babf3f47f000c812f8abb0af416bc710ed7d9c83", + "python/sglang/srt/hardware_backend/npu/graph_runner/vit_npu_graph_runner.py": "d602034909d74454a32caa39c57f5498d5bba0b53ca84e33ffba1b4546dbfc37", + "python/sglang/srt/hardware_backend/npu/memory_pool_npu.py": "c2c1d711601d380dbaa0cd19106bd201f1183f30fada4fe10b5b4309a0cf9537", + "python/sglang/srt/hardware_backend/npu/modules/deepseek_v2_attention_mla_npu.py": "7fa76db72e593a8ba108a28d6a6377fb5e2be5da6b005c1ee2f78397965ea9aa", + "python/sglang/srt/hardware_backend/npu/modules/glm46v_processor.py": "d8c17bdf2fe74cfb5981625c99a7532cc3fe442058fd89d31499b49b401ed8f1", + "python/sglang/srt/hardware_backend/npu/modules/minimax_m3_processor.py": "b29ac8d4bd93cb84041c2c9151f4cd190757d0ab5c6956a53e79252da6da111c", + "python/sglang/srt/hardware_backend/npu/modules/qwen_vl_processor.py": "41f6cb1020b188c412b698e80e957cf6b72ffaeca758d5efe9a838b61beb5186", + "python/sglang/srt/hardware_backend/npu/moe/activation.py": "6332eee502bcb38461bf7fec9808860b86063b115b931903a952060e95b259be", + "python/sglang/srt/hardware_backend/npu/moe/finalize_routing.py": "5f405ae3f69794eb21e6fa3a9a72c0c6e3abc954b69bc5895233359b1b341426", + "python/sglang/srt/hardware_backend/npu/moe/fuseep.py": "4f38387bbf29b9ecd8fbca4bbd24643c83476f70980489132e75230064336545", + "python/sglang/srt/hardware_backend/npu/moe/init_routing.py": "7259a3276000c15b0cb9db37905590889c02b0367b45f7aa6444af76738559c7", + "python/sglang/srt/hardware_backend/npu/moe/matmul.py": "103ee3efc3fb7472f123caa90f6bbee78ad54b539ea4c6029728292449343bca", + "python/sglang/srt/hardware_backend/npu/moe/quant.py": "f257a11a9d84899a4bdaec4d50f8851ea00c990304605ce87e03eaa8d2c3e21f", + "python/sglang/srt/hardware_backend/npu/moe/topk.py": "f82f25bb343892b7b8b1eb833a4e6ca376a510ac74a3a935e0a1997dbd072f75", + "python/sglang/srt/hardware_backend/npu/quantization/awq_kernels.py": "fb7e61a875fb16733bad79bb369470c0811b16297538a0096ee99db085ed0ab2", + "python/sglang/srt/hardware_backend/npu/quantization/gptq_kernels.py": "bbe88891a5cce8fa4384ccd792ff8051e57a8c464834066794cf4080a3213ce6", + "python/sglang/srt/hardware_backend/npu/quantization/linear_method_npu.py": "fb048862fa9bb1bfe1082571ce3801c0a67cd706972b9410df01b2d719d56b90", + "python/sglang/srt/hardware_backend/npu/quantization/moe_methods.py": "a2f19e4447754aae0d4c8298006f7bc4f4fe42ffe87d71c08364e90f26924c66", + "python/sglang/srt/hardware_backend/npu/quantization/online_moe_methods.py": "a58fefd0f600f928e639dd8efc3ac20bdf5819af63e447db40e123aa5667a657", + "python/sglang/srt/hardware_backend/npu/utils.py": "eaf2a13ecef1ceaa2871e1ceabe0d39d89d4f32f934a696684acc5f9734deb93", + "python/sglang/srt/hardware_backend/xpu/__init__.py": "64e0d0c737f4e4502cc9ba8f9eeb132f5cff859758e0ce996f84f85a8177c01e", + "python/sglang/srt/hardware_backend/xpu/graph_runner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/hardware_backend/xpu/graph_runner/xpu_full_graph_backend.py": "9f9c31cd0444afd50e806e32163f5e87d200ebcdbe60e382449891063f130d89", + "python/sglang/srt/hardware_backend/xpu/graph_runner/xpu_graph_runner.py": "e46764c9549d4fc90df488e8f87a9d513e3d2c48c7afc58daf5088713f09f4da", + "python/sglang/srt/hardware_backend/xpu/kernels/fla/chunk_delta_h.py": "89bcc1275bf8f3e5f90b8a451060bb720c90f2ab640c75830ee65b59839b45e9", + "python/sglang/srt/hardware_backend/xpu/kernels/fla/chunk_fwd.py": "1a83fb1671688d5cd995007dfcf1d85519a45b9ec8ba1fcc354431e62a851a5b", + "python/sglang/srt/hardware_backend/xpu/kernels/fla/fused_sigmoid_gating_recurrent.py": "f7920b6429af284d909324e43ac29d344bffed456465d52625384a4e7f42fe34", + "python/sglang/srt/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/api.py": "9b52a98d05f5143ad647e67b8aa66cf6fd5d5945153bf6f3e004713cf07cabe8", + "python/sglang/srt/kv_canary/buffer_group.py": "a694b2fd65132e06143a0dac2da636a2880019d7e0c98ab772cf51a2a088d1b3", + "python/sglang/srt/kv_canary/capacities.py": "e4861f85c69f748f36373ecf187750210becef2b33297b8e9141c6b9546f71cc", + "python/sglang/srt/kv_canary/config.py": "b265fe49344de6ba64d8364b128bc59a52ced91dab799c34af65b9e8d7f8b762", + "python/sglang/srt/kv_canary/endpoint.py": "373c89fade17867c597021a7f478757406084b591ad2faf4ad5295ce46c07534", + "python/sglang/srt/kv_canary/expected_inputs.py": "4dce033c1edd272845732099081d9b879eee44bdb642ba4cf20c8e333796e36c", + "python/sglang/srt/kv_canary/perturb/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/perturb/config.py": "7a74803a65a39024bdb9a768b23fd996e233c4f664f6cc0cbfaab78778418837", + "python/sglang/srt/kv_canary/perturb/manager.py": "ab779cf17fa7a651105f5c85166801158203a0c514139d086a830bdb52b8b7e5", + "python/sglang/srt/kv_canary/perturb/next_token_swap.py": "dc755f51b7e5d3a60eaab6eea025298cc547a3042e15bd647e5d543a4e3735fe", + "python/sglang/srt/kv_canary/perturb/real_kv_post_forward.py": "be8863ee30a6f61a8679f0e9243931b89a3d4385b54dc53a967827ef2b19c062", + "python/sglang/srt/kv_canary/perturb/real_kv_unused_cache.py": "b88f803a7763e7d6da908a083cf17219d39f51d2a294c47148cf63c9c7e2183f", + "python/sglang/srt/kv_canary/perturb/real_kv_used.py": "8b8e7e4017e5677f073e03fa40c5c1d879fea249ea019c926d2d334e93c5c12f", + "python/sglang/srt/kv_canary/perturb/req_to_token.py": "edc06725ff16248633bc2240b035179a0d8033e0af788683c94da046a9c3ea18", + "python/sglang/srt/kv_canary/perturb/slot_picker.py": "50eea89b054013310474da5988f8a5dbde694081c9abadec9dfc69b26382bc75", + "python/sglang/srt/kv_canary/perturb/utils.py": "87ed6650884067c64c329a80b589ddc492b21f18e7a26ef8e017681855f1fef2", + "python/sglang/srt/kv_canary/plan_input.py": "c1eec88772e932286e4f85dc74fe52839f4e6cf8f1a4344f5a609766653e64f7", + "python/sglang/srt/kv_canary/pool_patcher/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/pool_patcher/adapters/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/pool_patcher/adapters/dsv4.py": "d2a7114b620c66650242d189cd4106a6e2dfc2cd75df60102b092b44d83cecca", + "python/sglang/srt/kv_canary/pool_patcher/adapters/mha.py": "107fadcc284058e68e915870e66f33796b111875165568810b938d393dd4bf97", + "python/sglang/srt/kv_canary/pool_patcher/adapters/swa.py": "89c39c8b621743e4b131052d3a2d0306ebe46c0e3ce4d0b32302b644a30d1b42", + "python/sglang/srt/kv_canary/pool_patcher/api.py": "efa0c95a02c535b7bd2216656f724de73d0ae4af628761fd2feb89f97dbf675e", + "python/sglang/srt/kv_canary/pool_patcher/buf_info_splice.py": "1c2b42261111c6bee904b3862744ee469512937ddbf73a2c08ca48ded6c6f2e8", + "python/sglang/srt/kv_canary/pool_patcher/buffer_alloc.py": "bdf7540a0877f38a50e48aa50c680b1382ec81d763415e3043097be27cd6e6df", + "python/sglang/srt/kv_canary/pool_patcher/utils.py": "b932bf4ae79a34ffa0296fd3f7155eab5008576e38f5f787fac30f11ce3c0f04", + "python/sglang/srt/kv_canary/radix_cache_walker.py": "0336c58e3f009d6eacfec49edabd431dffe556b6766a17e24cdec15e9d6834d4", + "python/sglang/srt/kv_canary/req_to_expected_token_ids_manager.py": "dd236499cf61f30cbe4c7d314ed023f0a69c3927dc259a41aa836be19818fecc", + "python/sglang/srt/kv_canary/runner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/runner/canary_manager.py": "5665f0be8884203de55a1481c0c7af7c05290942302671b2124eff20f4f00e50", + "python/sglang/srt/kv_canary/runner/enable_warner.py": "9a48cbfd97b5a094883b6e0b02772992d930e9986083e129ab94914825601d26", + "python/sglang/srt/kv_canary/runner/future_tensor.py": "3d1258cf36cf05d2b37ac6e864d9e0ed7234d0435876a54bcf63948ba3ac7369", + "python/sglang/srt/kv_canary/runner/health_checker.py": "d05fea43777d02c2d0d5b9f3c118a5cd0a6b853ac0e6278cf9a8d8c05a25c547", + "python/sglang/srt/kv_canary/runner/kernel_launcher.py": "6c9ebd784e03b0e6a043e9318a32df3fb99dc98c25ec2bfb959a9b3a80b79dfe", + "python/sglang/srt/kv_canary/runner/stats_logger.py": "c2d88687b3787f11533f3a0ef14c8a25a7364c96b01c4b1b24912246750acdd8", + "python/sglang/srt/kv_canary/runner/swa_divergence.py": "3a784d1f0ac1f2e1ecc6b403ee66388dfea02c291ada39c92384f2f22d258fe5", + "python/sglang/srt/kv_canary/runner/sweep.py": "af59c8347380be88809f7ff0bd988467a2ab290a20a761a5c623d7e0c45bc5ae", + "python/sglang/srt/kv_canary/runner/violation_manager.py": "c75633a08c50717d4a5854fb7160e6dc05ed41dc2f919bf51eadf24c9f47a8bf", + "python/sglang/srt/kv_canary/runner/violation_reporter.py": "f2b8c04bf46207a0bd87f5fe3f4859b35e2fd76e2f440a20809d0bf95e63d5de", + "python/sglang/srt/kv_canary/single_forward_manager/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/single_forward_manager/data.py": "79fdf8e6cb67568d44976d10c197c2b9e2687ac9fe7915fc382e14a4e83ecd45", + "python/sglang/srt/kv_canary/single_forward_manager/manager.py": "f70e97b30fa57069e56b8c93c771ac4861178a5ab894250e7aae14d87edcae46", + "python/sglang/srt/kv_canary/state.py": "ae3cb8dfebda81c613bc798861921f883391cd637c89bbf466be3d68c1f997e0", + "python/sglang/srt/kv_canary/sweep_plan_builder.py": "6dd007f700dbd11580a068a4a387dddb98d88c8853bba8bc56b9a2de829cf2a6", + "python/sglang/srt/kv_canary/token_oracle/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/token_oracle/install.py": "09fa6834e431be696baa7a0ce3bd1fabf443618d395117607ee84d657b2b1489", + "python/sglang/srt/kv_canary/token_oracle/oracle.py": "9ef15e40f81a4f788827a172e2e50105ab5dcd07f8593448c77b48ca09b900d2", + "python/sglang/srt/kv_canary/token_oracle/oracle_manager.py": "7e434aa530009bbfe7ee6baf038626591e51bc5a520e3911c0bf61e5e8660500", + "python/sglang/srt/kv_canary/token_oracle/sampler.py": "3fc753a2a89c9bbaeb4d6b0405a83fc705a53b62c2999daeeab3997c4a0fe4bb", + "python/sglang/srt/layers/activation.py": "231a49e1f2f3f2237415e77d85d36c159c2ea3424f0197100f469252164bab7e", + "python/sglang/srt/layers/amx_utils.py": "9c78243b97eda52b7771219c373b50a46c498fc2ddb86caae2dfc2f96b130c48", + "python/sglang/srt/layers/attention/aiter_backend.py": "5a08325b94695eb0426fcfe78f08639eb1a849060917c601d6831e780112dce9", + "python/sglang/srt/layers/attention/aiter_utils.py": "11028c3388212e570c192f999fb43de4c161e2fd5f72f99eacef91a02a530f25", + "python/sglang/srt/layers/attention/attention_registry.py": "b2700564bbbe536d81ee76775449bd12e835e7b02e94a23d9545aeedc52b095e", + "python/sglang/srt/layers/attention/base_attn_backend.py": "21ef3e25c65b6921434a88e625b72b1442709a411a89e04e7f4f8dcabc7531b4", + "python/sglang/srt/layers/attention/cutedsl_mla_backend.py": "f5d6a8c062b8c1a6c86549a077aac62b7452993bd6635c62d46012dce70bf41f", + "python/sglang/srt/layers/attention/cutlass_mla_backend.py": "c6c5048e67b3fdd127115227341623bab0cdb6dbfc54e5d89cfa455c508b63dd", + "python/sglang/srt/layers/attention/deepseek_v4_backend.py": "e2b38050e44768e9da10a801979b3b29d9ed80437b4e9c3b277b0d40e6305e85", + "python/sglang/srt/layers/attention/deepseek_v4_backend_hip_radix.py": "9f7ee5f88ca8a31e486797155a365fd6908461405024290a52882ddbe9d33083", + "python/sglang/srt/layers/attention/dsa/dsa_backend_mtp_precompute.py": "0c77157e78272940485f93b1058603b687fb218299e6b6f503df6fb0fb2ac730", + "python/sglang/srt/layers/attention/dsa/dsa_indexer.py": "3404c9b83452d73f156b742ae32e4085a17d0b166d4d5e45afbd31cfa499b686", + "python/sglang/srt/layers/attention/dsa/dsa_indexer_metadata.py": "0661937fa064fc2788b3e23d73bdb4767c344a2cd18d3a217eea74aa0b921881", + "python/sglang/srt/layers/attention/dsa/dsa_npu_indexer.py": "8dec4f5ccf57f1e25e2b673a987406cef71202515141a18e94c1a2c802413bf2", + "python/sglang/srt/layers/attention/dsa/dsa_prefill_cuda_graph.py": "a1e8af9d8e5e4d58bffdec9b7a8e163c2a89e21e5dd7b21cbc86dc479e55c45b", + "python/sglang/srt/layers/attention/dsa/dsa_topk_backend.py": "dc6ebb07bc3551ced77fe5700ea650c072f13a6e703401152e0962c754b62e9f", + "python/sglang/srt/layers/attention/dsa/paged_mqa_logits_backend.py": "211de1eaab2273cd9c84daca4a189b10450b3cedd8fcbdabfb02d0d51d166d33", + "python/sglang/srt/layers/attention/dsa/utils.py": "debec7e26cb978283ee73cdd0d98004a08f157f6e7e9e2f10a620f8f78d67d5a", + "python/sglang/srt/layers/attention/dsa_backend.py": "b58944c0951217301baca28b73e0222fb1b635040c475d550658b2538dd0d06b", + "python/sglang/srt/layers/attention/dsv4/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/attention/dsv4/compress_hip.py": "420eecb061bbbefea41c905b05e152d1894db72016499564b9fc1bc1df338746", + "python/sglang/srt/layers/attention/dsv4/compressor.py": "6eb018051441c42004512ebb0da27e4b5c4df7b01e037127c50b97a2a27303f1", + "python/sglang/srt/layers/attention/dsv4/compressor_v2.py": "b41377aabe59a03041e5ab46ded60bb4d7e77beac2b14d4acebde2299793db3f", + "python/sglang/srt/layers/attention/dsv4/indexer.py": "1718bad546998d9b54fa7bf97256ee36dd3f7a7008406d8870f1efc447ffc7f9", + "python/sglang/srt/layers/attention/dsv4/metadata.py": "c6aa330d5b5b0fa10e8f09de6c758453763d131cfb1787fa0b8f4f17d01beae8", + "python/sglang/srt/layers/attention/dsv4/sparse_prefill_utils.py": "babef988e67b28f37f8706f2e49a99af0bf9669ab0f8922d80bf565db9dc518d", + "python/sglang/srt/layers/attention/dual_chunk_flashattention_backend.py": "b1b6d9053e1dc6528f083f9c019d3b7d5e74b8d580ebd1349ec6942af95aca07", + "python/sglang/srt/layers/attention/flashattention_backend.py": "e29fc321d99239e3002351e93f3d918b593540fa69ef8097a4104ace7409fa9d", + "python/sglang/srt/layers/attention/flashinfer_backend.py": "3487eb51ab3106350a2dfaaaee5f00223d678fc9dc16267c2aca9e90500efb61", + "python/sglang/srt/layers/attention/flashinfer_mla_backend.py": "ec61e3e093e66a9e79ff6a866c0d81d8b4eaed9b3bad74e8e40e4f3491dd401e", + "python/sglang/srt/layers/attention/flashmla_backend.py": "4a6775bfe75163c69158c4058ce81f56f0c689969122059f9b0e41e22b707afd", + "python/sglang/srt/layers/attention/hip_flash_mla.py": "23f450adfcf65f8962973f0e966bbaa759e59de78e1471c334ccacbed50f43ef", + "python/sglang/srt/layers/attention/hpc_ops_backend.py": "a22f4bbcfc90969c7e8c5dcd3cf071daebbf97e8f1c78c16be7fa627951c517f", + "python/sglang/srt/layers/attention/hybrid_attn_backend.py": "7d52b731a8ba2a33a6fde6f82cfef026d6dea4e938e35c2791869a2994d81cc3", + "python/sglang/srt/layers/attention/hybrid_linear_attn_backend.py": "6815a76bdc1ab6d299cbfe6b7abc57e2f6328645d1d7a3ca3c47ac1f14269623", + "python/sglang/srt/layers/attention/index_topk_share.py": "8659afff39a7db8187a6ab101b501bbe65d2e45856d73117ada9ecb6e760c4d4", + "python/sglang/srt/layers/attention/intel_amx_backend.py": "9b9dc0e75a51c3941e0fa805abbb06ad940c5e7b3f3c48b9ffd653b3e4c3face", + "python/sglang/srt/layers/attention/linear/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/attention/linear/gdn_backend.py": "dff629b87777feed0411414d66c096725267b4f8c8433226e0dd36399d440e00", + "python/sglang/srt/layers/attention/linear/inkling_sconv_backend.py": "276f0fa8f6fa80aee897e30f55e8bfbcd5cde8bf589c19307d5d024b39213fdb", + "python/sglang/srt/layers/attention/linear/kda_backend.py": "a1a06b3f5e6c13aac4c43aaed2a53581f384896769175e52975b68119a467025", + "python/sglang/srt/layers/attention/linear/kernels/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/attention/linear/kernels/gdn_cutedsl.py": "282e33bd8c60a77d8687a9bd11d3e13dd75774442967e3a6097476086346901d", + "python/sglang/srt/layers/attention/linear/kernels/gdn_flashinfer.py": "abfe7172239d3477ec5a14d4f2ce0fca1ee6d6dfa958b9e5041c98fbf27f4942", + "python/sglang/srt/layers/attention/linear/kernels/gdn_triton.py": "c3dfaf1eb04c035df2c7374a6714aeaa66c8a49b6573f8f28b100b9e7e063c82", + "python/sglang/srt/layers/attention/linear/kernels/kda_cutedsl.py": "df11b5d8b44644602f3c0ee361e47ee856048185b318ac409250091b4bf490b5", + "python/sglang/srt/layers/attention/linear/kernels/kda_flashinfer.py": "3188204bf8dba01dd462525be0c0266e3b9d240d4f9a5cb0d4c51485b8dfc367", + "python/sglang/srt/layers/attention/linear/kernels/kda_flashkda.py": "efabe373997983415159a3763472f4a1b1b3cdeb752d375a2b6898e2263f5842", + "python/sglang/srt/layers/attention/linear/kernels/kda_helion.py": "e67d3d430992ab425fc5c55db04b2f413c0b82546ea1b1dc1e52aad8199ae292", + "python/sglang/srt/layers/attention/linear/kernels/kda_nvidia.py": "41976cf93d43e2e36da084ed9e138b37cc6a86e5683201fa02dea38b2090bee3", + "python/sglang/srt/layers/attention/linear/kernels/kda_ptx.py": "78bd59a4a5be7ff48d292ce43590b60e73384f5b0838107e11f6ed4f43b57a6a", + "python/sglang/srt/layers/attention/linear/kernels/kda_triton.py": "176b0caff60ce5c26cf97b0c5b45098896a4856f85d588ed7dccfc13848b9b07", + "python/sglang/srt/layers/attention/linear/kernels/kernel_backend.py": "09921e483c106beedb9d3349079e75767bec8d8a0cb2fa900afa9980ea94ca58", + "python/sglang/srt/layers/attention/linear/lightning_backend.py": "0a19f17b4f1276ee16f0802399ef87c5479f0efd2bb757a8a2e43352a4caf25e", + "python/sglang/srt/layers/attention/linear/linear_metadata.py": "281621826248a9650fad6ef1189c7f1857cf154e73e6e6fecec3e5f393e48daf", + "python/sglang/srt/layers/attention/linear/short_conv_backend.py": "c65a74cca0ff0000bb368116eb4c13ff5489c8f86ac414765b84e287964dbbd4", + "python/sglang/srt/layers/attention/linear/utils.py": "77fb6031e34489ac38848d7d4f5995f9a0f1c47c1d4ad777bd978a05a21c7978", + "python/sglang/srt/layers/attention/mamba/causal_conv1d.py": "fccf7b947ef601038d867434f5a774fa3f169c356ba80e71eb255fd5ef249ef4", + "python/sglang/srt/layers/attention/mamba/mamba.py": "81c8860fd634e83977eb1ba2388a370448d9f7226d159a1b7a437f74f1a79196", + "python/sglang/srt/layers/attention/mamba/mamba2_metadata.py": "b4e7187faf88cfaeaf3de16835bec2b78b635db97fdfb2b9abf58e889dd7fdf5", + "python/sglang/srt/layers/attention/mamba/mixer2_rms_norm_gated.py": "3e5bc6cb1d60ac6312e0a408877faff7df7c2e46d787dc2a626bfdc3a470ec9c", + "python/sglang/srt/layers/attention/merge_state.py": "024522ddc38f7e493b937bbf30a5ad7474befd3908053db301a3a32e07bf33cb", + "python/sglang/srt/layers/attention/minimax_sparse_backend.py": "a9741fd74c16e94b8f8f200cdd5dec8df45617cfb3851d0f70b7e518fe431184", + "python/sglang/srt/layers/attention/minimax_sparse_ops/minimax_sparse.py": "630dbf65874310a89b5c7be7493ed75a7ff5add39c526925ffe569df6d4011cd", + "python/sglang/srt/layers/attention/minimax_sparse_ops/msa.py": "b9f1264b195dd49267fe8931b2e201806abcf05e55b0ab33bb1811bb6eb8a9b5", + "python/sglang/srt/layers/attention/minimax_sparse_ops/naive/flash_with_topk_idx.py": "b7bade9994f045b3ce8c494b1d2aa764cf0f9826e1d1bfd83925de7a6d29ac82", + "python/sglang/srt/layers/attention/minimax_sparse_ops/naive/topk_sparse.py": "3f990aa3544ff631d523efa82faae1ca836d0c1156dc3028c73a71eef0753395", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_flash_with_topk_idx.py": "3da8218bb7768b23bb0b7d1c07114c9015ca92e41a8fa4ac85e507508040a0a9", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_fp8_attn_gemm.py": "aa63ce50c88b5dc1351ecd3c59902babb66ce2576b5532aee8e3ae464bdaca89", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_msa_fp8_parity.py": "77d413b73eaf8552541d4402523965d8d45d96bd8dd89aeac96f87f151ce39f1", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_sparse_gqa.py": "cbfe7e55e752ba6d0d9f4cd50b5b18b1e6b455e3c1b4a62a5c43165cf725f339", + "python/sglang/srt/layers/attention/nsa/__init__.py": "d495b896a7c369016e9c5a87f4d3b6bd5a9ff2b60447332ee3b691d5fe525758", + "python/sglang/srt/layers/attention/nsa/dequant_k_cache.py": "ec1360d017a0c03fcdf7ad7edeacc11f4373c67401ba451f8e51b9cc46691b96", + "python/sglang/srt/layers/attention/nsa/index_buf_accessor.py": "b1085dff188766111ed109f602d0544911af598d4cfda4d710404de04c8c34f7", + "python/sglang/srt/layers/attention/nsa/nsa_backend_mtp_precompute.py": "e74ca1e0b174c219f9aae462140f16d339903ead6e62988d6cd63ffce24d0547", + "python/sglang/srt/layers/attention/nsa/nsa_indexer.py": "db51e44afa68cff2be1220416999539e850d1347e2aba74e4882d8fbf81223af", + "python/sglang/srt/layers/attention/nsa/quant_k_cache.py": "b6b29464ad973cdc408cff9698262893a45bd967cc1f24d3349d78d45d797d15", + "python/sglang/srt/layers/attention/nsa/tilelang_kernel.py": "7a5b7eb629245d5cb699ef3becbf2595053d7406971aafdc7b72afc2deec84f4", + "python/sglang/srt/layers/attention/nsa/transform_index.py": "593131a485a3e9c39e07bd733d27bb905de16634118e5d562d09088df7e88bcb", + "python/sglang/srt/layers/attention/nsa/triton_kernel.py": "19133e5a120257e73bc2ecbe255b656d7efc743374b899df13c577aba814ee94", + "python/sglang/srt/layers/attention/nsa/utils.py": "1abd4021f8ba49eb793faa3984dfb41fa5f40a32479066d8e26af258fbee8358", + "python/sglang/srt/layers/attention/nsa_backend.py": "6cb122eb32ad5c07d42dfc2bfb2ae43cb3111befa32ae95d03b09fc732bc2de6", + "python/sglang/srt/layers/attention/qsa/__init__.py": "89d2d232717eba289190f9f6eb95b6984a4db3eb213cb709569d76ed6c56142d", + "python/sglang/srt/layers/attention/qsa/config.py": "71a34e48c672480472e2040cc99955f7b7878a14c4ffa61493f290bb61fd1ad8", + "python/sglang/srt/layers/attention/qsa/dsa_indexer.py": "46fed29d13f11e2fc12f7117999969ca8f3564cc1ff3afaff93da29513bbe41c", + "python/sglang/srt/layers/attention/qsa/glue.py": "cb8064f4fb56e76e9f04d03ac12be23b76ebcad1eb1662f91a97c7a3a0f4c2d8", + "python/sglang/srt/layers/attention/qsa/graph_metadata.py": "9dcb66dffb079ca775677c3294ff45c945461fd8893200fc5d6ed26cc9f6d5f6", + "python/sglang/srt/layers/attention/qsa/kernel.py": "5482e38d30bfaf1624ec0625b4896cbb395a1637f75c183c8ca723c9f6055ff8", + "python/sglang/srt/layers/attention/qsa/metadata.py": "c529169cb0e9887a8d52fdbaa6312963747cb48be0a8058445d4de4aedb8f391", + "python/sglang/srt/layers/attention/qsa/mqa.py": "af36d5c8f4fbda5b0e82b7f31046a95c9a709fcc57b3600c6473c49e87b7629f", + "python/sglang/srt/layers/attention/qsa/qsa_indexer.py": "bb57ce1e9abc4fbfcba2c9aaaf125b9e625983966497df57165b6d4c6461afe2", + "python/sglang/srt/layers/attention/qsa/sparse_attn.py": "c7052125569f3c0fa9a0a4d62d2f57433faec636ad82a1d99c3b39e267b7904c", + "python/sglang/srt/layers/attention/qwen_sparse_attn_backend.py": "12c4d4d34774e5592c3a3ba3956d19a280606007e0161598e4e108bb6caa479b", + "python/sglang/srt/layers/attention/tbo_backend.py": "c19db2433ca43a07b36c48de12a69e4fadd846a6b6e991d985a17f613606564f", + "python/sglang/srt/layers/attention/tokenspeed_mla_backend.py": "429c55fa3284e94002ff18a86b7389c1c0376c504d877df8ac48046bc4a9e031", + "python/sglang/srt/layers/attention/torch_flex_backend.py": "12876a0fbede05168a9e8f997385ec1b4f009783ce7bf9c98516f19476ad3480", + "python/sglang/srt/layers/attention/torch_native_backend.py": "5da07edadf56f4f4e4b8319ed48216b5a8ddb989224d3e95011b76800bf9926b", + "python/sglang/srt/layers/attention/triton_backend.py": "0ae50e5eb33ed9bd951fc11f7754932f0b1589b604ac9d2f86b2a80823b58871", + "python/sglang/srt/layers/attention/trtllm_mha_backend.py": "8790ae6905f9d4450f31a6d63299599bcdf65519b93582ff83468da1f09e5054", + "python/sglang/srt/layers/attention/trtllm_mla_backend.py": "a085dc46dd51e832da65a5a8a0d4339ee7c342bdaf7beec781ed7704bcf2133d", + "python/sglang/srt/layers/attention/unified_mem_hooks.py": "a28e90da52dc0c018eb463486abe61509e40460fe85617b3baecfb44a9fe3013", + "python/sglang/srt/layers/attention/verify_mask.py": "e1117a20ca18ab58fe2246a8a29a37fa722d29f797be4658ccf5bfcc1de6e822", + "python/sglang/srt/layers/attention/vision.py": "db8a8d1b81e6274bc71ec96730799031be9cbbda4d33d565ebcb7131e3d044e5", + "python/sglang/srt/layers/attention/vision_utils.py": "13f18a790d2a6c6b9c4b595fa21aad72e9a61ca69d040835d89e600e8d5b9c64", + "python/sglang/srt/layers/attention/wave_backend.py": "a8abae555ead59fe9ecc2ceee687f64d81b74cf068c7816a283b07da908ff23b", + "python/sglang/srt/layers/attention/wave_ops/decode_attention.py": "a093411b9edcc92831b6625ed4c484b1928e2103979c7d225407053ba0d45af6", + "python/sglang/srt/layers/attention/wave_ops/extend_attention.py": "2f2650408bc561f70870e6e0cbfb444cae49c512e0024398945f8a8467061280", + "python/sglang/srt/layers/attention/wave_ops/prefill_attention.py": "76864c1a71632a4ba6629817b204e0eace71fbb90964ea891f0a9e73b4b0c33a", + "python/sglang/srt/layers/attention/xpu_backend.py": "23dd825db34a51db6135992ac4aeabd916ede09b7fef3f8a3b418fe6cbd34a29", + "python/sglang/srt/layers/attn_residual.py": "bd88b41dce435afbd16c230c2365b6fd7f5f5b2669a5cc8fb8976373dc7e6213", + "python/sglang/srt/layers/aux_hidden_states.py": "a3e5218d5d3dd04703385fa8b9dc52ae753731185925d597b2c2a84f69a18fd2", + "python/sglang/srt/layers/clippable_linear.py": "d1d39d6260ec27aff5ca270e8971853f9eb63bddfbca4baad36ce6d9a739d44d", + "python/sglang/srt/layers/communicator.py": "7305647bba46a6cfac7b1eef10a0c4f4ca89e802cd4a1d045774e8e47db0481f", + "python/sglang/srt/layers/communicator_dsa_cp.py": "b1c011dce9ec8b7d2811d5a9e36aac1cf95cbcee064faa4e98b82e5c75c1b1ae", + "python/sglang/srt/layers/conv.py": "f29a48009e55941c23612d3cf3be2114772d56c052fba70f812b06fe6b61d03f", + "python/sglang/srt/layers/cp/__init__.py": "fef93024570eebcfb78444c297d309267fbc830ea9f6d5bd9838c63641bda1b2", + "python/sglang/srt/layers/cp/base.py": "81ac37624ecdbbfc8de587a51fff1c7274e1dc250c167a68c8f37f98d343dd91", + "python/sglang/srt/layers/cp/bcg.py": "cf2c17500ceac68af2dedf0faa841cd1c58d7f44f0441ca818149b95de201b9b", + "python/sglang/srt/layers/cp/cp_decode_attn_tp.py": "779c506f8c7a5e7f862d94808ab8a3b3ab74555cff86cc7201b787de19f538c0", + "python/sglang/srt/layers/cp/interleave.py": "58b03b4361bdb71cf8e85ee9f6f4d07b6c1d51abb52e01e0ce6e20ba1ea8a2d0", + "python/sglang/srt/layers/cp/padding.py": "9aea07f3de7ded66d7a53c78d6574db4e80eb12be7700cea3bad33edeef7220b", + "python/sglang/srt/layers/cp/utils.py": "7cf1c1d05c999fe570fe297f899a147ef20b118f052df49ec530de27d8facb25", + "python/sglang/srt/layers/cp/zigzag.py": "2dee99c67a48f36dba355566265350ed86b141bc2937b0163d8544ef9bd896d3", + "python/sglang/srt/layers/dcp/__init__.py": "78c69e70f2bf0f7423bd8d4a77127266066c08e674adc949f5b317e3e1bfd97c", + "python/sglang/srt/layers/dcp/comm.py": "26eb9e95396c41bc8cd9bdd403241d62c2983837f32f528d9b2387b7fd97869a", + "python/sglang/srt/layers/dcp/layout.py": "5b923260c3b187d8e44bdcfff62ddb02ac7c4b5f49eb71704cb31fab478fabe8", + "python/sglang/srt/layers/dcp/metadata.py": "4dd11b8579b6501aade57fbfb17f54e90af5bbea2ee9680b5e08bf7fb36b8b6a", + "python/sglang/srt/layers/dcp/planner.py": "44bb3013fccf1830673197ee423fa5df2f024a26f1fce5d51435115d1a27419d", + "python/sglang/srt/layers/deep_gemm_wrapper/__init__.py": "7ac24c77462e8faf2de9060ea66205ba258fd89d9dc53302e1b441347d1793a2", + "python/sglang/srt/layers/deep_gemm_wrapper/compile_utils.py": "c021900fe72b46c54fddb3697172e0f4262efcc946e0824cf23093b17027dc74", + "python/sglang/srt/layers/deep_gemm_wrapper/configurer.py": "5ffe5079bbd081d1d24379897f3a750d0ca2caf74b27533b1a00a038fe64cd55", + "python/sglang/srt/layers/deep_gemm_wrapper/entrypoint.py": "b0ddb397f969ec96d0e0b183bec6d6f03c1bce98a8e416edbe09400dec854bf7", + "python/sglang/srt/layers/dp_attention.py": "3b93b699766e9c285885c7e0caf3ffc9db437d70ea2accdaaac1c7ab1681adff", + "python/sglang/srt/layers/flashinfer_comm_fusion.py": "0f2421dd9272f37343d541335007c18383e352ecb2bfcce544cec9e094dad08a", + "python/sglang/srt/layers/hc_mix_triton.py": "da86f494b04236bd897ff43d282125cc54ea77b9fefa56bdc8d54643761265aa", + "python/sglang/srt/layers/hyperconnection.py": "8bdc97375d53e25d9ed819f295bd6002d9937625df30a51e76161705abc7c35d", + "python/sglang/srt/layers/int4fp8_utils.py": "3d3268e58de63a4c211846c32e65b58df0c2933105ab153c219157be3a15c5b4", + "python/sglang/srt/layers/k3_ar_fusion.py": "23a80dcf59440e272b8dec0af1dba482ea0d7a95b19e1891f33612cf113dba09", + "python/sglang/srt/layers/k3_gemm_ar.py": "50db68e017eeec976b54fb314eb85156f9a4d92bb779b1dc2c4abfab5eb205d4", + "python/sglang/srt/layers/k3_sp_collective.py": "44fcd8e0a34a2f180960749126641bdc18c3aba4ae1256d923c295bdd0f000a1", + "python/sglang/srt/layers/layernorm.py": "5f4732b11e072352ec9341ecd68af86567e2a33e75705461b98d93e914f346a6", + "python/sglang/srt/layers/linear.py": "a18935ab61c7340b30464ceaede64f4474551f07ac06a10bfd3c751f0a4d110f", + "python/sglang/srt/layers/logits_processor.py": "b8698de7d00f2d8cc868d8be5d76cedac5317aa93ce1d3d21731be367d1da527", + "python/sglang/srt/layers/logprob_processor.py": "9e0258d52dab060cd4c7065cd6bfa7e6dfe710c508e09b5351a4d5aefa3bac4d", + "python/sglang/srt/layers/logsumexp.py": "43cf9edc381dfe0fd7b86b71dc8ce2b94542fbf2dbbe4ba319d51d79327f0482", + "python/sglang/srt/layers/model_parallel.py": "ec233594a2e12e3de1fc84f863f15a6f5812fbf96b2a218d520cd0dde632b65b", + "python/sglang/srt/layers/modelopt_utils.py": "01b862c26bb554ea1278f256cad805c51c3feaa4ed376aea4fad433c36e8088c", + "python/sglang/srt/layers/moe/__init__.py": "7df9aea0d7c8d2af91641597051f203596cca3e9264a5a107b5a8c26043cfa1d", + "python/sglang/srt/layers/moe/cutlass_moe.py": "2a070a9e6a9f841830894e2c9bffe37d3c87547ec411a99effb5ece039bac2a7", + "python/sglang/srt/layers/moe/cutlass_moe_params.py": "3268018db84bb5dc1623e1b77fe66d2f2b972a1f639a65ae4523a016373e36c3", + "python/sglang/srt/layers/moe/cutlass_w4a8_moe.py": "6be270292282d2fddbb061b06891a726689495da01140a07186fbfc07f351245", + "python/sglang/srt/layers/moe/dwdp/__init__.py": "fda1aff0944af821a5b874b672b446c24a1481ede5b3a453fd4dafd8a08a46bc", + "python/sglang/srt/layers/moe/dwdp/dwdp_manager.py": "d5464b78f28a95b015fab09d932d93250a13a5f34bfcc2d09c55f093c6a74954", + "python/sglang/srt/layers/moe/dwdp/layout.py": "ddfb483885b76c13696bb918038238b368a9927ed96a5376efe899c3a4dc0601", + "python/sglang/srt/layers/moe/dwdp/page_pool.py": "bb8354fca363240be2b1ba76611929d854884fed49606220ae591ae7cea73a1f", + "python/sglang/srt/layers/moe/dwdp/transport.py": "91e17306782a07af849e56f1cfa3d3ffe40e31a8e39362877f66be07aae9aab4", + "python/sglang/srt/layers/moe/dwdp/weight_buffer.py": "59159a7462bde5e347c1b6185ffd119574b427ed20ce5d089efa07054164bbf5", + "python/sglang/srt/layers/moe/dwdp/weight_manager.py": "5e9894e21c179d23df878aa51d3abb5ed39cad4f7bb64c51a27adc139e3661fd", + "python/sglang/srt/layers/moe/ep_moe/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/moe/ep_moe/layer.py": "ff3480f06c3baee391190023a3040c39b970ae890d908c42a00f3c599d2e484a", + "python/sglang/srt/layers/moe/flashinfer_cutedsl_moe.py": "3a153a26287d4e30e82585a9bf1304070635bc0982adee701fc204048b2aebed", + "python/sglang/srt/layers/moe/flashinfer_trtllm_moe.py": "7f5a729870d540ab4f81599e1f59fbe72d8b95d03119bc46f37eb48068c6fa5b", + "python/sglang/srt/layers/moe/fused_moe_native.py": "abfafce66f9bc4565a7aab73a40394d9bc4e042bcf477d5f408553c94a27e498", + "python/sglang/srt/layers/moe/fused_moe_triton/__init__.py": "be2cc3fbe561df1d6eef6eaac65238eeecece81c00f85dc8b5cd1cb504c7d1fc", + "python/sglang/srt/layers/moe/fused_moe_triton/fused_marlin_moe.py": "fab293ee5aaa0d285d161c3bbf23606d2908fe3273eae5f32eb5b49db52f81e4", + "python/sglang/srt/layers/moe/fused_moe_triton/layer.py": "dcb2620e96f23e1004e1439914a807e74293d3c1080db929f9aa542e742e5f05", + "python/sglang/srt/layers/moe/fused_moe_triton/triton_kernels_moe.py": "9eb4b8507b0789db1cb198087a256db28cac913bce36785342428c137ec11882", + "python/sglang/srt/layers/moe/hash_topk.py": "46e637193155824260574ddb085eedb9981298cb1a050ebac62507e6e999f3d2", + "python/sglang/srt/layers/moe/kt_ep_wrapper.py": "639ee63f05ea9767ad267d6d86d9f1b9cecdbbc2970611271e2b771b7bdfdefb", + "python/sglang/srt/layers/moe/mega_moe.py": "fb299d42fae12c78c04cb1760806196f47933b74f0a552826967b77902b0d012", + "python/sglang/srt/layers/moe/mega_moe_sm90.py": "70e8782065a5958eff4a3bbd6986b2a02a8515aab34993d741f8a56658b31e8e", + "python/sglang/srt/layers/moe/moe_runner/__init__.py": "0dce0f1fa1dfcd00e32562fb8ae67ed2a87ca11bbb3ad9c7e88125ebbe696225", + "python/sglang/srt/layers/moe/moe_runner/aiter.py": "459671709b8b7a36ab246f0d0846450b6f6b607de4a17e34831da9e19ce64641", + "python/sglang/srt/layers/moe/moe_runner/ascend.py": "00782903e91d3d9bc17346e15ab950e416a29b609ceaec19b4743c6b5dbb9e51", + "python/sglang/srt/layers/moe/moe_runner/base.py": "66dc391ebd36cf524c058c7ada8bcf32e5fbc446faebf4f672ca6ddcd4f18bd3", + "python/sglang/srt/layers/moe/moe_runner/deep_gemm.py": "c46be8b94401e3ef2619da100688e193b4d352d2e5493e4d7697dd4a92fcf3d6", + "python/sglang/srt/layers/moe/moe_runner/flashinfer_cutedsl.py": "cca94d12d5a062e59582f42b5afa842b72ca1b2baf60367b5542d09f5606da53", + "python/sglang/srt/layers/moe/moe_runner/flashinfer_cutlass.py": "655f7170a7898d28a3c0f539e4f5a2b419509803cd34e32590fff04fb02cf1ad", + "python/sglang/srt/layers/moe/moe_runner/flashinfer_trtllm.py": "b7229908c6ac61f0d78fb82aa77a20077dcbeef72df67e19711d285d495044a8", + "python/sglang/srt/layers/moe/moe_runner/hpc_ops.py": "c138600761d1aefa039eb1048f94fcfe7e6ecc7e7df02f55390aee9ac569f16f", + "python/sglang/srt/layers/moe/moe_runner/humming.py": "57bd948627238de937ad0394f59e40a8b49e6eca91e62c74880df19e0ff847b6", + "python/sglang/srt/layers/moe/moe_runner/marlin.py": "e1db2b78559fd7ed482710f0b95104339ebcd41721a3cb85e17fbc63ab683734", + "python/sglang/srt/layers/moe/moe_runner/runner.py": "46eace8bba47c7f207a264f94b3970ce693657e6cb383f0afc0ea25fb54f2bc5", + "python/sglang/srt/layers/moe/moe_runner/triton.py": "f2d0957311876f2e1c405c5bf18fe105754a32700693a7b83551a075a0dcf475", + "python/sglang/srt/layers/moe/moe_runner/triton_kernels.py": "0f515ee1673e3d4f2e5586c891680ac33971c112b3a5a7f7b52ccabd25b4e84b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/__init__.py": "17001b79d53924601d242d37aa2ba0b144002f02a5b6f1a75e168d97e508829d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/README.md": "6e075121eaff9bfb859498a86bf46cc009b9f3f6a8cc8f0308f959e4bfcdd0ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_sm_100.json": "0d997c67fe7e4b741fbfebae8cc3b88c8f1a4363027409d09d695a77e3000b3e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_sm_90.json": "ccc12031249f4a84a4c534a09217e2846773edf1605c386e9d6dc1473d2768fc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_sm_95.json": "ccc12031249f4a84a4c534a09217e2846773edf1605c386e9d6dc1473d2768fc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_with_prefix_sm_100.json": "ca44d18f28dd39b40ff08052787ec4ea25c994dfe643640f4319aed2a3c0317e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_with_prefix_sm_90.json": "ed8bc5dc1c239ce71fcfc96234612f8efe91025718a4ca9aa0b5490f85a7c323", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_with_prefix_sm_95.json": "6d6dd15bc98773d1f2597c1b683c2a710fb52d092d6c5fb7bd273790217dc9bb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/minimax_m3_gfx950_mxfp8_compact_moe.json": "f08a7280b6fee5aa64b615b007fdd26b344a2958b22023206d0766801a8d68c3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=14336,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "88d1ac13665e5674049cde00f1427d26fd1dde16d1176309f680608eea794b39", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=14336,device_name=NVIDIA_A100-SXM4-80GB.json": "24937486bcb22ebe59bf77524bb0bc70f1610304d3e97c54567046319bd5e890", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=1792,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "a2e4726793c430f3f69e33dfb42361b3ed60d72eb0b9e58b9a123b1b54a35759", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json": "75de1a419d5a7d7684192dd9507df561cde6696853e0beb59b6d904f18ea066f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3072,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "f062d9cce5493697ce5d731068cb6f7294080b33c6de30cd011bc7e0fc475feb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3072,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json": "b3eeea043c7f277985bb4f4d935e1956c786797e463cd452b508e8851098b7a9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3072,device_name=NVIDIA_H100_80GB_HBM3.json": "ca9c6c1feeb6330d9377a23c93a2bc039d83f4e46c52dc1c053861cfe87b7f62", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3584,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "d99dbb68a75a038571aad20293e7ede527351ea452f3b98ddabcbb7178420fd8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json": "c9fdf76265a55528e3ca0d10e0e3005af73d823471bedb4cad005410e7cf9782", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "6563029583759a855150fd9fd2161a737f1d8bfa54819820ca5f5dd83e6b9e87", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json": "0bae50d8cbf52f1150fea0e7bf5d4867d9f097bb06668ef69d60df94cb6dbb88", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=144,N=512,device_name=NVIDIA_H100_80GB_HBM3.json": "a64e95642861d98d02b094b38ed5213a796d6b540b4d4116cb7dda290538ed76", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1024,device_name=NVIDIA_H100_80GB_HBM3.json": "1a6936e2173995521f42da926b9c0b39c58a79d30df1a6547bddc3061e89d406", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1024,device_name=NVIDIA_H200.json": "b98fd730fa26697317c4891347872d53f61bae2fe332fd95bc2715f9fe8efdbc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1344,device_name=NVIDIA_A100-SXM4-40GB.json": "a4208a91d533cee055b658f293b0042006de0dfd760d48a279768e0d95f39b91", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1344,device_name=NVIDIA_A100-SXM4-80GB.json": "b6b5f6f9ce0dea14d30facc5362e80d9b4f71648712a390cdab3e5fa8d4af6cb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "238779eae0fb13524c5c3f51031ab715e6dd3eab83b2734491568863d0ad9bdc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=14336,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "b2a90f8b86ad54f026c7f43b2ae4eab2f8cb388a6727370beb241122f1ac252f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=14336,device_name=NVIDIA_A100-SXM4-80GB.json": "d1e8e09c843f9b32612a34299d3f88d558fdfab3df1a54dc43cbb471781e914c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1792,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "954e1f8e78099a9cce69f8bedffab4be3da92df6505556a016764da08f7b7ad9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json": "8a551fefa4e66ed68bdd6d1b6ab6ba248044895fe23c8b36f548cb6c7fc662d7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=2048,device_name=NVIDIA_H100_80GB_HBM3.json": "e327b555a908233ac6513c4635bfc3339bf9f5d8cb82893c49e05e53f608e86a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=2688,device_name=NVIDIA_A100-SXM4-80GB.json": "1b83caa96c61d0c941860ed01ca8f49befbf7cfdcb97482ced525a7a0f8d2033", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "6ca5fd02f73137a93e8b745498749c859677ae3a184586f8881aa1088e0bdcc6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3072,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "39e25408f5410f5cfd092a28669cb7851c806ac8caa850106932dc58ae8f5a7a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3072,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json": "3a2117bf19b9b6671bac4b52216952ebbc7ee21f7a803837d4bdec3e34a19c4a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3200,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "7065632b1df8009444d8b198fc95b0a704b9801a83f7f73d4f7c5ed2950c1fd8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3584,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "72ec3d1ed7b3e3a1a43c1f133ed0838891a1192a407ea038f9498bcb7d961c5b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json": "168d609459df9d840ea8dbe4f0a6aed963fdd223bacd3677ea21bd32b95b3d4f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=6400,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "c4e423f72f4240544244167c1bd447330d373eb08dc9ba5c5d1539b0c13ce3e6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "d58b056b9203d234c7231386a64b7c55e0f3845f4ba720137d0af2fe29120d5c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json": "14656fb2fc36dc378314b8fb4cdaa6e34d9f02d89bd9c3c645947778f05e529e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json": "9249607f6a8b239090622249e5ef46c71da001f1b17323036297499c85cf57c1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=800,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "f1ed2d37f0c73f0be1fc7102547c7da0e17fe1659d6a1b78b3a36677f2be6815", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=160,N=192,device_name=NVIDIA_A800-SXM4-80GB.json": "7d1cca7d5148727c6abba0ef18940d96db854511b3f05f9e68bef76c8cc1ce8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=20,N=2048,device_name=NVIDIA_H100_80GB_HBM3.json": "cead71dcac19dd8bb3138d8e3cfb049574ff552f6c2b5df909d07546ca2d2d4e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=24,N=1024,device_name=NVIDIA_H100_80GB_HBM3.json": "9496c46bb56c05528bfe24681e7881fb69dc78cacf72d92ab632acccf9d7e299", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "46e5032bd5df817b3579911259047d6dae2dbbeac2446fd4098c23689e7af2c2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8.json": "c250a2f5aa18a7b65cd464e112eb6f5836ec7b490a9cd69080526c77f2fc6ded", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b4f6317a8ff150e92342b64c75ff6fe08685af0d1119a64d2c62c93ce86313f8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "316ecaccd6bb0dc2a6e77bb6261fa69dbf7703720279f8101e474a38d24c7dec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "d1a498ce9bff701025a5608fadf1a035309f69ed4a74a4274f9e84f1715097b0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_H20,block_shape=[128, 128].json": "2443978f8f29870a2e999581c0dabd4e9ab157022b6e77e8b7841f01dcef2c92", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "2eaa26fd53083ddb9265365075e2f65a5ff1debf6ae91988f5ba2326b630419e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "5e628568c85eabb34daecbd8089b5eba5d30f34f65fe5e3ad19883402f53a06b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e6ba3d3bc35ffbb301f0d182437415e6407693789259ed2b753cf60385bbd820", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e6ba3d3bc35ffbb301f0d182437415e6407693789259ed2b753cf60385bbd820", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "db7089bf775ed540d7dc476e329ca50fd000f2a2f99333128cb2b818332a96ba", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "20c4ca9cf463852a6d7fbb26224a6a98c8d230bf5243b23c0a991b477227cea9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "c89cc75fc9cd5a72b08fd33cdbcd5dc303e1387434dfd981a6f3601bba68cb74", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4780769f6bc6b78a4fa3a8d2e019a7c7c018b5c7c5f6a4091396c3ece8665c7b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=64,device_name=NVIDIA_A800-SXM4-80GB.json": "6385a99951a5184447a1ea10346910f860be32c12d31b96a9c056e0db01125dc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=64,device_name=NVIDIA_L20,dtype=int8_w8a8.json": "45491df5f5bd59b6a317f7c5233a69b04d6ac96191e5a442e02967f813ddbb6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=64,device_name=NVIDIA_L40S,dtype=int8_w8a8.json": "49cf712b5c2d454a88cd7a696eeb5cabe6367bd3340d9976386573cc1d1a42e2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "4c1b1caf5b96c2963416b290e58dc43bf420e88f7bbb87ffce39d646fa1e2ef1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_A100-SXM4-80GB.json": "e903cb859bab22a70c55dcb7c340ddee02d588ac6cc89441cfea9df1a8298ba4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_A800-SXM4-80GB.json": "baff91c133594f69f6eb874ba38796c54a41de0ed0a94c9fd8c1441a246fa2a4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "5db09120e9a236a54a87cf69fb4531befb2920d443035895f377fd979c8e4700", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H100_80GB_HBM3.json": "e2e4278c63d6a24b1caf18970c8bdec4e03c3a42b9be4a08ba59afbcc1481288", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "8b90178f6ea6588fb11283a72c26435d4cf3f239364630dc1ae6a24f541849b6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H200.json": "7c92a4e4b10cfcb4a7ab5c9cdde90ba807db516ccfa23400eb25f75e0485a3ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=2560,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "8895659c261334331be94d549d5e3a66e2fff0b7293affd715a61621e44578d0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=2560,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "29fbd2602306e3cbe745bdf977d58ec58c99ba523e441ad41975074315e2e219", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=2560,device_name=NVIDIA_H200.json": "eb4cae3a5bae93aabcf197b4b683c907c873301bc5ed95b2319a6b88c7507f78", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "0c0e0fac2bbf04d2d2596553c0e89c35f6f2a94356ec14d90b6772173f4355b5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H100_80GB_HBM3.json": "a6b8fe43175f4bd36ce5644fbda858fd3afb0b2aa569580d1cf4fcf524b9cf38", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "0148281cad4f98015e852366b1bc6e9e505dccce744399c5bdd9c6f4548e8cec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H200.json": "a42e5f76d105739695373a63fd1107873d503eb1af808f62402be5a1d0cfec9f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "c99ffa2a0c09bca3c66e5a5b1cf42f10c71473d17b1bd0349925c77e07f3b60a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_A100-SXM4-80GB.json": "a3138a143ae09b0d589a0c53b516b5ba87b7a74f729532eb923fe3393a8d8754", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_A800-SXM4-80GB.json": "6dfafbd2be8f98cf79c3bada69b40e68e3923e2c14d8e40239987e90a5c87a16", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_GeForce_RTX_4090,dtype=fp8_w8a8.json": "e20f650015099c1fa25705df60f61c234e5714f1b88d8f28d322542bb9123d93", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "4462eaac01af3c2159d2330f0422744eab27ad2756f846d469266eeb571618df", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H100_80GB_HBM3.json": "b231153d54e0500969e2cf2d64b192c9e3736d6eb34ed526d888a81f79d9b088", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "783dd8f6c3b01c572055d39fc9af0ac4f86f2f1fdbe3085f1169b877c6361d6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H200.json": "2887e9672752977d45384aaad0405fc53c96463d504c3c138e43c716334edff0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=AMD_Instinct_MI300X.json": "1e1dec7c1391e63dc7cfd3b6ca83b0e7a03c28061969ba964ebd6e5de9b8befb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=AMD_Instinct_MI325X.json": "1e1dec7c1391e63dc7cfd3b6ca83b0e7a03c28061969ba964ebd6e5de9b8befb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=AMD_Radeon_Graphics.json": "1e1dec7c1391e63dc7cfd3b6ca83b0e7a03c28061969ba964ebd6e5de9b8befb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "57fb200ed12d184b81b0655ad266982478611aa7b5344ee5fb57a4d9e77d58ff", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "2c3e19e4c451e48be2e1b601e61320ca6b6f985c95270aba8267a103b7f379c7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=NVIDIA_H200.json": "18b207e1e820fa913e3565395ea2ae242a115dc88737a19273735a1383da7988", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=AMD_Instinct_MI300X.json": "cdc36f5f25af79605e7ee093be222d7679050148b7a2edf43c7a6492dc287503", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=AMD_Instinct_MI325X.json": "cdc36f5f25af79605e7ee093be222d7679050148b7a2edf43c7a6492dc287503", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=AMD_Radeon_Graphics.json": "cdc36f5f25af79605e7ee093be222d7679050148b7a2edf43c7a6492dc287503", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_A100-SXM4-40GB.json": "01f7c3734ff9d4c2fc1e2037ef9ef36c3d744d925d52c50321822a3b8834c94c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json": "204601363b7d1c69f3a0e5525af2f40348d4aaaf76e900f4fc1bd5611e110356", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_H100_80GB_HBM3.json": "36cf58d766996c99c585c1b79f06faedb0eaaa2400a3db5d4c021ef0ad808f3e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "a1b36d1e5aacea5e8406a1a6d1ed130f6c11f53628415fcdf58ee89bce3b5899", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_H200.json": "8eec4961e59814778b6fef37fc80e0ac7129a1e484babb235c3e379931c174b1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_A100-SXM4-80GB.json": "1cec5698223689f1e659cd28af6cbc9c47a7f3a8c378b0e8bf5fadb8ccee871a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "72c1dece1d0719668dc2b6e51b3320704f7986a6ea8d64bc1c898b44962bfedb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H100_80GB_HBM3.json": "ff9c1e2c18a74020f3c95ef98472884fde58d1c7bde0a59fb76ff9042e8491b4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "e0ee1578ca6014daea5b25aa5a06207180200509ce9405efb76e824525cafac6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H200.json": "a9f8db5ea6e5f74d93ba2cb3ce8994cb6b0cbecf83b9df19a610d16395883c13", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=AMD_Instinct_MI300X.json": "667b25bd3e8796371a9d6c188c5f27b61c2aaff878b63c9bff010b05d7060f8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=AMD_Instinct_MI325X.json": "667b25bd3e8796371a9d6c188c5f27b61c2aaff878b63c9bff010b05d7060f8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=AMD_Radeon_Graphics.json": "667b25bd3e8796371a9d6c188c5f27b61c2aaff878b63c9bff010b05d7060f8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_A100-SXM4-40GB.json": "46ee3ad1982750fe14f0eb097f017c9fe008fa07dca25351dffab3a311ba0ed6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json": "2ba046acac3fa074c0b478ec66575c8e9f8150cd5d21e70a5ebad19fd3a9446b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_GeForce_RTX_4090,dtype=fp8_w8a8.json": "e10ffec884cc7e28ce32882e50cda7f7a72501187e0d416c4bee285bf6b72697", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "aaa16831a39bb8ef291567126fdab4c18b1d0b879208eec1fbfaee42147537d3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H100_80GB_HBM3.json": "fb99e42c8ba78c6d6084fa1412db76017110c3da068a294fecadd4bd0bfd0aa1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "0578d254676f80fffeef14ef6c738ee99ad759ed2a4978900a1c681c68162fba", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H200.json": "3e2d9ca0994996982a5e23d177bec1fde0a69a2eec09d06ea1218ad5103960ef", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_L40S.json": "a76aa54614edee8c1607c91e126a02acf669a37f48031b0a9d42c543b477f122", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json": "85d598a640567c6f64c1461ca3554d8f053f4bae42a1ab75bb37c4265df751f6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json": "85d598a640567c6f64c1461ca3554d8f053f4bae42a1ab75bb37c4265df751f6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8.json": "85d598a640567c6f64c1461ca3554d8f053f4bae42a1ab75bb37c4265df751f6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_A100-SXM4-80GB.json": "0f162ef2b7a064e485bbcba014603f41bc162b883cc70414645f5afe7358e02b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "a1bcdf13ff5782c6c535f0bd6e260e1f147e57f06073b3ca4fca996496a22497", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H100_80GB_HBM3.json": "ab02b2f2868cb1ddd0ad78106ccff1f7171f6221cafcebb5084c033cbe466e0a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "ad1f1bf8eb90df06ad6fc6f6cee365c4a0d2669ce501a826f676fe15d2a4b7bb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H200.json": "f06fd0a95fc386f67ac526af312a5e13aa9c5cf569b158c4b4969bc9dc9b2aa6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=AMD_Instinct_MI300X.json": "856e3cb7d27ba6d76d8a5e8c28c49f5d5f8743c11b6b748b3a049c36ec2c7928", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=AMD_Instinct_MI325X.json": "856e3cb7d27ba6d76d8a5e8c28c49f5d5f8743c11b6b748b3a049c36ec2c7928", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=AMD_Radeon_Graphics.json": "856e3cb7d27ba6d76d8a5e8c28c49f5d5f8743c11b6b748b3a049c36ec2c7928", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json": "0402675d36687b0c02b7324b50f274a18b802efeb8d0cbc3b8bb1e19cb1869ac", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "f938fb2264ba6450e87ffd154f2abb9159bc5c3f41e78443e8250e3d27f72638", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3.json": "b667b4c9d5b32317400592e4e2d53c1bf5f674951818664d910ccd19c99cbd47", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "dd841a9129942a1a70d4a3bb1e7fad11cfb2c83d5f123d35ffa2654989ebae52", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H200.json": "5b691afd4f29cf08f35fad8d106297477daeb9247fcdf1c3d578d761fe5b801b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json": "f91cd459220002c83a880fbc48f31aebc84fa41568532309b3774b3fb79d46ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json": "f91cd459220002c83a880fbc48f31aebc84fa41568532309b3774b3fb79d46ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8.json": "f91cd459220002c83a880fbc48f31aebc84fa41568532309b3774b3fb79d46ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "b18da758c3e1f65b089213c28e41cedb8e70a677c56eb1e6cdd7190d514f570c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "533e57f3455c34139ac6c87054d5048adb47936cea0781d009f4c9e133c6e5a3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_A800-SXM4-80GB.json": "4fefd3fa85b8aa98d3201686571ba4264b1113b620f26f47347809d97991dda2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_H100_80GB_HBM3.json": "237938d7a1db5d4feb61bf2c703f20008e1fb81944947974e8f337e3b41ad75c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_H20.json": "46057c0b81752ced3d874d58b2017f7aa5fa18da01b42eee94f7c945451b83f8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_H200.json": "9ec344b83364b34b552df41f226ef1c45c047a9b537d07286bd7c9cb4352f314", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H100_80GB_HBM3.json": "478801737b0c6394303ad706c0629d936024e14b146c17778c351e28a9343b55", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a9baa38ac278a0a99c633ba61cf464e54c8ecec762f09eb16acf365161cc7802", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H20.json": "bd2d834480cea96ca206f6c6e87ef8ea8c277e40f517c023d98674113f71965f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d67e57c99679b0a022f99d5db963a12d47ebea092f9cea6fc5f6ea213ea253fe", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H200.json": "c6a865ef8f22b7c195d8a5d7d178b18ad13fcb09ec2a4b2a2bc0062fbb40813f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=512,device_name=NVIDIA_H100_80GB_HBM3.json": "16c59b57843a03302d81e815b843410f3d9971226ca8d8b050855f41ba4fee14", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_A800-SXM4-80GB.json": "4f9ad724e658344b3fde113c837721f34d839f249b36222a767d2cd11949afc5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H100_80GB_HBM3.json": "f4be42f15712b2252be57af25c1d403b70e49e5010a30a7a0d4e92ece4b3100d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "22ebf20bc4cd84254099465f2d2a044ecc822ac99e8ca5ebb3fd33bb014b3c05", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H20.json": "d7436dbb66950f9bc62e89f1fa35b4a8dc3eb606567599b3306c7bbad0d57a78", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "a5d43546f5ef7560e7f18f3ef0c017def9fe4fec1bb6466f1d5f46659bcd8e77", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H200.json": "26b68cf8dbdb83957f4c991297a50f15864dd731c7a086ebda901c92c7a7a136", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=96,device_name=NVIDIA_H20.json": "26d7074653f3f3140402a27d11623ade862f7668d0146e954c7aadb7ce553920", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=129,N=352,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "2fc6d51dd3da07baf991c361a0478df9efc6167cfa39c05cf24db4e849e407b0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=160,N=320,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "65138dd97211459aef277b5b3ee43bfb41ea199fc590fa51377ca3d62b069a98", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=161,N=192,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "780d617f7b245c5ef21371f2dde0cc337b1b973c0fd877d35206be6223d79c96", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "b6d16e2f5aca9c4a52848b66946c8294e7e95302e2e5c65815a560a3b080c670", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "3dcdab8bea83072b257c3f0b809b5107d4035a323e2aa31e0397ed96d8b0cbc9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "baeb9af55ebed47dfc01230f43ad2ded43ad5742102d95810a5d77330436e52b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "7f43c0a3642bae37bb04f632a81db56b3f93872cb6cc286d0ed4df00591e9fe5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "0423be7148c01b5784f48ffd2e8892b47533f1d1106298e23f31ed4d75f22c5d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "ed89ad6972a7997f037589d427b59015aef18ebd98ba7f5621d40da027ff2b6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f2035a9a29fa3aa32243e2cc55ee32401a3d38d8a8882e25a1258f9ca712d572", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "dd9b7885b0b7c89c56bcfd13ecaf776003da50ff1f4353f55a4d021aab4181af", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3fc1a9551f1f8eb5fb3856c1045138cb8309e2e860a32515e0d6029b5aa15b19", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "e01d129b3450dbe3ec0497057bb9de33538a7d6a6c6e2638c7a73a08e40d32c4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "5f288e0ae7e102ee4108c1e85bdab880b49140419ddb66c99c9930d7932a1588", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "7f91d38bff5f5af227132269f2916069537a03dbf1bb7ffce3979264637d629a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=64,device_name=NVIDIA_A800-SXM4-80GB.json": "3e2c382cde9df1062b51a856b30dd750eb53303d68def1cfc00f78b06239e869", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=288,N=64,device_name=NVIDIA_A800-SXM4-80GB.json": "dd3f3fac5d8f1288e181333243c0ec71780909659d59f0cf8f8338df8cd6700e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3.json": "b667b4c9d5b32317400592e4e2d53c1bf5f674951818664d910ccd19c99cbd47", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_0/E=16,N=1024,device_name=NVIDIA_B200.json": "85ef3bddaa0ecbb29f160fae3284c557820fed89340e4ee6393b8b093ab06597", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=352,device_name=NVIDIA_RTX_6000_Ada_Generation,dtype=fp8_w8a8.json": "44c630aad07b85879a0b2b99d5f7959d18411a53788cc7263505f686a52a0659", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=384,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "2cdc755bf06c5997291e89a249c0916a9e3a755d3e17b4bfc371edb24a2a966f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a9ceea9c093705870fe66fde4fc20f0df9ef16b9e0fe4891092dfafd4cb5336a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=768,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "25f2d91d50bce19b075487612768c64fdaf666a186c41a88671e0746315ce27e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=768,device_name=NVIDIA_H20.json": "4f6b0d1d56422dbcae3baf197ae754cd0301b00433b36f9ea39dc8f84508b963", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "aea3d6a517daf6ced449af5c5321c054fe74598902a970c9cdf29986a93a187c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=320,device_name=NVIDIA_H20-3e.json": "716904a4daa7ca7d104bc1dc8168b0588d71aa1fd4f77fd2d64c8d79bebd68e7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=384,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "8c659f64d3f94f57a7f0a5f4ffde25aaa4ca4505c2fca92afe526bb58e2013c6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "9da2b0fb6a9bcb6c43ba96752e66ad7f6a3f0a86e476f152f15e8250e4562e92", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "396dd6d36f4e6e6e07a22bb165b6e34c3c13508199e10afdcc3b2e99873d9bb9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3f46edcf1e4aa2b0a7a94c58cdbb9b21f5217dabe36b6f1dfbba447625c8d138", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "7e8d5a902b86a2a706c1081f879ea1029820fb02d77e8f641c792c13fea6d45e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a07e1b0a48c17bd3e1bea7dda939750e79e1f791da3d3e375438b3ed58e43140", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "31e50b5d6c8defdae8b124c9a7740e0e613fc844070a470322f01537758e4816", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "573d60f98b5359cbf9ef7118691ecbce1265472a2768cb073d3d8c323b9127d9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=384,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "10d0d89c2d658cf3690d51dd9aa47b51b803593d483ffe7964843f39a7b7e262", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=384,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e5402cf19d66cb0f05fb9158d871d677958c4f68a2f57f9a6086247f716c03cb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=384,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "f78d595c9b62f7dfc651e8b29703d45aa60af1be78f31b8d223bf4a73f4a72a8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=385,N=128,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "ae017e2920145e623b406ae1314cb03d57de4f1cff8fcfc83f837ee9b91875a9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=385,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "eda6a88b4308db10b964991f9644d9007e2d6b04cf76652999c04e80e2272b1b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3.json": "6bd5c96745ee7544de6c074de60b95abedd74af65eb472118dab4ed7eff4c429", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "258d7cdf6b08b753085846687ca998a1d2cdcd537877b3553a2d26181b8a1293", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=1856,device_name=NVIDIA_L40S.json": "843c6b9bb214a1997d01747740eddda05098b2b4c7ddefbba71d94c8cf692680", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "f8c65a67847daf9464f1af4e11ad5e33f4ba20d95cb17ebc063e7fa4ce006b45", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=352,device_name=NVIDIA_RTX_5880_Ada_Generation,dtype=fp8_w8a8.json": "2fb69c50c0e661939e03eae211db35fabf56b2ad8a0562651bb5fbae29568df0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=384,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e896063788a6c3322b4001206e848ef77c16601ba0bb34e00637d379dab673f4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=928,device_name=NVIDIA_L40S.json": "6cc134108aa31e1522de15ccf3a4af402d03a89beaa88079fab1625548ebc84d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=129,N=352,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "0a53e8808366e40b278c3ab1e87cffac7ae69e709d50f89dfa3608748823671b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=129,N=352,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition,dtype=fp8_w8a8.json": "44c630aad07b85879a0b2b99d5f7959d18411a53788cc7263505f686a52a0659", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=129,N=704,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "5bc0b51ad3f82b8dd22bdd76f14e760c3e565a87ef3e5780244e2eb36423bb59", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=160,N=384,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "1d197aeebf7c2724576f64a45d418c54a01c44c6f1f4c22b245a7c3b54969e83", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=161,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "eda579fbd27b541c3a7a0909c82f86babc3904f4dc86c6eba27b351286db89d6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=161,N=384,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition,dtype=fp8_w8a8.json": "44c630aad07b85879a0b2b99d5f7959d18411a53788cc7263505f686a52a0659", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4fa902b42532b42c625bc24e2df105dd881d083f7f98a71c27ce48a93d1bf0b5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=256,device_name=NVIDIA_B200.json": "3642d5722e6ed8619eb856c2dddffa3e27014b7992b95efb2480824b353ff1c7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=256,device_name=NVIDIA_H800,dtype=fp8_w8a8,block_shape=[128, 128].json": "3375b539053a46028040bd84a188af00889db73d5cbe0a0aebfea7b4d7e7fe56", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=512,device_name=NVIDIA_B200.json": "b9c517c01b040e35f23045446034eb038e567d63937dda68d7d6d36f2bffbd97", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=512,device_name=NVIDIA_H20.json": "6d27be294c22553df233d8d0b979439b17bf2947edec5527e7339bcbc6e94a47", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "45b2584d17e33ffdfecad7e3e775bfc368c5a59f71c0c6aaa0a5b9da99203f77", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "85a3ac0b17e396eabc44828e2b5bc4d13bab121c7659a0759c7e0a75d8d198c6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "6815bbd1e8ee6c9ec9101a7d434c1a4c9e60fda243b5629dd9c93a56d3061a14", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=64,device_name=NVIDIA_A100-SXM4-80GB.json": "40493c6c4f8689e665b538afde283ffd270cf50ff82be73be54cc8b83ac698f0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=384,N=128,device_name=,dtype=int4_w4a16.json": "739e5a0ae85eaa88a123ca9f32ffe800300c7bc8adcc2e5d63f4eb7b98908159", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=384,N=128,device_name=,dtype=int4_w4a16_down.json": "739e5a0ae85eaa88a123ca9f32ffe800300c7bc8adcc2e5d63f4eb7b98908159", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=384,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "1449e3bafbe4cbe72f5b58aaf133eb7c638e1fccb8ace131e23958678b6a6c3b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H100_80GB_HBM3.json": "254ceaeaf273380570dd5397cc28c1a5a2e97f93b13d09a8da224f263ccc9baa", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H20-3e.json": "6ab4d7b0b91ae315a408444d05ac911ea7e1c2bb6a75dfd8872f92ce25554d96", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H200.json": "1d11895aacb5082ee8b9163a7bfb770bcdf608cd01225434668ea7a1fcc17fc9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H800,dtype=fp8_w8a8,block_shape=[128, 128].json": "d8f289e3e98bc55583826f3526d923469cf598a710ced19d991f3822d94c59f4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=256,device_name=NVIDIA_B200.json": "3dbb49d1d256600058923a0dffabefb124606c690dbc614d8d04f7f2a89dd7ee", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=256,device_name=NVIDIA_H20-3e.json": "de839016c6ce8de8c7ff341a31894a52d43a4a7c481f9fdfdd421a15f4a573c5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=256,device_name=NVIDIA_H200.json": "9a688d50d15a8e56128c55cbd03332912e88f83d4ff004177510697820110fed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=64,device_name=NVIDIA_H100_80GB_HBM3.json": "15e4402a415497788c94d041adbfd8a1ee0eb16caf49b56de7ec265c48cb6c54", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=64,device_name=NVIDIA_H200.json": "a619a1910373f0370b1cfa8de6d8e626a3a06d7d01850c7d70ff367e9fe3c884", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "d7cd2d02c8485903be9d7748a6ce5e59d4aeafd3b09b2bbcf4dd2d895aebef94", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8_down.json": "d7cd2d02c8485903be9d7748a6ce5e59d4aeafd3b09b2bbcf4dd2d895aebef94", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1344,device_name=NVIDIA_B200.json": "e148af672111c72e10ed900eb91dd7b03685283aaaa740057950934208d24954", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "65d860614936717d909f85778998708a4fd23bfb5976077d52fe4efc2c0cb020", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1856,device_name=NVIDIA_B200.json": "4436c2bfbc22853263ca73e1b9092952da06843df216bbdd827dc8ba37f7da1f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "21aabda50ed3348325e25327464f6a33ffb470415142c2a947b388fbd3b09809", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=232,device_name=NVIDIA_B200.json": "7fc486f6f8c7f14312bf3bbe898eec9241c503cfbcc92d7cbf68732775b36867", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=232,device_name=NVIDIA_H100_80GB_HBM3.json": "ccf4a3dd1c6354ffd4b3c4d30b33d7412677af7a851faf2e216fc61be21b6eb3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=2688,device_name=NVIDIA_B200.json": "b0fda1dc65b4fe6feaba18551749b13e7ce63e96658f18def48cc7e915a5bf04", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "bc7efd575e2ad3223f03fc7442899e976904e3cbbd206764a911392b693cbe0b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=352,device_name=NVIDIA_B200.json": "ffed937219bf96ea7012abc427d8baa0ac920653bfd6954e9f65be2e23bfbcb4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=352,device_name=NVIDIA_H100_80GB_HBM3.json": "23df74db06dc672a8c400b16b52a8f58002284ffed6d6b96a013d0e2089c78cd", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=464,device_name=NVIDIA_B200.json": "d2dc681e2eb9b7cd90de9452a13a46b0ead362e957837986dbdd83ca16f0d3de", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=464,device_name=NVIDIA_H100_80GB_HBM3.json": "1ab05dd5e86a8231f9aaea486aaabbb7c8cba1a75cebe65a7d40b66300684ffe", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=704,device_name=NVIDIA_B200.json": "7bac882743da5749cfb1c826897965f325f1b8a9a666a8b5b5a5e362aebcf552", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=704,device_name=NVIDIA_H100_80GB_HBM3.json": "e0f0cd1a8fdda9b6176b5a07aac0a7030d5992edbba43e111b0c4231bcd6d7a4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=928,device_name=NVIDIA_B200.json": "ddd675749dd4da25bdf7b776d7bd0a79ccc0a5fbe8f6c9754924456ed8ba8a2b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=928,device_name=NVIDIA_H100_80GB_HBM3.json": "952ee3f7049513b4053db9b4549d1e5d8bce3a50139d526bc63e27c7e42d7304", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=16,N=1856,device_name=NVIDIA_B200.json": "4e362b8e978e57401a3846b6a24fed65af3a3e5bc6ba4ec6d1cabb64a6028f69", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=16,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "dbc3beaa3f68bb26e6d568c8c0c40cf637b9f4066052dc9c23129b50f86e9128", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=16,N=2048,device_name=NVIDIA_B200.json": "529f2b3eea08222c5a79afec1b93caa3ed599292cdcf07ac3a864fa128234fd1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_B200,dtype=fp8_w8a8,per_channel_quant=True.json": "7d6f53d4b97bca14965a98778f99e3c553b5f188b63cda946dc63ea3c0746f0b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H20,dtype=fp8_w8a8,per_channel_quant=True.json": "da049f5fb6789cf130ef362e8e221caee4e090091603a8a064277f8c70e3c36c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,per_channel_quant=True.json": "a05f66743170059d7b2a78374bd7a30c416206fcdcf26ad64d12656bd082ffa3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "a997d5122122d8d286931d8c0ff1ec23c424ae6cd561b09fc60c5efd5d405b69", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H200.json": "e82d8f40230528c208e655ac861245cb1fc75829c79adff888e4a688f217378c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition,dtype=fp8_w8a8,per_channel_quant=True.json": "f6d9e73dfb6bd35dbaa4ace6030817a29848742245a38c788dcb2cc491f4fd90", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition.json": "29826c7e8507d4cec5c79bf818c146f4d84a2289854b9a439b067a2b6e319683", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=384,device_name=NVIDIA_B200,dtype=fp8_w8a8,per_channel_quant=True.json": "71e4389df4e54eb7e28d5318f7de6214a916bed38b316e48d4b5d2fed2b39169", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=384,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "75f32678bc5c80676a35c94acdf1895fa7d23cdd32ebe1713033d60e3e119e9b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "3e6ed775a6afd26bcd424c716eef360bf7df8663fb78377606652169497fe1b0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20,dtype=fp8_w8a8.json": "de039ac7bedca8bcb6af0b37434c7a3d6ae7ef574e3063befef30b53be1247ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20,dtype=fp8_w8a8_down.json": "de039ac7bedca8bcb6af0b37434c7a3d6ae7ef574e3063befef30b53be1247ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8.json": "2b46e9a118e2e2913c04370d0d2d5e5e583f943df98415eb131d64bc1c2bd45f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8_down.json": "2b46e9a118e2e2913c04370d0d2d5e5e583f943df98415eb131d64bc1c2bd45f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e.json": "6e1ddf115cce355e9e20a9f9ae8ec31f8730495ccbe464587464f8137590d37e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e_down.json": "6e1ddf115cce355e9e20a9f9ae8ec31f8730495ccbe464587464f8137590d37e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20.json": "aa020ec22d8750fd9460c2d772e6c026953c197aa8bffe5e75a7720a38680533", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20_down.json": "aa020ec22d8750fd9460c2d772e6c026953c197aa8bffe5e75a7720a38680533", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=20,N=1536,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "403477abd3f7102384febf551596d082185d717b88012a03c6daa8f72be179df", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=20,N=1536,device_name=NVIDIA_H200.json": "f43d515d1d7bf385c176900985b5179ea77cd644e0cb305396a581a2333f95c4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=1344,device_name=NVIDIA_B200.json": "a1ea86a173e803ecde95bf6a0582fda52cf6dcad7afca7dd17a1680ad15bd55d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "fc6d86a18730cde466839fca66b4f6235eef0b78197502b174a8d5e0caa4817a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a1fbe0eb240031ae9b933135053d210e03a38940e6e36d8bfa48d4c7c63660ad", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "211ebb031054e6b5612f2b9c58e97df23cad890e33441117aadd35dacd2421be", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "a1fbe0eb240031ae9b933135053d210e03a38940e6e36d8bfa48d4c7c63660ad", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "211ebb031054e6b5612f2b9c58e97df23cad890e33441117aadd35dacd2421be", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=2688,device_name=NVIDIA_B200.json": "cfab9577a4e218eb0a5213aaa24d47078b7cf64d44cccb1852408767b381c9d1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "057233d0d5f2a2cbfd3077292ddb65c19266bade5ad8e7b0beaa075afbaf0f40", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=384,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "215aeb8489333f5b7d1cc454217a55e9d6ea0ea25c6c6d11339639d29ab3b897", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "9ca68260b79e11471f9540baac49bf0899c078a2bf986dbc52fe386a431c4dc5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "791325ae16cb1e05de42308a5ba86148cca6d2a8abc23a03e013c3e90080098e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "53e8f44228725f4e53f1edf1ba60daf74d11a33adcfa8d0fe86ad0ef6c5a04c0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "791325ae16cb1e05de42308a5ba86148cca6d2a8abc23a03e013c3e90080098e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "53e8f44228725f4e53f1edf1ba60daf74d11a33adcfa8d0fe86ad0ef6c5a04c0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e.json": "780a5f0cc7bb8051dbc921e53cbe4b1db84be972b93c7760ef4e671386431451", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e_down.json": "65efd6589261943ef87a0b794d9daf2263fef611bb42937ae9a15acbb1577f1d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20.json": "780a5f0cc7bb8051dbc921e53cbe4b1db84be972b93c7760ef4e671386431451", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20_down.json": "65efd6589261943ef87a0b794d9daf2263fef611bb42937ae9a15acbb1577f1d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=672,device_name=NVIDIA_B200.json": "496faa17aadbf3c53d0f890cee9c8377f4a90646a3e5a8e7e0b27c5ecdb5a1bf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=672,device_name=NVIDIA_H100_80GB_HBM3.json": "4b8f9d863f0125d28f77502d51fe02881b7e485351a01fad3bd742dbee1fdfaa", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "19e6b3a96b5bbf1340cf05ae23ef384b8c6f5fe49457b4b7ff88115d2e42c831", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "4753bac1380c741d3c16956f90557f3529edc3b161a6f38c772dc223992daa6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "64adeda916e9750122b060e6669068c7a5a3ec8234bfe2499e49199a9b0a96a9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "464c6d9660521a06c6b4a90a8a30790ae109b99816875179953b915def013576", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "8c4f4083d952668a7ebdc284ab87b565e03700e63523a28a80b78940b688191e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "0a88a3611a9f18b95280fda9461e3a553c3b254c3db774fd7e337facd960b4ae", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "9a8a5a9c503f4ab7e4348e07a09483868740573668b42e0a17b01889ded4562d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "421c5282a574b7afb76f9dd6d55eb6ef9f302017ab4029a065b2943e79d1ef9c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "381e68ebed0c9bf130dd898750aeb8a40ef787d69aa5ad40ae15db37c89c3ae4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1792,device_name=NVIDIA_B200.json": "b046ed083381bacf17a9baf43ceb7171602f412d57c2ca7aa8204294af945199", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1792,device_name=NVIDIA_H100_80GB_HBM3.json": "80184412ca386f603dc6190cc66bf54cb1419e493eebb5044573c0ab66cb812c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1856,device_name=NVIDIA_B200.json": "d4ebcb1373a0020f6c8497e28e25db5ec66ee9fbb6cc94210217037a46762e1f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "e3a5191eec788aa853ea8716e3ab807324690ec80a1349a8bb14f15e5a400bc8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=224,device_name=NVIDIA_B200.json": "94083a6d2f7e7e95da305df0c0ed40ae532a702078bc8cc44f036d7b5193c4a3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=224,device_name=NVIDIA_H100_80GB_HBM3.json": "1aea06bae1b7b49f157e1b1e70a1abd43b3722fe57434d820583c8c5a131a2e5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=448,device_name=NVIDIA_B200.json": "7eea850ff3a2c35695b367f446a1cdfcb12a232216bd3a7ca6a361c63f927a95", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=448,device_name=NVIDIA_H100_80GB_HBM3.json": "c3abe23ca68c22649bca1a91f0e13d25d207359bb78439182db98ba034caf6d8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=896,device_name=NVIDIA_B200.json": "5f0f987dafd9459e72f8086c8ed60650143c3a75a37c05e8d502323664d4906e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=896,device_name=NVIDIA_H100_80GB_HBM3.json": "110d7f5b6310d37b8b8ceab952a76b286ebd735a6e572c6d43658b8ee3c19caa", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=928,device_name=NVIDIA_B200.json": "4c722ca4b35d04df58b5d07907fff8f2e361069cab61ce859767fadfe528bdb1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=928,device_name=NVIDIA_H100_80GB_HBM3.json": "370d52bc59d130081cec0a79ce8058639fbe0fca6caf5cd701df1d5ccfec5be2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "4166cc74a782dbd1074bcbf302838a5cc5254c1d291240c13a3764d09f8374ec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "c13ab178c2557ec886aaefd13b28a3bc7c5036d4fb065b69ef76e1786b2ae1b4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "4166cc74a782dbd1074bcbf302838a5cc5254c1d291240c13a3764d09f8374ec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "c13ab178c2557ec886aaefd13b28a3bc7c5036d4fb065b69ef76e1786b2ae1b4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=40,N=1536,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "bec7a6de5d1d3c266802102bd582f82c45a263342e0408e6d2cc8083de7addc2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=128,device_name=NVIDIA_B200.json": "9ca8dff039717269e7d81215e6e7305d35c93af84737895cd8b7993f679c38e0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "020b7a36328778ec8a245da1523e047c24d3f73b5a485282000166412cf0e745", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=128,device_name=NVIDIA_H200.json": "c8ef7ff493727b450bb8547648c60dd73c726aaa425b3825474fcb9b29abbbaf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=1344,device_name=NVIDIA_B200.json": "3cfb859c279cefafdaed984ae188eb558f43ad42a5fd2ad1ece4dc5ac66099a0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "de21a66a3636480cbb9add7c5bd9017797c2346bddab2b319a2acdd6753fb158", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=256,device_name=NVIDIA_B200.json": "6e70f307b4e1fa82c3cc573c1ad421c244d0578074139372705672e4309e66ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=256,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "d365e3fe134b5cf69ff234e6923d35e91201098e2ddc61a9ad0efbfcc8b50f2b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=256,device_name=NVIDIA_H200.json": "e7478e6689b965bc3fcd45e114881a6d88c9ef2c933b5501ec8eb6b82614e305", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=2688,device_name=NVIDIA_B200.json": "1b82e6baca090de90062682b4631b0e78633c31be690547bd43c925278920cae", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "0963e8cd396c736bc91c6bd29e3f7175d4812054377b17ea1b6f3c91d2538218", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=336,device_name=NVIDIA_B200.json": "90cc65e7f99a13029758d1678708bb235f6bb58f3dfd118b2191102b60d4084c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=336,device_name=NVIDIA_H100_80GB_HBM3.json": "ce9fbc962e0623c6e08c81a5b70e57b496a61b6bc953efadb235d53ce3064603", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=672,device_name=NVIDIA_B200.json": "a09f90d7e21dcaa0d87479c144565e12c39cc1ed2f339207320b75772b252185", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=672,device_name=NVIDIA_H100_80GB_HBM3.json": "1035ffd39b5c925146fba8c8c4300f6819f5cdc1ac3b939b74a148c3f7dcfc96", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1536,device_name=NVIDIA_B200.json": "a56b9885e11b11fe27eca5f7374b803416ab0ab7c45a5180e618574e68ca28be", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1536,device_name=NVIDIA_H100_80GB_HBM3.json": "3bfb9217dca5085b2478d6d163560c531206fed385639bf55f2f6652289c31cb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1856,device_name=NVIDIA_B200.json": "c03cd023342457d5e94de50bc854b5fa1cbb6645fae36901525520631be84bb7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "44cc31dc0e3dce2b1edeaae90b7346b7759c966600d38ca9184df658fc55ad64", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=192,device_name=NVIDIA_B200.json": "156c92cd714998c9efd2375cdb1665d644229387a4029d86e2783d42ff0e608c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=192,device_name=NVIDIA_H100_80GB_HBM3.json": "ff610d631377f1bfb5ac2ede4e38b8037ce9c5058076daa6acbfb14a057bfe0f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=2688,device_name=NVIDIA_B200.json": "93251d3ad9bda0cf1323c9081077cef8758d1eb443a5a8fba9c36a8387bd2992", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "5ad6440146e11c16f95a71c837c9277704a475f6c8185e2dd3a52eca4d93f977", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=384,device_name=NVIDIA_B200.json": "13163b688aa88ac589c53d74e39a1f2850ac4c9c1d25a7f557476b65b2d160a3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=384,device_name=NVIDIA_H100_80GB_HBM3.json": "21d1afde8079375ebf0f56327af3c494425f265ddbe7f89f8c47e739f2fab16e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=464,device_name=NVIDIA_B200.json": "0ccb8bc37bfc9d4788fdb68663f5d31ae133eacc14379a75878c9776ff7d3ce9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=464,device_name=NVIDIA_H100_80GB_HBM3.json": "4eed6ee67e88f74a1e35e7a0887f6fdef079d99d59779b2fd2d1de917e7e9918", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=768,device_name=NVIDIA_B200.json": "21ee026818f8e17533a823f1e0579c4abce9573a1ad1733318588a8edf2f7487", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=768,device_name=NVIDIA_H100_80GB_HBM3.json": "25843603641dd86f223e82b36fed94da68d7d2508a343f8d6467f28346bdcacc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=928,device_name=NVIDIA_B200.json": "0bf60f991a0c825878914f15be16be82539a61cbdd5c1be8f6dc57d31a8dd46a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=928,device_name=NVIDIA_H100_80GB_HBM3.json": "20feaa1dba0d5641c4fc23c861cc4b56e9287a9144e847e7934a690e3ba518fd", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=65,N=1536,device_name=NVIDIA_H100_80GB_HBM3.json": "5873ea5db4da7fa9109f33e00a436cf15c515f1c6c05a413362fd43024cd5d63", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=65,N=1536,device_name=NVIDIA_H100_80GB_HBM3_down.json": "5873ea5db4da7fa9109f33e00a436cf15c515f1c6c05a413362fd43024cd5d63", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=80,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "49a8912ee6f4d1ed31b74f6b8883feb7d78344f92cde98a6c37d61eba85dc3d3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=80,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "e3a3b851c9bb799fe6e02641cca8b43d9a462761e23afe0d42a144d4b263a07a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=384,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "ee12de31d61c4bd184789e235fa1778861f7428610c20c841abdf7a3361a3abc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=704,device_name=NVIDIA_H200.json": "b395443d24926c1f59d90ad0d3caa7989f9d16c5ffaedbaebab33db247d60e11", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=704,device_name=NVIDIA_H200_down.json": "b395443d24926c1f59d90ad0d3caa7989f9d16c5ffaedbaebab33db247d60e11", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=768,device_name=NVIDIA_GB10,dtype=fp8_w8a8.json": "b8e1c318bb84c878c3d8dbb9f726cfc13e3ce5abbe2c9776941d2e407de6e146", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=768,device_name=NVIDIA_H200.json": "26b68cf8dbdb83957f4c991297a50f15864dd731c7a086ebda901c92c7a7a136", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=129,N=384,device_name=NVIDIA_H200.json": "f9eb906bb7187c17d1f863e1cb10a499045957b31003eb92d74cfbeb72754451", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=16,N=1408,device_name=NVIDIA_H100_80GB_HBM3.json": "9a06fdb55915bfd138b536ce00ab32ea145ad02c9eda46f4377baaaf361d1831", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=256,N=512,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Server_Edition.json": "d12a7ad0d2bbe834d9a3e116232e565d84698356d758876a6b52f3d9f8f451dc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=256,N=512,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Server_Edition_down.json": "174955761db4a5b76646121ecd5ad3791bd13bf06644727d8c27b7577401dc56", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=1792,device_name=AMD_Instinct_MI325X.json": "9eeaee332cb79ee55b66897732933b6e6a9fa15933b69ebfbcb47432692392cf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=224,device_name=AMD_Instinct_MI325X.json": "202a5ef736257dbcab3f5cd64179ffb02428d09c90833731a6a5fc5a6f9346f4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=448,device_name=AMD_Instinct_MI325X.json": "3406b2127e82acfee4847af4451cb748e5c5e8592fc3cfaf16f8852027430533", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=768,device_name=NVIDIA_H100_80GB_HBM3.json": "e52f46c62bd30196e895f6a1fbe78b6c56ec03aa93f1adca1fbe66a736f66e28", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=896,device_name=AMD_Instinct_MI325X.json": "74baceb424aa18890bf1bfc4ba3643e2e31a4c27b2d4d7c0b72ddf4691a74df3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=512,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "162a768a5d0f37d9753d4f171f656c99af0cc6c16069b44b9c462bd930aa59a8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=512,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "dc118fb2c7742aaa0a08571a838bf552fd7fb2ceac8d382a3679afa535e257f8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=513,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f9e3579e163b27e886ecff73211044e3f56f6168019258f3c115efd519e5b0bf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=513,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "f09913c7aadf0aab089a2d4bc26dfaec9ec4bdbe2d497638914e700c858c51ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=1536,device_name=AMD_Instinct_MI325X.json": "7f7785d11e38b720edeeb2b33faf0594509974880f9afab91213dd2d3fd15d36", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=192,device_name=AMD_Instinct_MI325X.json": "458d6e7e4ed21f527345a0bd542d1c1506efb5f0e605a4f10439d27d487a4c59", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=384,device_name=AMD_Instinct_MI325X.json": "8a53e814d5c7bb9b8a5ad31bacd42d0379ea56258b588d8b1e01b49f22e00b71", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=768,device_name=AMD_Instinct_MI325X.json": "f7c00f1942e95888081de80941b6f11935eca620cf3177e9e43cb39d2860aa8a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=256,N=512,device_name=NVIDIA_H200.json": "29d2963611a6efd579bcad4096c5483509903fa1381ab1afe3fb9e8180a981c6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=256,N=512,device_name=NVIDIA_H200_down.json": "580ba806aee263268a95c250b7ffc47cf073cfa1f55c2f5b2434e0c42787b3a2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=512,N=160,device_name=NVIDIA_H200.json": "d2324a321541e510c2caf6ba09a190295bf8e5035031052f180300ef286a6b46", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=512,N=320,device_name=NVIDIA_H200.json": "6605724a9be662ffd476ec7c33614aac57e13d1c321166f7f11ed14518636d07", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=512,N=80,device_name=NVIDIA_H200.json": "4bfcd012ce58ded82f11cda93415597743bfe5b66ddd5d10cef34765125d32e2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/update_sconv_cache_sm_100.json": "9e93756af03b3ff1ba35b6fe64d09ee2b5f3cb9209ea0735593d152314b627c3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/update_sconv_cache_sm_90.json": "9eb4322b6584e78392e0108d2b1857978aa78d9f4e56159fa9ca7ef150182b9c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/update_sconv_cache_sm_95.json": "4fc9b82db8223ede1afbdcefdfd05e92ec8fe6de2afc66f101e81687eabf2896", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/fused_moe.py": "1858f4050d3465b3b1f7fce979713e6c8f56a14cf8298c99a105b5877dd6431e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/fused_moe_triton_config.py": "022c8aa47972dd975ebf7be9c6d04ac4c60604cf705cf80c9b38e45973193d09", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/moe_align_block_size.py": "3556aba5fc1142546f30d1f03034831e6893ee5ce05d868c29207485cb28df78", + "python/sglang/srt/layers/moe/route_quant_handoff.py": "9bb752e7763be1640ae03541c0ef064813786e6cfb98a712a42de12ce44d86aa", + "python/sglang/srt/layers/moe/token_dispatcher/__init__.py": "e79e4a67cffbd6af9d5fa53fd8055ef54c9d3dee54bd5e90aa0540f25cfaa161", + "python/sglang/srt/layers/moe/token_dispatcher/ascend_tp.py": "28e97cf60dc67a01444f97b66e9bcab6b99cbc35a29b3a3c9c93b601066bbd67", + "python/sglang/srt/layers/moe/token_dispatcher/base.py": "a77e88375ac36c3997a704fe909fc7c9b66e4f51605f6d86efec69f3c84b2fc3", + "python/sglang/srt/layers/moe/token_dispatcher/deepep.py": "201827c6ffb2289392b9e1b36908ca524009c864d07e19388603f435efd76d2d", + "python/sglang/srt/layers/moe/token_dispatcher/flashinfer.py": "e411261fa1fdd2a4129b2dcc709c2ce7836d7413c7350d65448e33b3b2e559cf", + "python/sglang/srt/layers/moe/token_dispatcher/flashinfer_utils.py": "d26bf7c4fc811d42e30373e4495cd3163540aa8071dadc3534b675e627793389", + "python/sglang/srt/layers/moe/token_dispatcher/mooncake.py": "a5c940dd61de9621b4a8fd027140e6852fbc2df2dd965852a51dc190d0055818", + "python/sglang/srt/layers/moe/token_dispatcher/moriep.py": "de295b0ee79257484d0e5e0a8e7632b996b801d2d5d31c2fe5b4b402db3fa571", + "python/sglang/srt/layers/moe/token_dispatcher/nixl.py": "c6208523e0a66977b77130b288db80b55d31f71ffc98fa4759886eebb2810113", + "python/sglang/srt/layers/moe/token_dispatcher/pplx.py": "052053b7ba7b3d0070585d7eb81bf20cb6ccb1480859fe00d65e779998207e16", + "python/sglang/srt/layers/moe/token_dispatcher/standard.py": "9de02768e3877163c0955edf49be7de72aa3870ac351ad1e586b1679b0e72ebb", + "python/sglang/srt/layers/moe/topk.py": "8cc479ccfc835899db587194a3b193806135666f4743722da81cf3eb9a413300", + "python/sglang/srt/layers/moe/utils.py": "4ff2fa9835b36b4614c224adf75bcfed1694c13f0954befd1c90bde2793cd931", + "python/sglang/srt/layers/moe/waterfill.py": "dc09471a2ec1fd7ca98e84b06972edad8106443ecd0699e00d1f51191b0e00c5", + "python/sglang/srt/layers/n_gram_embedding.py": "ec3736e033c17bd99d7f03b7dc10017eb629fdb3e720aa5df939890caefb6785", + "python/sglang/srt/layers/parameter.py": "fc780d233617c99f6cdbaf60708cb771e27adb2e051ec7e9934b5431a55104f4", + "python/sglang/srt/layers/pooler.py": "788da634ca0ede66fbd8496242749abf07bf496146c6d178bfbb985297bff8a0", + "python/sglang/srt/layers/quantization/__init__.py": "cb87075ccfa96a8153951af8abef029f6c2e38cf285bb3e5277ef245fe1782ae", + "python/sglang/srt/layers/quantization/auto_round.py": "79e0664c76d37a6d006e242db9c296a96a06adbca5d49b5764d9abd07d66feb3", + "python/sglang/srt/layers/quantization/awq/__init__.py": "5592695d532179e7a5f208e50b8db7a39d1c0ccaee0367b784de8ee7b0c9531a", + "python/sglang/srt/layers/quantization/awq/awq.py": "028b39a024d3f6ce1ff2050c405a37e961b6ad646c0a67c7ec838d551a3b9d93", + "python/sglang/srt/layers/quantization/awq/schemes/__init__.py": "1fe1a2332de5f2f7b889d3473e52d78cbd32888d93c6522544670c17c0b97e03", + "python/sglang/srt/layers/quantization/awq/schemes/awq_cpu.py": "a285cad90cfa5df3b6f48f162ca4c3426efe02125ee9218e934b40a280d8c00d", + "python/sglang/srt/layers/quantization/awq/schemes/awq_linear.py": "e9b8b3ad69a7fee1841178deee05e554f979160aa0172cd31e205a0241ff1b6c", + "python/sglang/srt/layers/quantization/awq/schemes/awq_marlin.py": "1ef9c44e1c4b9fbc4e8f370d30afcdc36525be7a0964a7e31dd3b454cfe4765f", + "python/sglang/srt/layers/quantization/awq/schemes/awq_moe.py": "b6635d40313094835fa29687e6069ee44cfe74139cbc377b496a89e4a393fe25", + "python/sglang/srt/layers/quantization/awq/schemes/awq_scheme.py": "f5c37bf94c578b3193986eb9c7e23706f7fc84363c0c7e5aa2a9e109212fdb42", + "python/sglang/srt/layers/quantization/base_config.py": "b4d42c8f20588578b9b77ac536bd3296db71addb2692be904d62e3171b478ce0", + "python/sglang/srt/layers/quantization/base_scheme.py": "8443e8f810e130b95de96a7bced3b0c4922af5210d495b2052b524c7e3c1d55d", + "python/sglang/srt/layers/quantization/bitsandbytes.py": "68dbffc49bea248296fc3066879f15cf4214eb3f1f4f1c17f0d8fc168c3be08c", + "python/sglang/srt/layers/quantization/blockwise_int8.py": "3515d6e4efee78da5a420cd5355cd8ae9a68d2f5dbc8fffb6af281e99d2f1817", + "python/sglang/srt/layers/quantization/compressed_tensors/README.md": "f3495660ccc4166716e64b89eb09b4e703395d4cc24d04d2439961ffb35cdeba", + "python/sglang/srt/layers/quantization/compressed_tensors/compressed_tensors.py": "cd39a1f943dbf0f1fc5e69a260457265cbf5a2aaafd90ea4babe7eb1cf617a0a", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/__init__.py": "1fcef63d3af982e6f4cedd461c4ac6d9e59b8390582460abb5fa2ced3f0e269d", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_scheme.py": "40dec04b729a39d3362390d90fac29ca52ab99a90019ac56fd80497188f70476", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a4_mxint4_moe.py": "12624a8cfd8d03fd04ab4a7ecae05039c86bd93ef27f9838430625dfa94a3063", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a4_nvfp4.py": "f5a6efd61a9bb8b6e6d791891eaae440d60b04417f04ae67ed015f35df61b646", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a4_nvfp4_moe.py": "83d3eaa9e7843f809e8193d981d9dc90f81bab97a36cd30a8969f51fe2783177", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a8_fp8_moe.py": "adafb1332d0317a062ce6ad798cfef138756ce2bfed23e92696acd93e021dd27", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a8_int8_moe.py": "91537ccb48e8a3734111a44b1144c12e25c2939557b8b9dfafa9419d0d5dbd97", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a16_fp8.py": "7714b0dd7621a2c8a542cdafadaf573ddf8fa60e4b2feb826ec831b0edbe565e", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_fp8.py": "c853c513b29883c16dde974fe6b2d6e8ed6c4ab442509fd8a8f0f27c6cc15a85", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_fp8_moe.py": "bd823c839720f334ef90d65448e3ca14b16a5e9a21669dbe17ea1e144a8ff6e5", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_int8.py": "32ef6b9196ca6dc04a82deabcb849a1d029f09fd3137ab32fbe6691f6e23b40e", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_int8_moe.py": "0765e6abd35b6587794cab960d35311ed5a8718c3faa856db186c200988e5eb9", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_wNa16.py": "a78990db02e703847316fa71f2b8891d034c6fbb6fcaafb104f5e1002a7f396c", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_wNa16_moe.py": "74f1c0a36bef17ec0065002fda0824de5b1152e956e6f60bbc95134edff6e0a5", + "python/sglang/srt/layers/quantization/compressed_tensors/utils.py": "6f43153656248fd7fa3782fbc30ab052aa13e368ecdbd6fb00fac6c5e122df6d", + "python/sglang/srt/layers/quantization/dequantization.py": "e1bc76891ebfb33fe12fde7e0913884025c26bc42d18e0aa0044b4246e3b9ffd", + "python/sglang/srt/layers/quantization/fp4_kv_cache_quant_method.py": "0eb5c710559f3bf5ba493d992043213dacb651398edddcbc3b71db8570dbc038", + "python/sglang/srt/layers/quantization/fp4_utils.py": "2ff0495eb47d8afb282406d7e5306c9c20b5edcb65316435c7f39c3fe064bb32", + "python/sglang/srt/layers/quantization/fp8.py": "be081d39b0ebd397fb89208acadba7103111e95e3925569f466240667ea6de7f", + "python/sglang/srt/layers/quantization/fp8_utils.py": "cb310162f67b6cd33da8547c84b48cf356ea999d04c9ed5434ab52eaa2358619", + "python/sglang/srt/layers/quantization/gguf.py": "9cca184242c56a05a15b336f12ef5547efd8c0c97c66cd1630b6f2f0cbf64598", + "python/sglang/srt/layers/quantization/gptq/__init__.py": "30b60b9992a44a9f1a062197640df17e602070ae7b1be56925dfa7fa1e8deff4", + "python/sglang/srt/layers/quantization/gptq/gptq.py": "38f1912027a9774e7bc55e0ec66fc260ad4d9e2653afb000612163bdc7eaaab6", + "python/sglang/srt/layers/quantization/gptq/schemes/__init__.py": "1bc2ea55491a7c61c8e4429007318dfe16b0c9fbfa6606010c02b2f2311dd64b", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_cpu.py": "58bd9993efadc3a8afafd60154ea64aff78eefb42fda16976679d86527b9cca2", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_linear.py": "c8a1197e80de020adac83206fd4d388d1af228cc9407b15bc56191e8fbd02da9", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_marlin.py": "0648295334c1df8e33c008801616a0127333a0a9cd282c1dfa1d95716ac7ba07", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_moe.py": "135e004f7613a59aa0765cbe3d779c9bb0c459f3a199b868358759e020aaeb5d", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_scheme.py": "72dd1818001dea7c4a02d45778aa1078499a587a448e9afab057159b2957c482", + "python/sglang/srt/layers/quantization/humming.py": "7095d6edc186e6c1a306171f3814202fd2863aafaa77797820dd3645d84bbfc7", + "python/sglang/srt/layers/quantization/humming_utils.py": "d87e5ae9e2f29eacf4ab7e5d33327fcadfe3c9922de9b00982a00188982a726d", + "python/sglang/srt/layers/quantization/int8_utils.py": "d8340e7412dfd35c4b75b72a472367c5dea1508ddfa126080061e374f76db70f", + "python/sglang/srt/layers/quantization/kv_cache.py": "4b5862ab5530b563678f49a332213ea2b83437088a797ec6b925a8bf9b3273f2", + "python/sglang/srt/layers/quantization/kvfp4_tensor.py": "19ca3c7d21df3bbcd7b6c56f3c829a37d29814a9f80fbbd73987d08fc1842c5f", + "python/sglang/srt/layers/quantization/marlin_utils.py": "1f0529ca2b24e2af804eaaf51fe72d76484cf5c7ff91a768612c5c9ddfba0bf3", + "python/sglang/srt/layers/quantization/marlin_utils_fp4.py": "09460a6468148e4fbb9fcf82e907b378c457d21e308cc0e9bb3d8807f1679839", + "python/sglang/srt/layers/quantization/marlin_utils_fp8.py": "a05db436551dc12843c65de63bf6a4c40a3fe1fdc461422472ba0d555beadb8f", + "python/sglang/srt/layers/quantization/mlx.py": "1ce4c98f6b93abc250d8c43f3aff659a6146a1ff1265fa73f5b50a19ed40e490", + "python/sglang/srt/layers/quantization/modelopt_quant.py": "b05ed81bef0443781c79c7a6daf05204b8d6c50903cd84dae87ef3303c93d311", + "python/sglang/srt/layers/quantization/modelslim/README.md": "280e04b9a9ae69653d62c19b401f41b239d473297651a3785804f34035a5e14b", + "python/sglang/srt/layers/quantization/modelslim/modelslim.py": "dfbadf0987f8ac866b2c393eb4454227a8fe960c500b1821ad26ecc602ac802b", + "python/sglang/srt/layers/quantization/modelslim/schemes/__init__.py": "65e55f50c5856e370756f68ce933615bed12e01bd65ab24df2ac201c6d71b19e", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp4.py": "13915c338ef514fbf65e167c67e236839ed9b22b575a19148afa51e7eae4bf56", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp4_w4a8.py": "39caaf6e606acedbdbb8753dd2b49ab553b9ae9009d48b0cafbb0b99a4d7238e", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp8.py": "8ead67d94feec4e7f52341ba43e89ddbd5c2917a61b45402a9f4bcd70ab52328", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp8_moe.py": "2111aa441fb8831d02a594172153b3dca66506914b5cee43e9e12352fd4be75c", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_scheme.py": "3c35094a703eb80d8ba4e44a436405850f0c876195fe19e53628ec9fa4ff2d12", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a4_int4.py": "964162624e548aa408e869b50609ba40453b4432153ff887f2c3fd4609460eef", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a4_int4_moe.py": "ccda8039be906206ac224be6854e038b9ea2bbe6f9039facb9cdae0a8c6e80ec", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a8_int8_moe.py": "cea0df9233d6456f892edfaf25bc3b298c2623c85c4aa2d91a59ccbb63a03df4", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a8_mxfp4_moe.py": "f47ccc6324eb90742c3771874b653d41981e1f2a6f4ad5cd147c0d06dbca5f53", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w8a8_int8.py": "c31dd5ff7c011d3a2cfb0edde466243ca8c5646f91f3916eb4a40c9ab7b8aaac", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w8a8_int8_moe.py": "257a44e9071827dd4b6e094b9cfe809bb332fc3a23044b6809c863cf09e30ef8", + "python/sglang/srt/layers/quantization/moe_wna16.py": "1ba087ae1d074d07a918dcbeaf84b2318d830f1c9b61a2a488fe2aa725bbf6d9", + "python/sglang/srt/layers/quantization/mxfp4.py": "822a8dbec3f93c69b3bb6e391f4bbc4f69482842fec2d6a97224752f446dcb43", + "python/sglang/srt/layers/quantization/mxfp4_flashinfer_cutlass_moe.py": "4c17a8ff539b18f5001b71ccbd8fc5486e1f4f0432f422c845d94f91d8d6ee18", + "python/sglang/srt/layers/quantization/mxfp4_flashinfer_trtllm_moe.py": "470a7fa83038e7084738a3eaa46adda01ff073b58fa16bc5c80e710935874ffa", + "python/sglang/srt/layers/quantization/mxfp4_humming_moe.py": "d91fd78e65b95e2dcef12e430144f8a28bd82d7a51530979049a923a4636ec0e", + "python/sglang/srt/layers/quantization/mxfp4_marlin_moe.py": "11c3247b6faf8f1659a4b9e9415e370aef3acd70e18fb77261a575f90633b546", + "python/sglang/srt/layers/quantization/mxfp4_tensor.py": "6c67825e520e8661591465a9fe521390844312019468ba5ac03bcccb57133a60", + "python/sglang/srt/layers/quantization/mxfp8_block_convert.py": "39205c32389e71ae684ef7fc44af364c73c0b664e955225f6e75055a3b29634f", + "python/sglang/srt/layers/quantization/npu_mxfp4.py": "dea73ffa5ff92b1006e54fa2e2c8a6b5124d63ecb7ab089c5c2050112d2779d9", + "python/sglang/srt/layers/quantization/npu_mxfp4_w4a4.py": "eec4fa7db564e0f084c85b740047bef1e5baaf63624a9b933ff969070b2aab22", + "python/sglang/srt/layers/quantization/nvfp4_online.py": "3e44022a73e05a2ade22a98b3f04b0bc9b23d9a376d82ede6e506385f1a4e12a", + "python/sglang/srt/layers/quantization/online_quantization.py": "410088a35d9364617f522ba8eaef5a6bd9a63446883ed6a70882715492e21e48", + "python/sglang/srt/layers/quantization/petit.py": "253972ff143348f81f4c045663755db93a392fca5ed615a2631f10d719bea795", + "python/sglang/srt/layers/quantization/petit_utils.py": "fa0cb8ccc86a368200d51d27efee42d1e7d5e788c7a2709480f0d45058c6b323", + "python/sglang/srt/layers/quantization/private_draft_head.py": "08e8232ca0a9bc93999bbd3f35f91e075a3bcf9da4e02889666060b5212ab2d1", + "python/sglang/srt/layers/quantization/quark/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/quantization/quark/quark.py": "e445e6b87594ae3243c66c32147bcf966726430812e4ec77439f9a5168a2d6fd", + "python/sglang/srt/layers/quantization/quark/schemes/__init__.py": "8593d4ee997ffc3cf14ba6768f093011046e70ceb2144c627e013eac23c8d35c", + "python/sglang/srt/layers/quantization/quark/schemes/quark_scheme.py": "4655c2f81fb7169c07393f11bd080717ab1a34fe9da32e1d0392acc706a9e77e", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w4a4_mxfp4.py": "8f27127604b8dd68bd6734b2cace74544e14a2ad87d8ca51a712ebd49bb219e7", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w4a4_mxfp4_moe.py": "23231b1e107c36536daa6fb3b946502cd9ac3d61cc6ac36d17d170840f054158", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w4a8_mxfp4_moe.py": "e8d7bccd09308cec3bc4ae1b0a3fea3d05b4ff09424fffe5e534b6a5a4151c79", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w8a8_fp8.py": "0354e9556833d264ad1ce5fe7952dc51c36b6b87b3566ac07e73b3dec39159c9", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w8a8_fp8_moe.py": "69f015cdb3501dbd0e96005a9b73aebf53ee8d2299eb9359533c3305c548f635", + "python/sglang/srt/layers/quantization/quark/utils.py": "38fd28f40a45c1cf982c8af772fccda30619720fbf9bb3614bc9d88fc2263a7f", + "python/sglang/srt/layers/quantization/quark/weights.py": "539cfe2dc4ead86a20f04ff4506214dd3987f000511a90633908e76e496e53e9", + "python/sglang/srt/layers/quantization/quark_int4fp8_moe.py": "12957b021fd9648b1102eac5aabb63cee34d23c16c8ed84fb979ad4918c7d5bf", + "python/sglang/srt/layers/quantization/rocm_mxfp4_utils.py": "678a585a5e84c4e5eadaa7d31e8ad6d7a8556c9f919381bc5abc67ff1f1ba071", + "python/sglang/srt/layers/quantization/unquant.py": "9103cc6d4e03e19134aa1ccc92a9692f825ea6833ed701e4a12175a328ee1cac", + "python/sglang/srt/layers/quantization/utils.py": "290d4567ca2a8207bb1a4edfe6bf4c5db1f2d3b1972dade03cbcd69959a7b31a", + "python/sglang/srt/layers/quantization/vision_mxfp8.py": "abd9b92edc32c923581723f3fda0348d04f478edd7169fcb2732645917b021eb", + "python/sglang/srt/layers/quantization/w4afp8.py": "d43150f16f07329efbeda64c704bbb731e6904e9dda559e865f5c44e757f191a", + "python/sglang/srt/layers/quantization/w8a8_fp8.py": "010290429b6d79e60a01fe6af62ce80a69fa6d5dc1c38165e448c04198b246c3", + "python/sglang/srt/layers/quantization/w8a8_int8.py": "f266f3cc9bd118cbd138336965afee76382c4e8728452ad226e96e41d6ab9d25", + "python/sglang/srt/layers/radix_attention.py": "9e51244758e1c0923fc03b08045039900fc8ca3138485a6d6c47926f0cd423d1", + "python/sglang/srt/layers/radix_linear_attention.py": "4af975b5e0ea2b17505920a43509372200fffc62eebed2e4b04346175710a179", + "python/sglang/srt/layers/rocm_linear_utils.py": "87ca6a653584c01bc264be38697ad93af3a52fdde023be1edb2c59043c8c04b0", + "python/sglang/srt/layers/rotary_embedding/__init__.py": "7329f3e0422fdae69421c4335cd49e9ccaa89b861d7f89123cd1f207aa511ed6", + "python/sglang/srt/layers/rotary_embedding/base.py": "dc4d4ddf9a0d2b90f2108e0b5888f27822a5c6adcd83d966d9f10f6581504028", + "python/sglang/srt/layers/rotary_embedding/factory.py": "33fcd7e8c52f626e800e8be8231166221a526a49ad99c2be73b2b1829993cd99", + "python/sglang/srt/layers/rotary_embedding/mrope.py": "6f952b96801f9cab29c170670a308d97eca832d39b69374f866e50318c904146", + "python/sglang/srt/layers/rotary_embedding/mrope_rope_index.py": "625502f5e3fe75baab237627242d3a112b23d6f0140b22fff25b34391bdbef10", + "python/sglang/srt/layers/rotary_embedding/rope_variant.py": "5711a778a965c7a84fcf6b2552c1c7a2efd6eb820ea3f48fd4597d01dd86f9ff", + "python/sglang/srt/layers/rotary_embedding/utils.py": "828a50285218e40c3429d2f4e75b1d051e3a89d831a7ab005e8c2609278aeddc", + "python/sglang/srt/layers/rotary_embedding/yarn.py": "105a507bd92816cf785e807c8582086d2c9201781d1b0329083695ccc9d09058", + "python/sglang/srt/layers/sampler.py": "d96221b3873f1ad9d83fa8d4457af70f3aacb2513112ed405172bf5aceccb064", + "python/sglang/srt/layers/sparse_pooler.py": "f6007c76e478f11f851ad03843b0f57c80d2bdb2a50fbd0ddfc4b72ef83bef7b", + "python/sglang/srt/layers/utils/__init__.py": "992a4f05906e3f06ea1c942941ea0f05c2de68f89c8b6ccc1e4bcefdfe0e8ea1", + "python/sglang/srt/layers/utils/common.py": "5d3b3d71926e31aa0495ca7453efaeefd4e59802619826b91276761074764f0b", + "python/sglang/srt/layers/utils/cp_utils.py": "ea620e6240bc17517517005c774685a2fbf9507138b93805058cbf532435b286", + "python/sglang/srt/layers/utils/multi_platform.py": "3ad3db2c47c7db560fa76ee642f6bf1fcb10086fe14f5ff8840b90ba692cc309", + "python/sglang/srt/layers/vocab_parallel_embedding.py": "c837114a550d4d5b337e3e14847eb0b72896c45a124b57f2364272e8cb4a0113", + "python/sglang/srt/layers/zero_copy_context.py": "85bcaba1ac6911cacf83051f5214f3e4dd1edb9d3c1f6809aa8f1e3ab3072468", + "python/sglang/srt/lora/backend/ascend_backend.py": "f09a695ec58dbd46d81b9224ff35769483d1df9c535dc40f694a969425002326", + "python/sglang/srt/lora/backend/base_backend.py": "ac0a8622709f58962ccc4c39aadc23008664ce7a9ff48176877405ebbd1c8327", + "python/sglang/srt/lora/backend/chunked_backend.py": "e78d5eebc9d8369627242986f10de4ae7e948f54f3f2ba323138f73ede198bef", + "python/sglang/srt/lora/backend/lmhead_mixing.py": "88fe73ff06b6e2736dd3eea92639f9af0614b6ccb3ad83f2a34c2f17ffc3d654", + "python/sglang/srt/lora/backend/lora_registry.py": "77111565e70ddb33ecb656bf3f787809d0a8a37d328f2f2ea49294d87a5b73cb", + "python/sglang/srt/lora/backend/torch_backend.py": "2f2be4da44af150a66e9164485e83f0b0b819ff5160729c03a4c04a409d89c7e", + "python/sglang/srt/lora/backend/triton_backend.py": "fcd1768977d780c7f0187234f514b5bc41a675aeb753876bc2c9709672eb150d", + "python/sglang/srt/lora/deepseek_mla_correction.py": "34e2a7579cecae5aa06c2f734ffaa6052e397d1b6f80a27aafd506ae90731390", + "python/sglang/srt/lora/eviction_policy.py": "ee3ab6705034aef0448c5612456685f3b039efbd07d307313fe78539d3f2d520", + "python/sglang/srt/lora/layers.py": "a1b456750dad3ffd06df417f949f14b196c6813a3991943073abe8ad307c6181", + "python/sglang/srt/lora/lora.py": "368221bec72a8c75e900e46b76fd80c6c15a1adf929b9e069684c159c89bacee", + "python/sglang/srt/lora/lora_config.py": "abd3e2644c0ba0739ac1ac5cd15b43764c1fd0a2106fe610e0c6c841059505c1", + "python/sglang/srt/lora/lora_drainer.py": "561d0531a91b9ede808ebb21fcd037248504d5398ce79b8767ba954cb024ef95", + "python/sglang/srt/lora/lora_manager.py": "bcac6adb2797a211e648f8bfa98e84d45b482da7178a4b72130e02eabcde668b", + "python/sglang/srt/lora/lora_moe_runner_marlin.py": "f901cdcb79a9d4fcfdeccc8ed38ea82b88fd3eb9459514c4fa89f4cf9c01e1c0", + "python/sglang/srt/lora/lora_moe_runners.py": "6fb25d71031e67e6f13f67a078c7994c4f72322c01964dfed01cd4ebe7f2aab2", + "python/sglang/srt/lora/lora_overlap_loader.py": "d567ebd9865f224a97eaaa70c4bb12f27017552a4d2fcced7d64e72c7966d12c", + "python/sglang/srt/lora/lora_registry.py": "14474232285bdf7b979a05f93a10dc3bc4d4fa76c4e76dd6ead76fb0f91be79a", + "python/sglang/srt/lora/marlin_lora_temp/__init__.py": "fa121557e964bf92c935e13df5e7cdcb6346b3c90410d217827a84d97d54d08d", + "python/sglang/srt/lora/marlin_lora_temp/activation.py": "86f69dcc43a73c61c686e5fc3639407f0f0ba51bbcb6c3dc02cd7680d04b838e", + "python/sglang/srt/lora/marlin_lora_temp/direct_decode.py": "30424b11fe03c66ae48fc41069aad58dc7910b6fd5009e125532d006f7b0539b", + "python/sglang/srt/lora/marlin_lora_temp/lora_layer.py": "6ec8f8152e9888ab02a2dfc98e3b951f1e54e1130a762d481a340f541d9ff9d7", + "python/sglang/srt/lora/marlin_lora_temp/moe_runner.py": "2477906ab0b07cea59b403e28353ed68fe7b02b93c20b3b1ddb546902faa9741", + "python/sglang/srt/lora/marlin_lora_temp/policy.py": "b3bfd0850023c3e7a41bba40ff665c0957ded62b539f59116101b7cc36eb35e2", + "python/sglang/srt/lora/marlin_lora_temp/sgl_backend.py": "cab7e5c17f46e227ebea5f3ff54e25a2ba639ff423cb7f937fc97e276eefc854", + "python/sglang/srt/lora/marlin_lora_temp/shared_outer.py": "93ac7082a4a3786460310ba4c8d580ae127a1a7b3e7d75c133f0fcad9f304cdf", + "python/sglang/srt/lora/mem_pool.py": "f955cdf2cb9fd8dc5c1f29f254bc69caf3517c0118c0935429379f04e7b9c733", + "python/sglang/srt/lora/torch_ops/__init__.py": "a54d8b9f1b57cf752893530d858cf5c0b36936b4e55aa3a7aa8bc97866889c48", + "python/sglang/srt/lora/torch_ops/graph_lora_ops.py": "390676cc38975095ba124d1932aa8c27dc2b4605e18c495c095ae852f4c96790", + "python/sglang/srt/lora/torch_ops/lora_ops.py": "fc6b43a3b721194441c6ad80561596a064a4c5863de5b62fc3e2fade48f866f1", + "python/sglang/srt/lora/trtllm_lora_temp/__init__.py": "cc7bbe1717c92d5b0c944b94e871bdd3348f6deb086b8116dcabc179279c7744", + "python/sglang/srt/lora/trtllm_lora_temp/attention.py": "e180238bc5512e41496a808fe7d9783231b4c1fffc9b556906b1c74821e16825", + "python/sglang/srt/lora/trtllm_lora_temp/deepseek_mla_correction.py": "020cbeb935ee95598a8953ef082f1e92f8fb506bb665f3559591311f812335df", + "python/sglang/srt/lora/trtllm_lora_temp/environ.py": "391391cb385d9472fd44314cbe09fd2e73eeab65dfb3b2bc8caf0fde8e71434b", + "python/sglang/srt/lora/trtllm_lora_temp/experimental_sgl_trtllm_moe.py": "57238892cd2a481bfa8f3cb74eb73d15bfdde0fc2ab80ed782ca6e0724979dc8", + "python/sglang/srt/lora/trtllm_lora_temp/inkling_dense.py": "d9b3b95ff24faa097ae5e108cd72388e291e989211f0c518ee3079631b09c28f", + "python/sglang/srt/lora/trtllm_lora_temp/lora_dispatch.py": "8a4b258d43eda0e978a018e1ae2f297d4702b4038749ac6486d167f1ee4a7636", + "python/sglang/srt/lora/trtllm_lora_temp/lora_layer.py": "ec8b9bb0f1d611051271c61080af3b1a6ffd4724f946c152537399c4eb1752b1", + "python/sglang/srt/lora/trtllm_lora_temp/merged_column.py": "e52017ebfba01df0fe37b01b1770438bb23548e450d663208673b01ae19971cb", + "python/sglang/srt/lora/trtllm_lora_temp/moe_overlap.py": "ecc556bd4aa274e2db97002e022c935c991f139892b9cebd377e9f11e171474d", + "python/sglang/srt/lora/trtllm_lora_temp/sgl_backend.py": "bf90ef8d9ce1a7382d2caf76d494b3810637800128e30ed7dbec0125957af20c", + "python/sglang/srt/lora/trtllm_lora_temp/sgl_fp8_moe.py": "fe39d65f7e4d56806762e9518d598e9095f3657249718349b8c058df6dc60948", + "python/sglang/srt/lora/trtllm_lora_temp/shared_add_overlap.py": "c2df0c884816c05a996487742005073d7e30dbca4689bbbf1adf0ed60b4cc7ac", + "python/sglang/srt/lora/trtllm_lora_temp/specialized_expand.py": "6246ad33cbd08b529b6299c05cac20b1e3939daa0d085228661296048b9e7cf6", + "python/sglang/srt/lora/utils.py": "6c2b94b92a45ebefcd2e3e4b5c8f9d2a7d5496ef8b98832a2d10667f61c505b1", + "python/sglang/srt/managers/async_dynamic_batch_tokenizer.py": "a52ed01045e146dbddcd915f3ea1c0d15775207bebf26777df84bbaabb709ff6", + "python/sglang/srt/managers/cache_controller.py": "3f323c0b08acb8b1de6f3ff8c08f1ed34d508afd186ae61d370f4e1087d89974", + "python/sglang/srt/managers/communicator.py": "8228691d693cc2877b23fc777866a6779c1ed8511dff0c64ad002d2c602e0552", + "python/sglang/srt/managers/configure_logging.py": "acfd1542b779fcfdc207ea5f94037f9275e5ecfcd7ca77e17b7a63d9d4dbbdfa", + "python/sglang/srt/managers/data_parallel_controller.py": "ba6bbee2be27a5cec6d1625a4ae8d131dc5bb19dd6c32d985e378116d085173e", + "python/sglang/srt/managers/detokenizer_manager.py": "d90f88443bbde167c516dd4b55cd978bb75dfda1766d7e83c4f16a3094d9954d", + "python/sglang/srt/managers/disagg_service.py": "b1b2a8cd4d9bd1c891fbc403c499859277d85f641508a6f75919d8997e88b67d", + "python/sglang/srt/managers/embed_types.py": "a82f4dec31163faf0982b1346290698b1a19aa648f7b6381d3b129d73046de75", + "python/sglang/srt/managers/hisparse_coordinator.py": "f40ff83c78647cee92d674df808681dd805e29aca0711e2a944231d10cddc8c8", + "python/sglang/srt/managers/io_struct.py": "cc022f58fe2468fb6231c1e65a41106cbc0d73fe1bd784d6f57df94a412564a9", + "python/sglang/srt/managers/load_snapshot.py": "cf691698fef36941b65ca73f79684e95466fb8da528115b381d0f310d3673c98", + "python/sglang/srt/managers/min_free_slots_delayer.py": "bb864fc17446d3ccedc208250ac0171a235a39870bc151139c411049772fbeef", + "python/sglang/srt/managers/mm_schedule.py": "0c25cae8193e85088be5e1c012268689d868d87a49c5d81fee624c5e8f7dcfe7", + "python/sglang/srt/managers/mm_utils.py": "a51e0de5ec1abe5b2d094b43df8e2cf962372d50ffeb775d915b3c385b45a871", + "python/sglang/srt/managers/multi_tokenizer_mixin.py": "d5ae16421e4be95b51ad7bda44604ad4759e1bd7fda716d52a5102f29c356e58", + "python/sglang/srt/managers/multimodal_processor.py": "d295ce69c2fa2c5eb6940a28609ed913fef980f64de6af30635292c250875f0f", + "python/sglang/srt/managers/overlap_utils.py": "7762a4e463a8052fdac22e76ba904cedb35fb2deabda687849724a354bc891aa", + "python/sglang/srt/managers/prefill_delayer.py": "ca1bb87ae714a3329776965e7a47b53f2bfe1d411beac627e2af50721c823d04", + "python/sglang/srt/managers/rust_server.py": "ee6ce020ce33911c5445e21c8daf074e864d2a04530ca3d037bcabd5da9b13f8", + "python/sglang/srt/managers/schedule_batch.py": "4965156c669a536b40250605794de9d9aa7582fde71d188ab2ecf22e766e755a", + "python/sglang/srt/managers/schedule_policy.py": "7fa154986e574cabdbc341875401a59a7a388f94c548f11bf3d2bd7badc131d4", + "python/sglang/srt/managers/scheduler.py": "8bc11f8bd2ddef96bf32adc1fe5b52c3929e23538cde1047914eb336f3994595", + "python/sglang/srt/managers/scheduler_components/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/managers/scheduler_components/batch_result_processor.py": "22bd0ccfb1acfa4374a977ac0f104cee55652e6c5449d7c272d6775718828f7c", + "python/sglang/srt/managers/scheduler_components/dp_attn.py": "30c6112257c01bb4499cb3112789ada3cb9256e99c14881016be024d8876fc9e", + "python/sglang/srt/managers/scheduler_components/flush_wrapper.py": "5adbcdccd5fd6de5760735126fb83f9f578ea6d2d77c14dad374213ae0f2a925", + "python/sglang/srt/managers/scheduler_components/idle_sleeper.py": "031821b3f74435835dd9d40007eff027eff912375eeefbc7724210150f505082", + "python/sglang/srt/managers/scheduler_components/invariant_checker.py": "2d3ad1f4bb760747f4a09a674015c7f8fbad4623150add58612660034e545d66", + "python/sglang/srt/managers/scheduler_components/ipc_channels.py": "ec73fc4546bb75991daf1abf5be1b4f0fc23770eebcdb704ea0973e51285699e", + "python/sglang/srt/managers/scheduler_components/kv_events_publisher.py": "600d51ae91978322fbc8d3cf8b8f136b7f6f9eb803819e90149ad69698dbcae7", + "python/sglang/srt/managers/scheduler_components/load_inquirer.py": "2d27be46e1cf70ed4164dd28ccc0b3a2be8967780a12a4e83b36f0a288ab2c1c", + "python/sglang/srt/managers/scheduler_components/logprob_result_processor.py": "e155923884c924cc6cc98fe9ee7800f093f0d8b755be27599902992cdab1725f", + "python/sglang/srt/managers/scheduler_components/memory_usage.py": "82844af91ffed25cf1468ce3ee9afa4bf7d170432d6e7a3242971bb886848e40", + "python/sglang/srt/managers/scheduler_components/metrics_reporter.py": "88ca2f1f7ed43b9f226393643a66c39e6146eea8ef5052ca617fde32cfd465a3", + "python/sglang/srt/managers/scheduler_components/new_token_ratio_tracker.py": "865da371d324f57117f0aaa45cb53f15ffa22a32a458c3ff1eeacdd95c3f16cd", + "python/sglang/srt/managers/scheduler_components/output_sender.py": "e1c4e17a45a69157a73396f2d46099cef2a48ec8a2c86ee652f460e58eef8611", + "python/sglang/srt/managers/scheduler_components/output_streamer.py": "4f069fbba82a77360fec29330edf5f6cf3740960984c5e1d01ef4e385c90ecaa", + "python/sglang/srt/managers/scheduler_components/pool_stats_observer.py": "a9cd71a9cd38c4178657c5ddd433cde55f4abde918bb512f2b61441f9b88089f", + "python/sglang/srt/managers/scheduler_components/profiler_manager.py": "b1fdbdf4f00caa3d2ec810f0e4245ef44dc1327ad3f9833a1aa2ad726a4443fa", + "python/sglang/srt/managers/scheduler_components/recv_skipper.py": "3468d334af6a624769a8888d36b2b477270d5faae9d8b3a28af38e4cf31bfef2", + "python/sglang/srt/managers/scheduler_components/request_receiver.py": "899ac13dc79cf41a7582357298a40a03fa4f7d931955ddbc89705301916b4d5e", + "python/sglang/srt/managers/scheduler_components/weight_updater.py": "70944138cb88d88feddf9f2474684bc8cf7739484efef367336efc0e2ed9411e", + "python/sglang/srt/managers/scheduler_input_blocker.py": "edfe07948d75b3871bae173997914397878aca66aba0b42ffb8e26eb7e97102d", + "python/sglang/srt/managers/scheduler_pp_mixin.py": "89027f3bf1e37a485b8f2c9a96b62b1ed87879efaced1e41071179ba76b025a5", + "python/sglang/srt/managers/tokenizer_control_mixin.py": "e7f1ccacd6c243e1b5630f8f04b2fa444a6cc5635a7e8c2036ab0663ecb23091", + "python/sglang/srt/managers/tokenizer_manager.py": "591d5bf0ae4ab5009b8dfa37bd4d496f62b40cf13ee19bf7c867804b8a263bc8", + "python/sglang/srt/managers/tokenizer_manager_score_mixin.py": "1afd43f14f2521bc03c7d7e5f6fb839c32a250314922245d2eb8100a11022419", + "python/sglang/srt/managers/tp_worker.py": "c39b0b3363a57612caf73c600c07f9e67e56ae3ad939048eba7e856002047e59", + "python/sglang/srt/managers/utils.py": "23967b5942bc893d843f39028bb6d091c678125bc4378fa09499804b26f3c7ea", + "python/sglang/srt/mem_cache/allocation.py": "5012c58e1ca32dd28c97917195c87d80927eed55d60eeccc67f436f822b42c24", + "python/sglang/srt/mem_cache/allocation_sizing.py": "093f09c8ae88dc4008589195b97ca6a200e22b470839447800adde6ec8ff5400", + "python/sglang/srt/mem_cache/allocator/__init__.py": "c89351f05411121d0aadcb565ee848d78dd91726a61533f58b43cb7eeae2bddb", + "python/sglang/srt/mem_cache/allocator/base.py": "8159576fea298f977deb1535da9f42b4386e9ece2d663a2258aa97210d5f79ce", + "python/sglang/srt/mem_cache/allocator/hisparse.py": "ec75a199e4da40fc03bfb59f28bc0a1c5bd41b036e2e1cb54b81b1a0f9944fc0", + "python/sglang/srt/mem_cache/allocator/mamba.py": "b3d4561b7f96aa55f615c491b3d5a8c8e72e156fd7e6cf639ee7f87cfd80674c", + "python/sglang/srt/mem_cache/allocator/paged.py": "e58478ecb416a3a3bad1faa07863fe084f17bd3b1feb0f59a26b72b500a5a429", + "python/sglang/srt/mem_cache/allocator/swa.py": "1791c173ec8bf42b7a2ba9d5cdd1dbdbfd0c01b7de98e3206af9a178a3cf928d", + "python/sglang/srt/mem_cache/allocator/token.py": "07372fc82e58c58ff9fa749aa6573b0b1c9d7eb59d5e8c779c3b198a4da4370e", + "python/sglang/srt/mem_cache/base_prefix_cache.py": "d61f7ec0793661731f6150cdbbbb861428740e5697675beb7bcc67766df68791", + "python/sglang/srt/mem_cache/base_swa_memory_pool.py": "d37f2318c1d1fff9a0d6b7c17439ffd7733fb5a697c93dbc2fa31ec40803e280", + "python/sglang/srt/mem_cache/cache_init_params.py": "68ee503d8d1a908c338e0bb7f0bbdf67fd239ccf7be9fcfb6c94fdcf1278fbc2", + "python/sglang/srt/mem_cache/chunk_cache.py": "4819830a78b66d94427e235d20883561cb2a965764407184452eeef56f38b549", + "python/sglang/srt/mem_cache/common.py": "8e822206137dd6bfdf1c67ef02b93505c5a024778aa284e9a1709721c958e276", + "python/sglang/srt/mem_cache/cpp_radix_tree/.clang-format": "dc2a6c4be9a0951daedae7d3ba0955f2062b4f05ae165d812d1e8d3706ef6c15", + "python/sglang/srt/mem_cache/cpp_radix_tree/common.h": "cf196b6f42e2930229fb757f0cfe9a22680424b878bfdbb06857a76e0adec4d4", + "python/sglang/srt/mem_cache/cpp_radix_tree/radix_tree.py": "b50669cfe1fa1f134041ef6662ab7a697f267c3672bbf7db25370234af8db353", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2.cpp": "4606cc83205e6fa0a00f53b4c241caade013d993144da5b263ae2ad050819704", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2.h": "443969b06253f7fa1e33d70b51ff4595a1f81f7d1a510726bf2e051c1edade02", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_binding.cpp": "b3c07ed96bbde446ee58c4688bb1c19053f9855e1ae0e15d2ccfe1088ac74204", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_debug.cpp": "922cd38f2a90d697f9cdba70a90fe7fc9dc300cc7ee52b14eb3cee8cb6024c95", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_impl.h": "9dd2617f47568d4f57d96faeb8eb5031c9a148e5720c648cfe21350330a5dec2", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_node.h": "eed6c36b2201eaa0e89339161a9227446e51911bf2328a067ac629d7ef3a8ffc", + "python/sglang/srt/mem_cache/cpp_utils/hash_binding.cpp": "f4ab69e2e99b2b11dd19588bed5011ce737bf9fdf639669925d4119e0aa24b2a", + "python/sglang/srt/mem_cache/cpp_utils/native_hash.py": "8ae66bf8147fd0daa518a1519028a5ce3504cdf5616341cb348a71b873251924", + "python/sglang/srt/mem_cache/deepseek_v4_compress_state.py": "9f993de84546782d529403974665e3882defed42bb0b0459f833403cbe816ce3", + "python/sglang/srt/mem_cache/deepseek_v4_memory_pool.py": "bf3a94483cf099111460611cdb83addbe740b970613177df4c803a50b3468451", + "python/sglang/srt/mem_cache/dsa_cache_layer_split.py": "432d2fd880163b5c8633dd4e5f6527c658b045890c9a6e90d40909bfc153102e", + "python/sglang/srt/mem_cache/embedding_cache_controller.py": "0fe05d298032b7dd375e95a3daf0241a4333739c72002f4de680a30d0ae78b9d", + "python/sglang/srt/mem_cache/embedding_store.py": "bc359008e336099772b44961e0dd34b5a3169d5c0467679aa09112c53bd3eb8c", + "python/sglang/srt/mem_cache/events.py": "02a73642033edf74ae881c32139d8afe7c38b650424661ed8868c0c8f6c42fcb", + "python/sglang/srt/mem_cache/evict_policy.py": "8e839aa19244b870db52577ed06c7e1b4c02302813d33cca1f2d49ff190b929f", + "python/sglang/srt/mem_cache/flush_cache.py": "19873198d5e1e21b0ca457cd3ae093a4a8a55bb82e6704ed020feeb1578cdc9d", + "python/sglang/srt/mem_cache/hicache_storage.py": "de92d6c7228f3c93d889e1c054f867235055f74663b2808c5456e53ff040be86", + "python/sglang/srt/mem_cache/hiradix_cache.py": "6defcfe6b90f8205078aa08a605ea560d708d81d5121445205408d39cbdc846a", + "python/sglang/srt/mem_cache/hisparse_memory_pool.py": "65b49da21e56f544d4fe8abcf1fe5a91d03f68ef6e5c1a06f3ab45817c362e65", + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py": "bc06826aeae69fa9702469d6a8606fba6efafe66433e402f9a8fd488dfdb1096", + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py": "a348509b43c64ee979d838dfd7c6ee3350b6617edb608ccb0f593f7af86e7140", + "python/sglang/srt/mem_cache/index_key_cache.py": "740533e40dfa061c2b3540d403caeb079ff5c1b135ff4df23b66eeac05f00f2f", + "python/sglang/srt/mem_cache/kv_cache_builder.py": "7eae73259a8c52559b1b7d95ea9600fa70155da6e3a1fa8c2ba094d02bf8c058", + "python/sglang/srt/mem_cache/kv_cache_configurator.py": "06ea5d33aead6b058d64665e0282ee7f5d89ccbb1c221b229b2610f570121099", + "python/sglang/srt/mem_cache/kv_cache_dtype.py": "c104b125ff723c584bfdcd368a2129a9980e10381de0470c22522d4a0ae55f1c", + "python/sglang/srt/mem_cache/kv_vmm_backing.py": "c34c50a50260abebad49ab1b9832b2ece22a5a56dc66f8083c2220306cf11cc3", + "python/sglang/srt/mem_cache/l2_transfer.py": "d78f93396f2798dac12dc42e977592f24326c3445f253c671fa64e84137193f0", + "python/sglang/srt/mem_cache/layout/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/mem_cache/layout/page_major.py": "0ac5254ffb984db066285ce9508091e9f24dd2619bed631d7b0e7f3841959b84", + "python/sglang/srt/mem_cache/mamba_checkpoint_pool.py": "00be6d6ca4bc058ce743f08e83037b4b4a6aa6f62795c95bd70c332d8117d318", + "python/sglang/srt/mem_cache/mamba_radix_cache.py": "c90dd4f835b273673b9e2289624023469719041b6499b779818f3e5f4da455cb", + "python/sglang/srt/mem_cache/mamba_slot_fused.py": "291c34436e1d82b97f82a8ec8afe8b7999692c9be677f30b1a98f306e8970522", + "python/sglang/srt/mem_cache/memory_pool.py": "ebcb705f37b6f78cfb730ea43c767538a4f63b719a14336f5bbac71d20ec3f7c", + "python/sglang/srt/mem_cache/memory_pool_host.py": "fd2b196b9bf39ae93f96afce6748ae2571c26308dbc150da452dd055f3b03125", + "python/sglang/srt/mem_cache/multi_ended_allocator.py": "30415f31c66043aefe60f92278f8f1fa16ef2b1980fc45baee70766a536b5d1c", + "python/sglang/srt/mem_cache/multimodal_cache.py": "f1415edeb4554534de2648e2ee1ffacde06236a7b0028f29f94b9b94a954b739", + "python/sglang/srt/mem_cache/ple_state_pool.py": "a99b71c6e3941c060e4126c212fa9a941545d4d6614af7131681dc9b696515e2", + "python/sglang/srt/mem_cache/pool_host/__init__.py": "991f35e8e919d7b9c7a9fbf9c418a1087102bcb22dabb764aaf95ca4af071b86", + "python/sglang/srt/mem_cache/pool_host/base.py": "3a04fb9805312de59422e262c966713116f866ca836ef8de440829930a45a809", + "python/sglang/srt/mem_cache/pool_host/common.py": "b98f0399385093044562ceece5e04868e4ee5867aa36b89f36d0c2177cda6e15", + "python/sglang/srt/mem_cache/pool_host/hisparse.py": "0f94fd23d74613556ac5dbca59d8399fd3c5f6cbfc8758775bedb5fb5b8f9e01", + "python/sglang/srt/mem_cache/pool_host/mha.py": "1ce14fb16a447e63575bae99aa2845604c5bd2a403e518bc448a73044fde2f9a", + "python/sglang/srt/mem_cache/pool_host/mla.py": "977fe584060f0ef377949fd9bf7e060241f4aa38758299d4a401db8f1c9bf9db", + "python/sglang/srt/mem_cache/pure_swa_radix_cache.py": "ad4d75c308d0767ade0c6113081772a5f4f9ea49ab0e675ed899bcbed7ffe53a", + "python/sglang/srt/mem_cache/qsa_kv_pool.py": "85e7687daee0af9506b4c0e8840ec5b4c870be6f6930a3c210cbd31bf1f84412", + "python/sglang/srt/mem_cache/radix_cache.py": "c3ddcce2da58c455ea949d3214d77a2afb841de96ae7e5bf77a2730ec9d6299f", + "python/sglang/srt/mem_cache/radix_cache_cpp.py": "28bb1289e1ec45f4974638eec78f6fe17b963ae1a7ff6316c175b7d679e38e12", + "python/sglang/srt/mem_cache/registry.py": "0e09618b4e88fddca91540ea8813eaa35507ccded56f4c287b5b4b26af5bc00e", + "python/sglang/srt/mem_cache/sparsity/__init__.py": "cb5b7692800a739f4c3aa99cc4215b7aa437337bae2d7ef63ab9c703253e751b", + "python/sglang/srt/mem_cache/sparsity/algorithms/__init__.py": "f2d8e139958b5165f52acce6bd3a3bb04352b0ca610d3008fdfa6d9f26857977", + "python/sglang/srt/mem_cache/sparsity/algorithms/base_algorithm.py": "a805e5e0a2cc0e54daa530a52f98dffe949a3acf08b413911865c342ae9aaf4b", + "python/sglang/srt/mem_cache/sparsity/algorithms/deepseek_dsa.py": "5b70e38087383704ce8ca09800ffb37d8a74d88e55470750a9a1c05f07d3803b", + "python/sglang/srt/mem_cache/sparsity/algorithms/quest_algorithm.py": "a3a57a8621e513f982b56c45b5bf294bd9943e72fb5c768354fcddf97f673780", + "python/sglang/srt/mem_cache/sparsity/backend/__init__.py": "26273f1622afcdf6ba6ca5d8b329d3d58e3ded32c01c4635938107d4dff1305f", + "python/sglang/srt/mem_cache/sparsity/backend/backend_adaptor.py": "507274b969655308c2b8700417a787616c4a8619f0a45a4effcafa6a2224e333", + "python/sglang/srt/mem_cache/sparsity/core/__init__.py": "374d1108ac4dc013d0ceb0ff8c72f0fd6e826dd88aaa94576317dfc15b89ac9e", + "python/sglang/srt/mem_cache/sparsity/core/sparse_coordinator.py": "84559fc9615580a1245494cc3bd889abd4f960ea2904ca5dbe4a8aa336499311", + "python/sglang/srt/mem_cache/sparsity/factory.py": "174760bd209f84a68ad4c6ace33faeda3f4ff1cc307b5fa8ac07c9cace4a1a64", + "python/sglang/srt/mem_cache/storage/__init__.py": "1c3cc715455e38796bcbb1e57cbe6d45de47500d3637de29f2ecc0fd56bc9e53", + "python/sglang/srt/mem_cache/storage/aibrix_kvcache/README.md": "419e5f2f02c3a0bb502247b4fe076a829e1232b32c2086cf9157b3fb366d3391", + "python/sglang/srt/mem_cache/storage/aibrix_kvcache/aibrix_kvcache_storage.py": "c9a9f64c8d81de9e6d35bf39db03579a560710454eea26d627466a4502562379", + "python/sglang/srt/mem_cache/storage/aibrix_kvcache/unit_test.py": "84c269f9c31d2ae308634046dace048fa0d8d74abb7081df98015573adae4f0b", + "python/sglang/srt/mem_cache/storage/backend_factory.py": "d0a64077ce4e1b27be7c831543efe9622a102da0ffc0850dd2c4c786c7774c4b", + "python/sglang/srt/mem_cache/storage/eic/README.md": "28b16c973377a35508835bbd728090fd44c481ea3f2c5d025fca2b0c4be38bf7", + "python/sglang/srt/mem_cache/storage/eic/eic_storage.py": "175a6fa0ad59dffe36717b8e3217fe20937a7aa179251aa35f67408d69227afd", + "python/sglang/srt/mem_cache/storage/eic/test_unit.py": "3df34fa4beb6e2ddb7b72560b664b9175a468ae58332b0b7f590fa65b90df36f", + "python/sglang/srt/mem_cache/storage/file/__init__.py": "211b5bf704f84f381c9d81b929507e05c9c4eb9955e1ae3f00a129e8a78ccc7d", + "python/sglang/srt/mem_cache/storage/file/lru_file_evictor.py": "9e590e144c1169d463102e9aa147432cf5fa9108f1f8936de1184903c79a1330", + "python/sglang/srt/mem_cache/storage/flexkv/README.md": "c16b85753ea2f6f6027fa027868a74c16ea311674df38837008e16c01f50e7bf", + "python/sglang/srt/mem_cache/storage/flexkv/__init__.py": "77b4c12ed0352f565f0a3caff7d82caa572975ffa9785626028743442ceae67b", + "python/sglang/srt/mem_cache/storage/flexkv/example_config_mp.yaml": "83d9734fe13ceeb9773850f679ba54f49ca36a313fe5c6a95691a6bda7fd9aae", + "python/sglang/srt/mem_cache/storage/flexkv/flexkv_comm.py": "a565bb687c22388a9d14dd13e3e93112d3e4a003825ad7358e296ec61320c89f", + "python/sglang/srt/mem_cache/storage/flexkv/flexkv_connector.py": "635e481bfcaef29a6037d482446bf425e327b33e4fd13804f1b400e48dc4e3a3", + "python/sglang/srt/mem_cache/storage/flexkv/flexkv_radix_cache.py": "0fc8bbd7859005f454b3ea73b8e41ddc53b621c1bde4fdd62adc910df8ff2314", + "python/sglang/srt/mem_cache/storage/flexkv/verify_outputs.py": "3d20a6b8847e85e4e2fa9a778a657213549900d24fa6b810b9ec65833f97c3b6", + "python/sglang/srt/mem_cache/storage/hf3fs/docs/README.md": "b9f28a67b99d882233597d65c7ba8e42784b2e87b5f7f168ea98187109fca62a", + "python/sglang/srt/mem_cache/storage/hf3fs/docs/deploy_sglang_3fs_multinode.md": "e9aab6a832ef9f4e47651a00dc1213b128d29189d5107e5f456db1fe508399cd", + "python/sglang/srt/mem_cache/storage/hf3fs/docs/setup_usrbio_client.md": "8506110b4ea9adeaff24e4f1f8e45b74c9d0404a5b0aa786f420085088fd1b2e", + "python/sglang/srt/mem_cache/storage/hf3fs/hf3fs_client.py": "df11b4755e499a76c827c901d7f964f2301eaac84e714eed5c44b6ee57726fc2", + "python/sglang/srt/mem_cache/storage/hf3fs/hf3fs_usrbio_client.py": "dcdc16ae6f9b1c3307afcbc6af17cbfd1a0cebe1e538b03ebfcf4755fc53c2b5", + "python/sglang/srt/mem_cache/storage/hf3fs/hf3fs_utils.cpp": "74360fb7198be8e161132bff1ae4e0ce44c3a418dc0f410af24a619e7ede6867", + "python/sglang/srt/mem_cache/storage/hf3fs/mini_3fs_metadata_server.py": "a7e00b06d02ef5ca801d064ac8d7547961cef81b49caa8dcccf6ae835eff678b", + "python/sglang/srt/mem_cache/storage/hf3fs/storage_hf3fs.py": "ed33f0ce269ababa2496498c22ddeccde48faebbd4f9c036bd09f510e5a03cdd", + "python/sglang/srt/mem_cache/storage/hf3fs/test_hf3fs_utils.py": "2fea7f6cadea4745d900917267722a4d9498ef7116975b45cee736b03ab7a4a6", + "python/sglang/srt/mem_cache/storage/lmcache/README.md": "8214e609b24428cc93e3a46ee8dd4e3af082eb6d188747f33b77a92dff43f123", + "python/sglang/srt/mem_cache/storage/lmcache/example_config_ip.yaml": "48de9bd2cf06ac6105305551b611e4ae9a2f36e21355866eaad98faac697e1c5", + "python/sglang/srt/mem_cache/storage/lmcache/example_config_mp.yaml": "882686e3a48242cea38a620cd0214f564efbf7d637312bf8a82ccbb652820ef1", + "python/sglang/srt/mem_cache/storage/lmcache/lmc_radix_cache.py": "e7a0c04e1e4deebff441569c9cd96f910620e82def99391266404e09813cb483", + "python/sglang/srt/mem_cache/storage/lmcache/unit_test.py": "e563e3777e705379b1856c36140f1b3ed2cee1b5714325b8bc9ab69b6b8479ea", + "python/sglang/srt/mem_cache/storage/mmap/__init__.py": "3d355914915afc1ebb316292a60ad0f55281c88e103505aa1d4d75e3be21073f", + "python/sglang/srt/mem_cache/storage/mmap/mmap_allocator.py": "68b043b8bf868846dd0990ff5cb98079a54c2d01283bd8152edff196c9954d69", + "python/sglang/srt/mem_cache/storage/mooncake_store/README.md": "e6e7f1adf5a56e9ca871bc6e750efcae5be4b540d66c5b70953e19cf625004ec", + "python/sglang/srt/mem_cache/storage/mooncake_store/mooncake_embedding_store.py": "7ec3ef1b2e98e2ea4b85e117ad8e8c705103fe2cea2b52096884ee219702dd30", + "python/sglang/srt/mem_cache/storage/mooncake_store/mooncake_store.py": "d8232dc281bdc849df1dee9dd77b8ff4582818b3d46b0106c79a6cbc3729d7e5", + "python/sglang/srt/mem_cache/storage/mooncake_store/test_mooncake_store.py": "16af85082ba8c65be637403fa1f94bbe2eaf9b9f9698eccd1180c407dec5ffbe", + "python/sglang/srt/mem_cache/storage/nixl/README.md": "56e0cec6167d1c6bd53f6b197a3a2417ac8bb48afba687bf79c0c12cddbdda75", + "python/sglang/srt/mem_cache/storage/nixl/hicache_nixl.py": "8d9109990e4bbb2fd0ad60dc676c4369fabbd946ab84cd32c6a093af5125797f", + "python/sglang/srt/mem_cache/storage/nixl/nixl.config.toml.sample": "65efaf63789842d6412aa78d508232ad7a62a14face2c7049da86d523b87beea", + "python/sglang/srt/mem_cache/storage/nixl/nixl_cleaner.py": "16bbefafaefa793d201d71656ed415fded5c2e465476e011cce7058041bafedf", + "python/sglang/srt/mem_cache/storage/nixl/nixl_registry.py": "aee7d343b1e91d8f13d769b0de1ea66fcb0536f0400415e60407898fc7550dfc", + "python/sglang/srt/mem_cache/storage/nixl/nixl_routing.py": "5c40bfcc8814cea19137574be69ce31a6554c4ca795ab4ea49156c8e55375c7a", + "python/sglang/srt/mem_cache/storage/nixl/nixl_utils.py": "6ea9a6f58601709d93a65a71c52c204b3d25e28198d0d37feb7a67c80ba67c57", + "python/sglang/srt/mem_cache/storage/shm/__init__.py": "b84dde8fa936064b55e4ff467296e0c6fba9ca8a0574e60320f1d7b0d16b20d1", + "python/sglang/srt/mem_cache/storage/shm/hicache_shm.py": "32f9658b5027b0d282950440a0d2da59ac78f3d995edf46b191142581e58474f", + "python/sglang/srt/mem_cache/storage/simm/README.md": "eb549638b8a964a378c36a8de6850bedd49afe7361b409e7c6b7d1a8aaf3ff08", + "python/sglang/srt/mem_cache/storage/simm/hicache_simm.py": "e0fc56ebbc248ee4ee8c2c3b02b8679e06c34b84b72ae3442aa6ec8ad996c825", + "python/sglang/srt/mem_cache/storage/simm/test_simm.py": "4dd5ef674785cecb33e0a7de504259b9db496d59de2923d491b1dbee5db4f297", + "python/sglang/srt/mem_cache/storage/umbp/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/mem_cache/storage/umbp/umbp_host_allocator.py": "f4b31ed2d77a6679494aa95b112844c7934ea7531490ccd552dff6edb911a987", + "python/sglang/srt/mem_cache/storage/umbp/umbp_store.py": "a05076928164521278786f5ff5d83b49926dcdd1c36d186548a29908d5f8027c", + "python/sglang/srt/mem_cache/swa_memory_pool.py": "be524192527287453eb09ffce1d2b1e457a454bc18a6029e4c80dc3174a531a9", + "python/sglang/srt/mem_cache/swa_radix_cache.py": "ce38277491908c28457a39a53a90485e3ca8c56c6d579f0ff9b598d54c38b76b", + "python/sglang/srt/mem_cache/unified_cache/__init__.py": "dfe2244f37bf6c26b2b8473d6c0317fa4996ec16a1e98afb8dabd1ed93c90efc", + "python/sglang/srt/mem_cache/unified_cache/cache_action.py": "6e1ff116fbcbc77954e12bfbb8d525e9d60d26aa2b95d54f19920c3f15f9ed52", + "python/sglang/srt/mem_cache/unified_cache/component_type.py": "7d369ff5f0c9b84c0f0f73910357e7929b4bda6fc1287f987522a83f8c893376", + "python/sglang/srt/mem_cache/unified_cache/components/README.md": "28ae5e66cc56368593cad72793b70ab61e5798d586300e9e1922b5be2e9ca586", + "python/sglang/srt/mem_cache/unified_cache/components/__init__.py": "bde842f9c2d5054e000281d301ecfa1e934bef65628a77fdb6c20172c0f0995c", + "python/sglang/srt/mem_cache/unified_cache/components/full_component.py": "edf7ff730f81db8d2d322d54329f74953175cba5745ed55ab6e5d24115706d66", + "python/sglang/srt/mem_cache/unified_cache/components/mamba_component.py": "9bfcb7a20af48c2fce8cb63537db54cb4231456d9c04896370e290611e0ba799", + "python/sglang/srt/mem_cache/unified_cache/components/swa_component.py": "2db0eeaf673cf690460f9c859fdc35eecbcf3ddb9396b21c7a7502f8925d6b52", + "python/sglang/srt/mem_cache/unified_cache/components/tree_component.py": "e79eab56f3803fa81181cfa4d6a42d7aeba95b5d89a1420195c4003483bbad0e", + "python/sglang/srt/mem_cache/unified_cache/session_ref_tracker.py": "21353af6b20585132b65e3952dc5ce3f2450780db1fd8d0d809e184d3fb37007", + "python/sglang/srt/mem_cache/unified_cache/tree_core_registry.py": "d767fcdc2c2d7ec40f541be897a4036d55fae7a40c629217cf72ddacf1bb7359", + "python/sglang/srt/mem_cache/unified_cache/unified_tree_core.py": "2b66bd6c8105c12d8b57b5d6c1abd3a87136bfaf0524fd9606c7746c81327aed", + "python/sglang/srt/mem_cache/unified_cache/unified_tree_core_interface.py": "cbffb202a3a4bc2e91b184c19551ff1a310eaebdf70fb8fe93e52c5ac8c3f9a5", + "python/sglang/srt/mem_cache/unified_memory_pool.py": "143f40588c2b88929dfc5017281373413827026ee79e6870b703b0b999946348", + "python/sglang/srt/mem_cache/unified_radix_cache.py": "6e29ffa01adb96c9d400331850fe60b054cd83c980f033d36552e369a5d5c6ce", + "python/sglang/srt/mem_cache/utils.py": "9310f130db27f7277ad0295a02f82809f3798c4e6ba0ea828990a76809f7068b", + "python/sglang/srt/model_executor/cpu_graph_runner.py": "253c23bf2abe2642763e7942a973e4456c49733253c45b47e54c936fec1100a7", + "python/sglang/srt/model_executor/cuda_graph_buffer_registry.py": "28fbde4e1e9f2824928b29283690fed9e7f38cac435d416f355fb92d8ea346fd", + "python/sglang/srt/model_executor/cuda_graph_config.py": "a131496f543eb354e91ca818b0f3863918da51aadae8e8a6fba087edd30cec76", + "python/sglang/srt/model_executor/forward_batch_deepseek_mha_mixin.py": "4d46d49221749cff5289c262d8acd6e2f5f3d44db1a1d7ffabbeb32fd9e6f05a", + "python/sglang/srt/model_executor/forward_batch_info.py": "c5465206368475dd2c1887de893679fa171793ee00eddaca8ce6acadc9237627", + "python/sglang/srt/model_executor/forward_context.py": "63900e43eaf683bcc50991e56dac6d194566b9fcef2ed452ff8e5818e503d2d0", + "python/sglang/srt/model_executor/graph_memory_usage.py": "e98c9a6d7c4af6eff1302e0a592cd1724098b043cbd47cdb0c25780d3058ae9b", + "python/sglang/srt/model_executor/graph_shared_output.py": "aa7b7bfbf903584089ba64f8756a541343edea0c8fcce5f6d49e608e7c0159f1", + "python/sglang/srt/model_executor/hook_manager.py": "899bea28f874cb7a44b7d10fcff50814b6f99221e31fe4aabd073227f3c24073", + "python/sglang/srt/model_executor/input_buffers.py": "5167fe0294d63ee7dcb4f8c5bf9bf4430c838666c7b00f670c8c57a50d9e14e3", + "python/sglang/srt/model_executor/mindspore_runner.py": "a2d5affc4c2d97069a93f17b215a870d1b32ab75479e47adfa73797b666e0bc0", + "python/sglang/srt/model_executor/model_runner.py": "d93a427b8ba77128ba0752adb990a1d69a489e3249c189ee9bca67583ace2069", + "python/sglang/srt/model_executor/model_runner_components/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/model_executor/model_runner_components/attention_backend_setup.py": "bf01b845e22471e19941168dad276e8f429ca302e7cd59ec4c0463defc5bbda0", + "python/sglang/srt/model_executor/model_runner_components/cuda_graph_setup.py": "ca36d4b440ea7a67f42cfc1c253a292f5dd039041ea24cc6d9177ce58aed3205", + "python/sglang/srt/model_executor/model_runner_components/kv_pool_runtime.py": "ab82c8793c90f0fcdbfdbe4a9edaa28bc760c304c4a76cd6b03a96f20263d061", + "python/sglang/srt/model_executor/model_runner_components/layer_setup.py": "235c9ecd3a707645fd3aeeb54602c4233d23cf23a216e16ed8ef7cd6be2f4e4c", + "python/sglang/srt/model_executor/model_runner_components/load_model_utils.py": "c864d5fa51311a9653a609bf23a70f21d2d6ea5c1556c5287adbdbb1b3c4ad4f", + "python/sglang/srt/model_executor/model_runner_components/misc_utils.py": "673bf8a3feb784c9054c9865d2c3441f34039e43d84548928c2b4b7022f57112", + "python/sglang/srt/model_executor/model_runner_components/moe_ep_setup.py": "5776252dc6787df809c41e2c2b2130b153c76bee773ac814d673be782d6b2d0a", + "python/sglang/srt/model_executor/model_runner_components/ngram_embedding_manager.py": "050718d06087e1586d220654fd91916c4dd1b0494a2312baab768bc2c3e9d797", + "python/sglang/srt/model_executor/model_runner_components/remote_instance_weight_transporter.py": "092536c27b0f72216170708dfd3ab6edea2e057f9e4a5bfdaa8fdaa17606684e", + "python/sglang/srt/model_executor/model_runner_components/spec_aux_hidden_state.py": "db31c1d76466c6f99e5acdf9483a2a6beb4e6d8a6d96a07c17646257a61a7e9f", + "python/sglang/srt/model_executor/model_runner_components/startup_weight_load.py": "cd502780948edcffc33027a4b324a37da14630468b1c5ed0cd22bf4515bc4efb", + "python/sglang/srt/model_executor/model_runner_components/weight_exporter.py": "de472de90137203bcd00585e400a9200b62f2b78385ed9296fc0d00ced9e4487", + "python/sglang/srt/model_executor/model_runner_components/weight_updater.py": "564f42a67afa1d0f37a0049b8ba6d444808bc9b3ecd536d071feab125358df81", + "python/sglang/srt/model_executor/pool_configurator.py": "2bbd8233d29e1e748b4600f902a9911db1de4a14d727f30d6dd3fdf4083624ef", + "python/sglang/srt/model_executor/runner/__init__.py": "97fa36fe04f0627ea70570f30b63e84dd8eb5945b8043d087cc81f7e4ff949c6", + "python/sglang/srt/model_executor/runner/base_cuda_graph_runner.py": "2f64791e0a5056a248126e306b4a003b510ecec66d42bcf62e52f7801ba23ac9", + "python/sglang/srt/model_executor/runner/base_runner.py": "7703c46be36a5e5c04b6a0d99117b58cc007e578c61effcbe968ef8cac90adc3", + "python/sglang/srt/model_executor/runner/decode_cuda_graph_runner.py": "96a92a7c60a8ec81c606721ec7d5cf7588173a55505e58f7f231757a056029df", + "python/sglang/srt/model_executor/runner/eager_runner.py": "40168d097921768244166dabd3506e9f136ef7dec1455e7cef927978c790c351", + "python/sglang/srt/model_executor/runner/flashinfer_autotune.py": "a719df49227f1c16725ee08b3653ce533a231f202f026eb0abf6654b2230a5c4", + "python/sglang/srt/model_executor/runner/prefill_cuda_graph_runner.py": "d0a020ec366e536f80357c749a9653cca00202da0019f890d4a205e783e6e875", + "python/sglang/srt/model_executor/runner/shape_key.py": "11f5b0c097aa4041c9b52f83422760394b039eda9633862035ba09cd7b5c3bf5", + "python/sglang/srt/model_executor/runner_backend/__init__.py": "0ca105fd3561122d1dfe030672f9ac094ef000aafcd3109f565ce78d8e1b05b8", + "python/sglang/srt/model_executor/runner_backend/base_cuda_graph_backend.py": "57fcbc83c10b8e83dd60cd3da1cb7e2a58b19ee0a390d80ae921ed24bcac4ecc", + "python/sglang/srt/model_executor/runner_backend/breakable_cuda_graph_backend.py": "e64520232bb15bba64aaa98bf89fdd34d25b13e1ae1190caeb25b98ddc4e6f0d", + "python/sglang/srt/model_executor/runner_backend/cuda_graph_dedup_mixin.py": "9038ca91df07fd957ee910ba6ce8af10da36608da01331591a391bdc8e2c535c", + "python/sglang/srt/model_executor/runner_backend/full_cuda_graph_backend.py": "f765293a501591ffa5a108cc73ea3efed8c90fc4a947021602a15d4248ee5c12", + "python/sglang/srt/model_executor/runner_backend/tc_piecewise_cuda_graph_backend.py": "66414526bedeed4b085d691410507b7c3428b965d93e5ca4108ad004d6704ef9", + "python/sglang/srt/model_executor/runner_backend/utils.py": "c0deb930798f6fd63e4a7955a850c0b6f866868502da1f45269f63b796c1c124", + "python/sglang/srt/model_executor/runner_backend_utils/__init__.py": "7b7119efcfd59dad25698a73771656856e533c0e393b073fd3ad0afd38f34279", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/__init__.py": "7cc27ba46d122dfe8f37ff11f02223e4fb2cc5577165a5d6d4dabd7b023488c7", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/breakable_cuda_graph.py": "730d8c0963bf7752e0aa3094f76046424ee836cd1067cb9d8e4cdefcced5c50a", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/context.py": "f7cf9d819d872d4c0d3c0201ba9853939e4509ac8309445ba9f75aefa6525729", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/cuda_utils.py": "808b8f470974294317589f4dd914d0eb7e3087d1e81bb4465f19f3dc0ac86b31", + "python/sglang/srt/model_executor/runner_backend_utils/tc_piecewise_cuda_graph/__init__.py": "364c2cdfabfc7c1e746f87aced897c54f10790fd5a05c4f9100d342ab6db85a6", + "python/sglang/srt/model_executor/runner_backend_utils/tc_piecewise_cuda_graph/context_manager.py": "1f51ba025ea2130b9c13483dabd1e505edd75bae61f9a05d22bb8273ae238d95", + "python/sglang/srt/model_executor/runner_utils/__init__.py": "e4d428f53b42efe3a95446bacf1ee7d7828e66179d1368020e67ee70e723bcee", + "python/sglang/srt/model_executor/runner_utils/buffers.py": "b330f13a2f7bfaefe69c4fe39024fa64357ad963113700389180d7821e29e3dc", + "python/sglang/srt/model_executor/runner_utils/capture_mode.py": "539b4f62039a17c5e5e0a0637757d04de3cfda83a5ed37f611c2d5be2e4795db", + "python/sglang/srt/model_executor/runner_utils/deepep_adapter.py": "d97ecae40b3ce131994459af95ab425cec058e74d78b54ee7ed405d11a57c1f4", + "python/sglang/srt/model_executor/runner_utils/pool.py": "f271c959b63c5925e0784f3232dc7babce2b2dd9eee525a18b58fd60886eea54", + "python/sglang/srt/model_executor/runner_utils/shared_read_event.py": "4dc2cbdb575719dd7b604977116272ceb4f95c356f48047123deac2773faae83", + "python/sglang/srt/model_loader/__init__.py": "8cfa1f43a634864baf70c664ad8bc911a9da50a1cf84a7942f5187bef477ce00", + "python/sglang/srt/model_loader/auto_loader.py": "4401654e17fd8c9a65bc15bac7f4786d7fb37eb95fffb9f747339ab57ff5b173", + "python/sglang/srt/model_loader/ci_weight_validation.py": "73c825b8435845663dc600a456de9e7c416626ce37c7c85331eec77a87b77881", + "python/sglang/srt/model_loader/gguf_name_maps.py": "281feaa82e79d805d58ba68ed6dbe6287db3515300ab3cbdd8e397cd44bdcdb9", + "python/sglang/srt/model_loader/loader.py": "5746f08e47e8a21e173a0df6036a9c1d58d0ffee5d392ef5361deb7d77d0a539", + "python/sglang/srt/model_loader/remote_instance_weight_loader_utils.py": "6e4743a6715a7a24bd854144b9d9383fd6479da8ca39991845f4e96d5a5c6b2a", + "python/sglang/srt/model_loader/utils.py": "7151f2b4092d14cb13a68ec645f386e024f4919eb22dc52fe72052da01419834", + "python/sglang/srt/model_loader/weight_utils.py": "1759d4feb63dc1e41f509f16c4d46d2f00a175fec6f5efda1fb5a7501394588a", + "python/sglang/srt/models/afmoe.py": "51416d24e54e8686c2a15a08ad211dd62fa281b5a9ffaf7c32461d44ba69771d", + "python/sglang/srt/models/apertus.py": "5f3f741d622c74475de0a2788a364728d933ac98e72fb3b061e643e702bed800", + "python/sglang/srt/models/arcee.py": "00d5599d470e993a6b3308dc0ba9231c386d45cbff60d51d65957c0f51e1007f", + "python/sglang/srt/models/baichuan.py": "3a8ea172c648f8e472012dd7c6a68e02b4df34bbf0d2d36527aa35c6542b0e00", + "python/sglang/srt/models/bailing_moe.py": "c5052c1d24a805a78623d89f32d164a50db75167b177333b682814b3473c3599", + "python/sglang/srt/models/bailing_moe_linear.py": "366d86420d3811c7a6b084c7b4280b2d994e3b2f058df4918a83a452bb66acfe", + "python/sglang/srt/models/bailing_moe_nextn.py": "d33076e60f6801ea42e5e6f2ca3a97e449bf20b2ed3d8ae930726aa2490d31ba", + "python/sglang/srt/models/bert.py": "23b157b2a5d90c24c7ced6a67909120d1d0759fe5b9d518c15bb29ee7e4240aa", + "python/sglang/srt/models/chatglm.py": "76f9c49d9b4cba67d244841774449485a8c98201402508fc9cbd2d7efc07d302", + "python/sglang/srt/models/clip.py": "0b3851d2381bc2cedda81d985f18875414f9ccd6844958ddd556b8fadc1cf2e9", + "python/sglang/srt/models/cohere2_moe.py": "bba44f58ef1ec55e1004d8ddbf99950eae69806f3a061c102a45fcd428fcffa0", + "python/sglang/srt/models/cohere2_vision.py": "4350018aa1c8f8dee60024ff48756ec7b88a1d906b35263308b666772d7ea346", + "python/sglang/srt/models/commandr.py": "a80d35171cbd8f87dfe2a1832440c311c340ce06ac8c66324a29afb1c915cf2e", + "python/sglang/srt/models/dbrx.py": "9f0d6d344cd10eb4f810d042137ffa067b547f86a1a82f9c4882b959f62d7814", + "python/sglang/srt/models/deepseek.py": "7f1e7743b734acc16f821d166301015120bd6e64242464d326d5c3a38883c830", + "python/sglang/srt/models/deepseek_common/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/models/deepseek_common/amd/__init__.py": "91337352ff5bde7bb2d74116c6beabf628948ab03fe055604376861e3486bb19", + "python/sglang/srt/models/deepseek_common/amd/deepseek_v4_fused_mhc.py": "83d2a21a47f867c8816c6e60aac17e435f0b212946838d280dcad99f670af91c", + "python/sglang/srt/models/deepseek_common/attention_backend_handler.py": "0d379aed9bac29ccea54361ffd22ffbd4853c9008f70a8d75b06b6a6ebd8a2de", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/__init__.py": "4907531368605837fb09f3579dd648ce6a27cbbbd2177ac69629a1f6705dbd37", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_methods.py": "4d66f9a7098eb22e1a94ba16ceb2865e18df578de9e9878cb3b314dcaa3d2e1c", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mha.py": "9ecd6362edf7dcbd6f9e49842450bb45295bc8efb605ade27082a8d7bd8807e0", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mha_rocm.py": "398271bf5d75636eb721987b3c73387be7ce17349bd20533a1fd259e0d35b15e", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla.py": "d54137d7bba213cbfc39365fbe41492a4cb26ac479236c77fd7bda55c7c4bc42", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla_fused_rope_cpu.py": "c6c3965d5d76a6a80ffca6dfd40229df38ce92ed8aae946eb2bd356c50cef268", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla_fused_rope_rocm.py": "9a7cd4113aa4c830aa4403ecf240fe13eecfcb84bca4100a762b571d07d70145", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla_rocm.py": "9ed9a0fd2262c22935879c919540dc96d3965bb0ef59d18e7460747ea8e52629", + "python/sglang/srt/models/deepseek_common/deepseek_weight_loader.py": "04a7e150912e7035c9ec538822367c4d9160235a4e23d94a2e526d1c6a4f9f19", + "python/sglang/srt/models/deepseek_common/utils.py": "7e9b06cce0501c1de11afc261e446c1d4edcd5f43b06c7f273ddf633c6893f3e", + "python/sglang/srt/models/deepseek_janus_pro.py": "c22190f341e785675a3c9d1b62441467f4da4bb7a4bf9095759c9e6e8d427deb", + "python/sglang/srt/models/deepseek_nextn.py": "462c7595ac80361c5988bfdda4a63a3cde0236983d2afcef11241216a210986c", + "python/sglang/srt/models/deepseek_ocr.py": "7f11abd028f5d48f178120e69c5dcb936f17fa48699c9eaf482be1771d186797", + "python/sglang/srt/models/deepseek_v2.py": "1ba2ffe6bf7537d0fcef6945f44b239883125a8bc382e86fa57885c135bed21f", + "python/sglang/srt/models/deepseek_v4.py": "304cdce90a9638804731c36a6f4f61f56c7d81f2e530f7bedd67bc5eb632e75b", + "python/sglang/srt/models/deepseek_v4_dspark.py": "0a7221f4405ae49b88983c97eaf97e073823871180d9080e6f7215a1206ef16a", + "python/sglang/srt/models/deepseek_v4_nextn.py": "d3139cd8f1dce2b2100f5eaeda71bb826abf4b5fc9dc20170147f6727bd24d30", + "python/sglang/srt/models/deepseek_vl2.py": "f2ec27c761892722ea7003e4f16f66b84786866551f77de4debb3961b4702a7a", + "python/sglang/srt/models/dflash.py": "b4c867543d80845bb621cb9bf93a0f9d8b09a6753f2a4d32e5e36d2122babc30", + "python/sglang/srt/models/dots_ocr.py": "b16905b043635f96ff09e70b0aa5e37a9b2bea2cb209b3539a365b45fa01e1e9", + "python/sglang/srt/models/dots_vlm.py": "13e74814ce7ae20cf2d37855cd429e3227b2d40269d301985f41ce1888d0da7f", + "python/sglang/srt/models/dots_vlm_vit.py": "03dfa21a2955d6d00148f97c40c9a840ca9613e33261b88911497954cc608f74", + "python/sglang/srt/models/dspark.py": "194759ffba28cc1e1d7d8ba28cb2f0134ec9f935eae34392bca2178c748b19ce", + "python/sglang/srt/models/ernie4.py": "2cbf4d45eb9ab1bc6b11ddac224de50697374bc8fcc21b711b1c73adb9e5604e", + "python/sglang/srt/models/ernie45_moe_vl.py": "0b0047ca789e1d763afaceb687bd1129eebdb0be26436e142ade22254adefc8d", + "python/sglang/srt/models/ernie45_vl.py": "cc7804e3875b65c7f541eb2676565616158fd019c8a6fcc6635119ae57dc93a1", + "python/sglang/srt/models/ernie4_eagle.py": "fcc548df82ad5df32cbe847406951d47800265931226e68853f4d97c17a16b77", + "python/sglang/srt/models/exaone.py": "a38b7b4bc8e2e2ec25108bfde1414f33fd585b06772aa376a10974799bf5bce0", + "python/sglang/srt/models/exaone4.py": "8d46719fc5bab2348a96c5d4b5ca481776c23e81421404c870a620633043d1d4", + "python/sglang/srt/models/exaone_moe.py": "d29647bf5a6756dd087a5b28a23704a461b10900588f0321bcf88fbca228e2d0", + "python/sglang/srt/models/exaone_moe_mtp.py": "71ae12725a3c92a14a679002cfc8c091de0f578dfbc2d263376e443c1502f544", + "python/sglang/srt/models/falcon_h1.py": "2feed2e456a7ed86f8d6827994df3514e5c94244dd675ef99b4f91c58cd63812", + "python/sglang/srt/models/gemma.py": "0fb42f0965d7b846b9e1b04cb63f76404bf77b9fd9db91c76c08cb940e37ece5", + "python/sglang/srt/models/gemma2.py": "aeef5821188e4b01c3e7d3569851ac9609de210d7988d7bc560a3d9c9b0202c3", + "python/sglang/srt/models/gemma2_reward.py": "2b89ab5090aa9c7832763ac38084c58095d1f5584b23c5acef29cf5287194ab8", + "python/sglang/srt/models/gemma3_causal.py": "e68b3840ebef0b986ab96653ee2bc4395192f330ddd2a95f0ad1e420912166a4", + "python/sglang/srt/models/gemma3_mm.py": "f35141ba77b106706574e8ba3f905e54e8210e5a7d7fbdcd1d2991d036a36e71", + "python/sglang/srt/models/gemma3n_audio.py": "8ac80a7e30395227986b0c54ea679d2f6b2c5e5cd83ea01b6a00c19cb71e982d", + "python/sglang/srt/models/gemma3n_causal.py": "833ca64d4d4571a6612d6cbd63c7260ddc1207691e8f0d835a58a9b6c017e079", + "python/sglang/srt/models/gemma3n_mm.py": "c5b0965ccf240ae0d6216bd4796a12a85d0f16920f5c658a5fefb1363137331c", + "python/sglang/srt/models/gemma4_audio.py": "08a394f05e3b87593346cc68f2c7c6fca5edd527a9564f2e25fbd0117dafb8c1", + "python/sglang/srt/models/gemma4_causal.py": "62a9e720bb0b339005bb96ff12a128c476936b9ec2764e529bbed7e3df4a6f5c", + "python/sglang/srt/models/gemma4_mm.py": "4e58c60a573f140afe9bf51d8023d909aac48ca906dca40bace4b37394f137d3", + "python/sglang/srt/models/gemma4_mtp.py": "3c2025089f6c62738770a45bbf64df5bc615c2f378cdb1753f4febc055aff138", + "python/sglang/srt/models/gemma4_unified.py": "d5498b253f35e83ab0aaf219a2c2bf2f42c6bbd3f95ffce02760e78b2e38a4e9", + "python/sglang/srt/models/gemma4_vision.py": "66eaaa3968f9ec8339890dc105174e74db21c6efeab5ca31650c368db97a445a", + "python/sglang/srt/models/glm4.py": "ca559ff25961b5c87e017d76a8169c48a3ac6e6e59ada6ee8f2d5699ba5ba6c8", + "python/sglang/srt/models/glm4_moe.py": "da66fe6314fa84e7401900cf7e7a05d7dced72b39477595c3a67fda735e24256", + "python/sglang/srt/models/glm4_moe_lite.py": "cfcee7654fd72dbd192fcd1b8a1728fb318059caa41c679e3457abf50a7e1031", + "python/sglang/srt/models/glm4_moe_lite_nextn.py": "165b7fd2a6b15fdb338707846dea4aa4f4a380f87eff358a4463c8598fff1f2a", + "python/sglang/srt/models/glm4_moe_nextn.py": "6c6b01239f596f2c3ff7cff2836b498d2c7e5d891ef4d387eb9d2d74e46dab91", + "python/sglang/srt/models/glm4v.py": "92ea7274deab155e77bdc8acaff13b422ef46038aadb46aaa59c0783aa1e526e", + "python/sglang/srt/models/glm4v_moe.py": "b510ecd4d1aa164699e1306861e993a9b07bf126f98944bd618e9c158754d5bc", + "python/sglang/srt/models/glm_image_vl.py": "7d994d2b83a9cd46151bf525dae23525d4b1ab6636b57d62933348242c2d40cd", + "python/sglang/srt/models/glm_ocr.py": "1f0af6af0d24a3d8e36ca50e93e52ec8f2d45f8b6e2db7634bd551301deed8d0", + "python/sglang/srt/models/glm_ocr_nextn.py": "f4495df9b3a3cbeef4948d563c832f378b302113d714dc14892feadde8b9a7e2", + "python/sglang/srt/models/glmasr.py": "36bba050ca1b985944c46ee662f3045f6cc2c76bbb7168033900de75baf48ed1", + "python/sglang/srt/models/gpt2.py": "acc560106bdb0f4bf7666a6500bfe04871cc7cc330ff9f984343825a048ae429", + "python/sglang/srt/models/gpt_bigcode.py": "d93a118f5a053b4f5a916a38ac277e8ecffa810497fc36f38104586f381b405d", + "python/sglang/srt/models/gpt_j.py": "ea6573f8f959be3ad3e6b429955cbc2c8e60957af456b439ddb2fb53b1121536", + "python/sglang/srt/models/gpt_oss.py": "e345802d5b8696e58cf3022083110dd8d1fda18290cf7fdc13274605fc3e3dcc", + "python/sglang/srt/models/granite.py": "2157d2628813e0d91877b54ba9cbce90067b77cd56ddf6b00b634e94b1f7738d", + "python/sglang/srt/models/granitemoe.py": "f1a465f47fa472801ba0c8cefb9227254ea6309273e5ba6394054d329ad03910", + "python/sglang/srt/models/granitemoehybrid.py": "63e020e0d734db583a5dd19fa70c7bad6a1ea4800a92a7fb0ec8084edebbe44f", + "python/sglang/srt/models/grok.py": "63b87b5e58545c7bc474f9f1793917afb18cf33b9618946a0f7631acc52cc481", + "python/sglang/srt/models/hrm_text.py": "d71689264ede55ce8ba847ac63ce6cb43b671734d267a0b67b08d60b62a1a88f", + "python/sglang/srt/models/hunyuan.py": "137de560974b24bd2c8705d82a13f4a2357d2b86fd16c389c8f07d1cb5639749", + "python/sglang/srt/models/hunyuan_v3.py": "bcf21fe22dafbf739b009eb3ea0c996251c08c69b07d5a61284e735ae6d184ff", + "python/sglang/srt/models/hunyuan_v3_nextn.py": "1389dc50cc287248b03adcbe4e2c394d5c81cec5191e3c047a1b3f2156dbfed7", + "python/sglang/srt/models/idefics2.py": "b2794f629f7faeb43d25050ea3d7dc0a1aad0da55134217973ac6c6bfc2869e2", + "python/sglang/srt/models/inkling.py": "bb54c701428d58967690bb016b170a237cb018f28bc1b2941dda61a6c33ffbfd", + "python/sglang/srt/models/inkling_common/__init__.py": "b96821456ca126fc0ba0c2d6d026664714dcaea47fea7add939d80d74f401d94", + "python/sglang/srt/models/inkling_common/attn.py": "2152a03ccd0c0535e65385c6961e968981eb8af9966fa8189a724a3016635a92", + "python/sglang/srt/models/inkling_common/dense_mlp.py": "632432bc4dba4d2e9d7593777aee00af746b2da448d0d0e7e30b424c11b30f59", + "python/sglang/srt/models/inkling_common/hmlp.py": "377c5ac0d2fd579897dfe8e059e60052ffdf08095e02d5c8ab90c8c1fa288474", + "python/sglang/srt/models/inkling_common/kernels/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/models/inkling_common/kernels/comm.py": "f2e1224fe7f1eeb1c576c4592ce55d875a8681e26efdfea54b504b41667bddec", + "python/sglang/srt/models/inkling_common/kernels/sconv.py": "7e9862ea08df10fea5772f51bad0708424b996409c5447ac3872f539e6414b4c", + "python/sglang/srt/models/inkling_common/lora.py": "706df5c637c5b092c246d0bf95605604c33329880f292c061441c4c9ed788c69", + "python/sglang/srt/models/inkling_common/moe.py": "4bf39c7662ac4337ce81c5136ce288be18e532290400fd27de5fc0ea4384ea92", + "python/sglang/srt/models/inkling_common/norm.py": "2f386379b4ec8680cfa438202885a5c31de9e0d9287c2a5fa10e2f1874f2d39e", + "python/sglang/srt/models/inkling_common/quantization/__init__.py": "20764ebd292899f5c31c5747ae7289174126807570f84482ebdf44a01ebf5329", + "python/sglang/srt/models/inkling_common/quantization/config.py": "ffd7c1bda9e756ec6056b61a5b6d853a2bde682cd6ac39b9fe8b0b3ceba21613", + "python/sglang/srt/models/inkling_common/quantization/quant.py": "9fac6d421bdfd85086e390c45f22794f79bc23934387be094206df26ff8a00b0", + "python/sglang/srt/models/inkling_common/sconv.py": "39f7e78b8b9b476de003a902ebfc7acd98cae625901d94d23b24d383238dce06", + "python/sglang/srt/models/inkling_common/util.py": "6258d774bb930aad9f93c7fa91475e808d1a427fe3d6044e1fbc2fe8867a25cd", + "python/sglang/srt/models/internlm2.py": "e9a1b60b9ec93b02cebb60b2a8db90ec75a5ba07aac92ef48d0b418f03a59bc3", + "python/sglang/srt/models/internlm2_reward.py": "c229f6bcf851c72696b5d637f04ce8dc865ae49f8436fe9558c2b57d2aa7364a", + "python/sglang/srt/models/interns1.py": "f36a7f8af20b4dc127f3138fc951b573d693fa16ab3af96dbcca267a63583dec", + "python/sglang/srt/models/interns1pro.py": "f8e196bb3eae4df08312c58ac124587f2195732bef28851aff0d3e7b1b31d3e4", + "python/sglang/srt/models/interns2_mobius.py": "b6b1684fd7d6e5110d4a6bd297f0703d83629ccbc9f1d330f2363e864d7f310d", + "python/sglang/srt/models/interns2preview.py": "f19744e2c4c18d2919100423b8bfdc0546c80512a293b2e49a2a727272e067b7", + "python/sglang/srt/models/internvl.py": "b318a9e40618e85114a472494c3e9410d2ad9ad7074ad1cfb89fbd48483d86f1", + "python/sglang/srt/models/iquest_loopcoder.py": "a9276f23629feb434f0e12a81709c7d9bd903b228b84e68c2c6706373713b91b", + "python/sglang/srt/models/jet_nemotron.py": "38ebd2df37393986c1d816f316634412cb2a7a0d4bb52b0acc068b012e3c8b92", + "python/sglang/srt/models/jet_vlm.py": "2b406a23b6a742e0e0912b330191d7795dc52fc9ee8828abcf774a029e624d02", + "python/sglang/srt/models/kimi_k25.py": "cf64ca2bab9c828aaedae7a86ce018947d32138377fd2f2a5b9a2e4ea7769503", + "python/sglang/srt/models/kimi_k25_eagle3.py": "4717e7ced2536b879ffecbafd8597ad55a78707cda79cffa27ebc11a9aa25f1d", + "python/sglang/srt/models/kimi_k3.py": "d8dfc58e73246577d9eb6aef5488ee4c205ca40b88bd9af849ccfffb59146f04", + "python/sglang/srt/models/kimi_k3_vl.py": "2924c38f652a6ebff2ef79c49f2f336ba18723ea4b854d3ac14d95292988acdb", + "python/sglang/srt/models/kimi_linear.py": "40274c2c8e6fe095c0b3edea28ced13083a26dcdf45b7b0eb06e5788686a8209", + "python/sglang/srt/models/kimi_vl.py": "8b6d662dfccf19543ff8223a862bd1eaeed80f073001c27f20c655130ee9c713", + "python/sglang/srt/models/kimi_vl_moonvit.py": "e417162c4e61613bd76994ee9fe0af1a58eebaa44ec14b6d6b85bf778ae6dec4", + "python/sglang/srt/models/laguna.py": "085ddabc569bdc797394f9dbc83e16d1e8db309b50295517f5ee03b974de6d01", + "python/sglang/srt/models/lfm2.py": "1ed88642d9370b69be11d219e86caeae80aaac035062a70fd2d148a2ecb14f92", + "python/sglang/srt/models/lfm2_moe.py": "7a3eb60fa52f32f07cea305e233bc0514a940a9a7444daa42252b4be06596f3d", + "python/sglang/srt/models/lfm2_vl.py": "256facc230ca3455a651a2feb94302a9b25cfb66316f041f87ae5d5fb306db77", + "python/sglang/srt/models/lightonocr.py": "88b3e3f81a099bb19d280f078c9ba303e1ca85e1f5fa078424d516d29fe39577", + "python/sglang/srt/models/llada2.py": "89306a43224bb9a51749fe7738be7356f40d9858a5f11037a45ec0239b02eee6", + "python/sglang/srt/models/llama.py": "1f70c2745c24658a55c2b17a7629a9c728e41f2fb2734801ba12becda55d932f", + "python/sglang/srt/models/llama4.py": "e372b3afea00078bb75e1b0d6d3c3472a740db63c54e84b9511549fc5d47da0e", + "python/sglang/srt/models/llama_classification.py": "055235ecdd405590a3e883eb3279012f5ae52b6889b842e489794a3f713e67bb", + "python/sglang/srt/models/llama_eagle.py": "03a48b74e97bd7f43582fc4b11d06f3423f384538c4845c86df1c6804fbde6f8", + "python/sglang/srt/models/llama_eagle3.py": "16ab0259f7823174688e0461827aecdc51edeb7693eb720c9a0f7cab3bdcc8cb", + "python/sglang/srt/models/llama_embedding.py": "ceafbf94dbb7e5504573b79e9a26a6d3376418813c7f3ae093939661f8ab6670", + "python/sglang/srt/models/llama_reward.py": "87625f811511a8aea3e11e05a12e4490edced7703ac3126a015db48a0098039b", + "python/sglang/srt/models/llava.py": "49ffe4b8e6dab21185e6dfd5e632bfab9f02b8ffdccb3e3ef94e95aaf7a021c3", + "python/sglang/srt/models/llavavid.py": "cd78585da7006df12425fb2a5d1fc5a6998e13ed1a4e2ff4c51efd1e3c45fd76", + "python/sglang/srt/models/locate_anything.py": "e5ad5a36e85f417e38ec297ac091dee0ef54fe9495c7cd5c9d1ab920b277b8fc", + "python/sglang/srt/models/longcat_flash.py": "db2b42f23b3461a6d0a0be1c52a05550c3bf5ae93ea45165c91d4248d40e01cf", + "python/sglang/srt/models/longcat_flash_nextn.py": "b2dab60290fbba8c612e2f0712fcab802f98aee18d585665ca4697a60439a636", + "python/sglang/srt/models/mellum.py": "ec83a2403979372196e8ba805d0bc4d3a60a05f39ebf4918fc25fd2c710cdaed", + "python/sglang/srt/models/midashenglm.py": "41feec5b1cd1c902f518dfbfe829d072a46046b945c2a8cd2ed00d388c17e14b", + "python/sglang/srt/models/mimo.py": "4dd89f957b5ea3f1cb1fb43561feb10c039747336b3a92d1e248d55ccb9e96d3", + "python/sglang/srt/models/mimo_audio.py": "2530a986a818f518d258ef1353c5b436eac05a5eaa43dcd9f0097060afd33114", + "python/sglang/srt/models/mimo_mtp.py": "da82aeb473817dfea5828b65cc4c9724c9ba80aae0fc6397b11c7450cbba2a94", + "python/sglang/srt/models/mimo_v2.py": "f7a413a456e6567155b91ad479fa6ec42420f66b7dadd5449d0d45613a50a7c1", + "python/sglang/srt/models/mimo_v2_asr.py": "6527276c32b62e75af54d95f6132b600f8e0e62a4afe45c3a263fbf72ab68ca2", + "python/sglang/srt/models/mimo_v2_nextn.py": "d5ee45e7db07f2e527a2d03ea013fb8cd2a54495b330f51f0c9fb81c127df061", + "python/sglang/srt/models/mimo_vl.py": "0b365aafabc003b0a8bfc7617542e1ae7cbbc1ab2b32a13763c05fc69606f6d8", + "python/sglang/srt/models/mindspore.py": "e05c612e4f467779caf96267f2e7e07146b04fe1bc81e578758bd92911346c87", + "python/sglang/srt/models/minicpm.py": "10288c7ac6d8e762aa7fd71fd9d186d1daa804a836161242718c27b23471a6bd", + "python/sglang/srt/models/minicpm3.py": "4f0519477f7cc9aa708a040c184b6544a21c6c5a142ae3b3767ec61d6853df55", + "python/sglang/srt/models/minicpmo.py": "c47dfac0dde4b64672db7b015d4e0891686e70924259e0c4a86e68139ef56314", + "python/sglang/srt/models/minicpmv.py": "cf93d077bffac4401d7d8de57f728dabb1197537da615143777092249a23bdef", + "python/sglang/srt/models/minicpmv_vit.py": "bf539b30ce1fb139bf70c43ef0fe6bd4d96dc7104fc0004cdfd313a394f008e6", + "python/sglang/srt/models/minimax_m2.py": "dd593d37b88bce083f55a94055d4eb24a4585cf0f93f4e761749529b764e3446", + "python/sglang/srt/models/minimax_m3.py": "2cef3ef046f7e1a2786cf5874bdb2ceab83e99d2ce70b421af0ea2d3094e29d5", + "python/sglang/srt/models/minimax_m3_vl.py": "e472fabc0e06683de377debf71940c16929e1fe2e1b7e6ea74a172e14f109a3b", + "python/sglang/srt/models/minimax_vl_common.py": "3f141f6fb07081d11d7255adbcd11d5feb506cd291315501a8f1653b8de40be3", + "python/sglang/srt/models/ministral3.py": "93a77d7707c5415d24704ef83e15d6a080bbe39796715b105288ce8fcc63cbdd", + "python/sglang/srt/models/mistral.py": "21a2df76c3cb114833f521a64e8dac53986036e1eb4bdd5b65759a5100904cea", + "python/sglang/srt/models/mistral_eagle.py": "c286d3f3946dfa08537cefc3f1979ce1fc6ac4469ec6aa7eb2bcc62a67782aa4", + "python/sglang/srt/models/mistral_large_3.py": "787c57a6499ebf68e3661135e3f14350ee808eacff9e7a339fe5bcd73492e09e", + "python/sglang/srt/models/mistral_large_3_eagle.py": "172bca42aeb3f1f1399de0de9d45bb8046d64f319c407cd48eea9f91e10ac056", + "python/sglang/srt/models/mixtral.py": "96da18082e741b197a428089558b2c9454edc59bf4c8e3786ea476c7c0c04346", + "python/sglang/srt/models/mixtral_quant.py": "cd8cd32e82be078d4dc7609a7f5483180dd859a3698c5451185066c428c51f1d", + "python/sglang/srt/models/mllama.py": "3da05e06e5479fb909cd3f890063bda3dff10a4bc621da8563d842c959f09184", + "python/sglang/srt/models/mllama4.py": "a532260b2312fc894f8b7029e44e9351cbfb64a5a519a429ab98ef0a1d997c63", + "python/sglang/srt/models/moss_vl.py": "28308ce12e14186c7c49a6c3a30e420d56d85ba26f9e3672f3b31dfd7d238712", + "python/sglang/srt/models/muse_glimmer.py": "eebf558cf180de061283def5662a2b2489f6e6330f4e812e5ea47b3a183d708c", + "python/sglang/srt/models/nano_nemotron_vl.py": "8518784a2c5b2475fc125daece17864de13fc443e00923cb8ddbc227b090b1e6", + "python/sglang/srt/models/nemotron_h.py": "0510c47bac841d1da1ec3b2e7e3ff9a54dddaafa393a7a08dae9efc3c5be910b", + "python/sglang/srt/models/nemotron_h_mtp.py": "32392f28eb09ff30786bac289cc3c37aa7614455438a2bc62f78325140d96dd5", + "python/sglang/srt/models/nemotron_h_utils.py": "a7ddbf52ee14533da3a06e9f63f3bdcee2726007af615fdd22aba88143c3b510", + "python/sglang/srt/models/nemotron_nas.py": "875028f2d773fb1f7904894a2437e060238fb6e1e49723b72698da89f02d43bf", + "python/sglang/srt/models/nvila.py": "667265c922eff8080a13a5bc52aadc71754a1353588a91243721bd9e40235559", + "python/sglang/srt/models/nvila_lite.py": "1331c607d087580f1d6772a057d912b71e5dd84eceb9df2e4f41c36b804c0252", + "python/sglang/srt/models/olmo.py": "bccc66bc7985745d36ab09a7f6c0e66548687cb789fd0cdbad9547a1076d05f8", + "python/sglang/srt/models/olmo2.py": "543220ce3ac3767d8d039e44165005703cf273bb5b05436c04bd5f75aa2e50db", + "python/sglang/srt/models/olmoe.py": "0369a0f057bb8905727ecd38368e7153664f9f40bb67081734ca6deec236f521", + "python/sglang/srt/models/opt.py": "276fdc26df083a110a5b368c129731f313a641a77b8d917f928a88d5ff10d1b2", + "python/sglang/srt/models/orion.py": "60d9f622dcfb5c89346b86c2fe00e978d71b6e36b7746480c5eced5db2bf93a3", + "python/sglang/srt/models/packed_ple.py": "32a733d445fae43d5fadc85106c6a3617248e1d0be4e8b101607aef197bff6c0", + "python/sglang/srt/models/paddleocr_vl.py": "60fdb8e506dca8afe50567782baee879806d5cda0b44cb0033c5f574d99f83bf", + "python/sglang/srt/models/parakeet.py": "afa477ab4dc5fe1e82855066664db54f8fed8602ce9e7bc744c83ded57d80ab5", + "python/sglang/srt/models/persimmon.py": "a270b4ae43f763a41304c37b90af3fc651134b03af6e5feb8f24c5b9068cb8b5", + "python/sglang/srt/models/phi.py": "382592c42616624252577c2e4f75d610db2da0a446f9f1f9a76fab24505094c1", + "python/sglang/srt/models/phi3_small.py": "e2a701bdadc1747b89294cb646f2a3f080133372362ec2fdbee1b611fd9f2e02", + "python/sglang/srt/models/phi4mm.py": "f5ad75724add38c0488c6c1e73a4968393e99aa19bfa3a88cd22d6b5dcd093d4", + "python/sglang/srt/models/phi4mm_audio.py": "d0285e930a18b9d0276d8d3e272370cff8a7ccc97133c16650ba91f66c243e14", + "python/sglang/srt/models/phi4mm_utils.py": "6d6dee9f8c774870ef4a400e1d01053b6f3a14674e3de2a10692423a63650bd1", + "python/sglang/srt/models/phimoe.py": "603aa98fd79c0167db1cafb9b2c80e27375ac340325c34b721d03b3378e39b0f", + "python/sglang/srt/models/pixtral.py": "744492a3d65174ae2f0341c3542afd55c870f67b158e83c7b49fe1bb8f1a4dbb", + "python/sglang/srt/models/points_v15_chat.py": "1d5fc64602d371eb4a8740766a026bcb4d8dfdab5c588e4d3e38d010b6ab5069", + "python/sglang/srt/models/qwen.py": "7f783026bd35b5095cbc31436aa2c6775c4584c2d367e73076d864b467c0a70c", + "python/sglang/srt/models/qwen2.py": "41741eb780a3f75bc3ae4f43cc09d538b15752b1d5da34b5a96d8bca36970fdc", + "python/sglang/srt/models/qwen2_5_vl.py": "6949ad69c74dadb1d9e29cd794d13a1019ef3f1342cbd9d2946f53e6b0b19327", + "python/sglang/srt/models/qwen2_audio.py": "36fd4a320987a53035bd94c9bdc49bacf664aee884f139ed43bbd9c5215be55f", + "python/sglang/srt/models/qwen2_classification.py": "b45ecd8c713792662fcf8d6df0810a59e6fda40011fc35f82ea0678b6da7976b", + "python/sglang/srt/models/qwen2_eagle.py": "8c7f437f93e991dc33e04333a77eabd945cecf5fc6e039e64c5e188ef04add71", + "python/sglang/srt/models/qwen2_moe.py": "20467a642243f2160f34381c31468b85c60c33316e4a33b38c07be3ac53424df", + "python/sglang/srt/models/qwen2_rm.py": "e81ec356c191ea45d5db5a1eb3bbc72c29bd9599c70ed3011aa1027c70f15579", + "python/sglang/srt/models/qwen2_vl.py": "ed6c3b2039b1e8bf2e43aaf9d7dd59be224fd6022e20ff84223caaf8c0d9bd4d", + "python/sglang/srt/models/qwen3.py": "39c7c9c6b0107f12ac76cd2b6b54a0694c8540c1bb9588a380e05fcd3ee93e6b", + "python/sglang/srt/models/qwen3_5.py": "f7e52f647d8e3dd8c980ae170569585ee118c782df055b21b1e93bbc28b1f9e8", + "python/sglang/srt/models/qwen3_5_mtp.py": "f5e2440a6b16c65ea7768b38441283750692890300c39266025786f33d48f796", + "python/sglang/srt/models/qwen3_5_text.py": "b5e41ae9d90a3b0cef80a644335da66d385403bc5bd64eeb1d391a148bd3a8fc", + "python/sglang/srt/models/qwen3_asr.py": "f3b30fda98ac587f87ae4c2f414dc56ca2246867598e9c6ba3ea8a3db6076777", + "python/sglang/srt/models/qwen3_classification.py": "8eeb04172601531add9cc72c5a2ef7c5f370c443b3407fafd9af188e687aaf66", + "python/sglang/srt/models/qwen3_embedding.py": "863f53ed09e8d28e657212d9379191f9ce684c736a98f4a6d4d1b593c5cdb598", + "python/sglang/srt/models/qwen3_moe.py": "7c559324111dfdc6927e97d13e31d5ff7b23bf7efa4d4fa33d636c026212bb05", + "python/sglang/srt/models/qwen3_moe_mtp.py": "e795243b8af8bd75af56022af0be83d7b1be537d1a5659e372a34030e2339ebf", + "python/sglang/srt/models/qwen3_next.py": "a489dbe53eb6f5ad24f8b0dc04b65f1ef8a14cb4172f37de1a3df759a1f047e6", + "python/sglang/srt/models/qwen3_next_mtp.py": "143c6b62eeb23e1f2f79cb9c856540dfb40ae7f49a2695aa4698f3460cc34d8c", + "python/sglang/srt/models/qwen3_omni_moe.py": "ccb9850c1353f145ff31856b9307e9064f59024c2a7eee0a70338e986ab99a80", + "python/sglang/srt/models/qwen3_rm.py": "07a12c16cdab6a97ed7896aee9dfbfe746591816aece1ab4181ed1d5891a1166", + "python/sglang/srt/models/qwen3_vl.py": "f08159602498687df548797edc45849f84540c2a3d57bc3e1120665ccdb280cf", + "python/sglang/srt/models/qwen3_vl_moe.py": "48adc25f100392919f446ebd7e662b0d7fe7d13f85daa3b01cb694b79dd6e4c8", + "python/sglang/srt/models/qwen4_exp.py": "311375b089b05091bb1a99d95eeec238a03268381f491854322abf40e3f3328e", + "python/sglang/srt/models/qwen4_exp_mtp.py": "7597cbf46993768cee865c888fdb0ad3560f123ead707700d785f7ae0d28497c", + "python/sglang/srt/models/radio.py": "3e603a16807d9fb511e8ea463366cb685224dc0a7bd71c1bc2f8879db69e116a", + "python/sglang/srt/models/registry.py": "3c5b4e87c5943147c28cb5b68e187cdf8f8f9d880c42f1f6941fce99fe757e41", + "python/sglang/srt/models/roberta.py": "87994b2a22c88c1c5810581439159759d5ba6c9f2c90ac8558d9c4a9525706de", + "python/sglang/srt/models/sarashina2_vision.py": "b6f1f865bf94f6981caf19bfed4bab9e6af95dea34c57716607bae7080ec7a4b", + "python/sglang/srt/models/sarvam_moe.py": "d06ad53aa9283b7d2763eb9d5905f3ba7c26a0c2ea1e8ad9fb3cd7f6dd8eb267", + "python/sglang/srt/models/sdar.py": "fbec6b8ed653758a76aa75986c243267f0d7a6637a80508a7b94c0a9f963c72d", + "python/sglang/srt/models/sdar_moe.py": "07776e14b56972900c31921cc22c0e964a7c9a9af39dedb038920556ca8c45dc", + "python/sglang/srt/models/siglip.py": "722bac4d6dbe18f224a0931f5076c84aa41067adcd8211bed455f1b31d7976db", + "python/sglang/srt/models/siglip2.py": "bc81904cf0a746fc15932e73298bb6401ead827a2399924ee754013f68507c95", + "python/sglang/srt/models/solar.py": "b2ba46c5d1931bf11aeff6c31390934602be133a2defe7381ed6f69b0dd1fcca", + "python/sglang/srt/models/stablelm.py": "3b13b359144c799b2a2947906dcb199552783f91f5117d4a0ae6640060f04fdd", + "python/sglang/srt/models/starcoder2.py": "2fcaef42743aefd14ff44b8cf2ca7357aa4a69ea23e9ec9b2deb9b934ab5c461", + "python/sglang/srt/models/step3_vl.py": "a7b918d8cc89d0c1347d5553bd15738dcd0d7c79b726c2f4ecaa073bc5d486b4", + "python/sglang/srt/models/step3_vl_10b.py": "9654f28e13bb8fdafd157e603608fe4212f48c028b026cd08ccd6b90b8d22428", + "python/sglang/srt/models/step3p5.py": "dd201e0fe8eb0e833a325d37e3853eb25711ae78a8fccc71dd5a3089f5acf69c", + "python/sglang/srt/models/step3p5_mtp.py": "59403c590c52c69376f6b3b7997686f1bf60b24983cdaf8fb1cc0439f745094e", + "python/sglang/srt/models/step3p7.py": "814dff8fec4ed5e310ccfd3300a543d63f7620a6a084eed05126bd0c6cd99b42", + "python/sglang/srt/models/teleflm.py": "d5d2af97bc09d103cc8891a6c19863651a8247b2929f293db6e5bba2f953c2a5", + "python/sglang/srt/models/torch_native_llama.py": "5cb5a798c87fc2c546bb04fe9cffb0695dfe6b20ea22ab05d5340feede692248", + "python/sglang/srt/models/transformers.py": "cd06ceac5b96a81630770bf41cfd2244ca4384d6028fdc482fc0c81aa7abf3b5", + "python/sglang/srt/models/unlimited_ocr.py": "dc4605bf016db9a619353e7ae21a798571b9c565ab5652e20495ab66b1ca3e34", + "python/sglang/srt/models/utils.py": "7a05f7b446086ea6427b562b895355c1dd5b0b2b2563467d8daf11bcbfa979d1", + "python/sglang/srt/models/voxtral.py": "5a81bd2c2219aa791ac5d5a4a78c1969e9c678a3fec3282dc21fe526e026e4e3", + "python/sglang/srt/models/whisper.py": "3ca327482f0e6be78408da1b64a59018cce4f62741e713c38ddec0057232288d", + "python/sglang/srt/models/xverse.py": "f675d37ed6d32e7da68f35f6a59232082f03e173ddddd8b2942c7f06049de619", + "python/sglang/srt/models/xverse_moe.py": "f26cddaac7b663cd2b1605d1575e8f4ff0413b1ac3a1a68f460e39604f40806f", + "python/sglang/srt/models/yivl.py": "f329de6db7907d07267d44c261186801c580df2bb9022128f4a958716b0a42f5", + "python/sglang/srt/models/zaya.py": "e9aa7f2a13597df88c098267fed0fec664b4e4fb20de0d7520c785a3e4107f54", + "python/sglang/srt/multimodal/__init__.py": "1eccef4346506ea01312ea8f8cf5a37307704a53acccdca0e8c3e94c5f7e29ef", + "python/sglang/srt/multimodal/audio_from_video.py": "caaad30b5339ea5508a5a0a1ac688520b24a1d989f106a04d66d2b5cbfaebe77", + "python/sglang/srt/multimodal/cache/__init__.py": "c55ee6dd5cf2a2417cb9f8e1382fb3e6073f219398d495596e1b001970cda16f", + "python/sglang/srt/multimodal/cache/identity.py": "575e0c59c4c53f39e13e39d161a2378f5eb9e6f0c1843d7ef65c291e0c98aa8d", + "python/sglang/srt/multimodal/cache/preprocess_cache.py": "01b12a7b21c61539a3b5f62eb358e8278c8ecb5547d0f0cbe855c2290870d227", + "python/sglang/srt/multimodal/customized_mm_processor_utils.py": "288a2c31f8de0e69212ebbdf4814802959a877e4070f0a830e57a2916a7fd78c", + "python/sglang/srt/multimodal/encoder_preprocessing.py": "16ce42db23c82c43725633f58e9d462613f0b619409442ecc0ea1bd635eb7c3b", + "python/sglang/srt/multimodal/evs/README.md": "2639aff4833d067f6e109e383f9a63667cc5c118ae6eecd2cd0b5be6539b1b0e", + "python/sglang/srt/multimodal/evs/__init__.py": "d0a4e395f23d868ff513c20f7f5b76591a5232c461346cd1300c0b75130d1503", + "python/sglang/srt/multimodal/evs/evs_core.py": "a96d74c0d6d08b2d54301a2744037a9a2600c2ca0a199d32e2e69e6cd5094d18", + "python/sglang/srt/multimodal/evs/evs_module.py": "0ebd652748903794048e397310edc797779d60066dab18715146c34397632b35", + "python/sglang/srt/multimodal/evs/evs_processor.py": "aa39f0bdadc56b0bd8f20ea8a4a8408a05895ee6a4c82386025d45486622aa25", + "python/sglang/srt/multimodal/inkling/__init__.py": "2fbef5e7488f2f44f7db231f3de174a37af46d8d5d1585ac81e80052f94a8666", + "python/sglang/srt/multimodal/inkling/feature_extraction.py": "d1f14c50d2a0dddbeb2249c00b6fc1c118b05f65477a9000608d24b36939cd2e", + "python/sglang/srt/multimodal/inkling/image_processing.py": "bf11425a3eda1180ef585c0fd0b6461063c608ebe93540bac3a73273872af6bf", + "python/sglang/srt/multimodal/inkling/image_processing_rust.py": "ee81a8133042cf06d7e08b5d97bb55a3c84d7a2cf213b9a22cada27537e0b7dd", + "python/sglang/srt/multimodal/inkling/processing_inkling.py": "578be654ffe3f2ede5628e9254ed9484e028ada0294d5a9c8f692472cb66b01c", + "python/sglang/srt/multimodal/internvl_utils.py": "06fcd349896e1a3c1fd12ea0ee26801bd265e91602ff47c1c496ce226d479da5", + "python/sglang/srt/multimodal/internvl_vit_cuda_graph_runner.py": "45e7717c3e6356019761b528944e009debbbe88842364b98c74c18a26062a1e9", + "python/sglang/srt/multimodal/kimi_k3_image_processing.py": "5a87501834fd8b5189a11d8d2a6497de2a12baa47bba7775e5c3dd8bc3e2f9ca", + "python/sglang/srt/multimodal/kimi_k3_vit_cuda_graph_runner.py": "18d27ee23b87e2a06ffa1dfbfa46611a3ad414861f2d982e58d49287d4b2eb8d", + "python/sglang/srt/multimodal/media_artifacts/__init__.py": "37158f4df86b84d22c9582b631436603ccbdf94947fd8f86435588c70cb1346e", + "python/sglang/srt/multimodal/media_artifacts/base.py": "d07984b72280a6153a7e2ded8b4e392eec760485f75594fd17154bab1329d080", + "python/sglang/srt/multimodal/media_artifacts/kimi_k3.py": "196e633c6a437cc0bcf15bd4ee86316e5d0932a78d66453f7b920df494324187", + "python/sglang/srt/multimodal/mm_utils.py": "2cab2ecac1f3fcbb08377556d9480facdcc3c910f607fa3771eb6e3c6377102a", + "python/sglang/srt/multimodal/processors/base_processor.py": "1e5052235b0b76840949a597e2f2816e5dc296cbff45cdc218fdd9a3dfbdca9f", + "python/sglang/srt/multimodal/processors/clip.py": "9290a6464e0e36f48a868c6ea058cc85212b311edaad7b0ff0ba6aea59411a54", + "python/sglang/srt/multimodal/processors/cohere2_vision.py": "fe3863384d7e07e1bab7c78aadd927214013f28ceb288a2747b7acd77b35a6a3", + "python/sglang/srt/multimodal/processors/deepseek_ocr.py": "8acaac872069693f27de4dc84cab401673cc9276933acc1c106cffdd7960a358", + "python/sglang/srt/multimodal/processors/deepseek_vl_v2.py": "be8670c2929978d6f6c004fa46bcfb8f454dc2cd54124472289a9822ab6757a3", + "python/sglang/srt/multimodal/processors/dots_vlm.py": "faf20b27d660c150a785e861791b5047ffb232c2f977f871a75186234724632f", + "python/sglang/srt/multimodal/processors/ernie45_vl.py": "45086c502a488dc4ba3a3db9ba106d231dbd09a2cb31df902d5ce8a5d6620bbb", + "python/sglang/srt/multimodal/processors/executor.py": "b69d19801ea61a36f6359e3e4f5464d9eaa1de825368a2c1aaa36005098f63b2", + "python/sglang/srt/multimodal/processors/gemma3.py": "1c1bd5774eb7bb741013a1efa8eb994d2d8cd7c51382d87a6168e78e61ce1a1c", + "python/sglang/srt/multimodal/processors/gemma3n.py": "005baf0e4d790266376a59115a5512f8d6feb44c2feeaa403ceca62cef3e0852", + "python/sglang/srt/multimodal/processors/gemma4.py": "a3d8b0db8b7f34fcd0c42839b9c7d3ff38f439d702898542ff5c80c12a57cbed", + "python/sglang/srt/multimodal/processors/gemma4_unified.py": "0a4364a71bbacba534b89a390f41b1e3d07fd5096f57d2d192767d24e81cf4b4", + "python/sglang/srt/multimodal/processors/glm4v.py": "8b4198d2ec3de68e009db6d228d29064aacb8c782ade406225ce4f7f48f3e922", + "python/sglang/srt/multimodal/processors/glm_image.py": "fea5e9f805a25a77250bfebf2b5b0dde8458cfc986cb5ac39656fe4b72f751e4", + "python/sglang/srt/multimodal/processors/glmasr.py": "e08396780d66db0e8ce826b52f82d4f44029901c7d2ebb6bb19bad7ae4d4f8c2", + "python/sglang/srt/multimodal/processors/inkling.py": "d23c1d67fbd643d5be2390c2a1340a1d21bb64d3c3624b061ef8f01fda041fd2", + "python/sglang/srt/multimodal/processors/interns1pro.py": "018ff87350f60de410e7516a5e4b5895cdfab3547c2c6341a3f60070b76bf117", + "python/sglang/srt/multimodal/processors/internvl.py": "d28fd661ea772c46e9a735b2da3ee2363acddaa16bae989af3b821e066604cbd", + "python/sglang/srt/multimodal/processors/janus_pro.py": "427ac76c5f98fe58d1fce72b91b7ea63fd46a4ec7dcf4fc5c49e96bb643375cd", + "python/sglang/srt/multimodal/processors/kimi_common.py": "671ac50154f5e46bb32b2af758481bd3dba6fdaf8768510e35b2b1472cba4abc", + "python/sglang/srt/multimodal/processors/kimi_k25.py": "80b1805dcd7311f376922b01543e3dac45aa95050332cf21d08aa38e00fa777b", + "python/sglang/srt/multimodal/processors/kimi_k3.py": "94a6352f64cb68db103e750c57652b57b44c5d1cf2ea6e54c9f925c7d604b461", + "python/sglang/srt/multimodal/processors/kimi_vl.py": "1c61a58362af452cfff36347ff20c043c315f8bb3e0696255a87e1824c237766", + "python/sglang/srt/multimodal/processors/lfm2_vl.py": "dbc8bc147d77162b79daf4d0e722fe8e0bb3b208517a82439fbfcfc0232aea87", + "python/sglang/srt/multimodal/processors/lightonocr.py": "d0ef1de2d85ff3e6b982aa333dc8f3c7859853e4b13aafde972a0aeaf06882d3", + "python/sglang/srt/multimodal/processors/llava.py": "a1f37f13d7867077eeae165f6a4e3c7ee1b8b146fda871d857bcb3e517a7e541", + "python/sglang/srt/multimodal/processors/locate_anything.py": "4e721b8f8ccceef8be8aefe067568a988cd2a5efe7625975c8ce97aa3cbf8a39", + "python/sglang/srt/multimodal/processors/midashenglm.py": "80c4f6a6404a15816d43a177cf9abab6a864b61df01a2f91af7649b97f366a03", + "python/sglang/srt/multimodal/processors/mimo_audio.py": "2c2c5249581bd1a8d61c428f5612312eb7764e3eb8925f9af12a94c4d332eb9d", + "python/sglang/srt/multimodal/processors/mimo_v2.py": "6fa9682bae6abfb488cf4054b73c76f7d8274e0a3c363c88b79b17548a9524c1", + "python/sglang/srt/multimodal/processors/mimo_v2_asr.py": "927de6b375b1d0c8bf219eeacff1e90611e2811dd52643bc78ccda66b519e694", + "python/sglang/srt/multimodal/processors/minicpm.py": "e3214d38661e8eca56ddbe1e8716f4df2ea3505102d1e7c50f955dcd9bebc7ee", + "python/sglang/srt/multimodal/processors/minicpmv4_6.py": "cc482bbf6f04f75df155c8be405cea46f6fd0cd180f2337f5f282b7d5556d64c", + "python/sglang/srt/multimodal/processors/minimax_m3_vl.py": "60f3ec8ac933e4b71b32e29d181b5877efc3f1ea40bba241aa89479ad55baf5e", + "python/sglang/srt/multimodal/processors/mlama.py": "81ff37009499cc6bfbb3c2cf0ba5509ae15793df2ca4eb36e8183d31dff1936d", + "python/sglang/srt/multimodal/processors/mllama4.py": "4e80dbbe14923a3c35a6283da2224b7bac2f347a8066a899b7feae00c621b90d", + "python/sglang/srt/multimodal/processors/moss_vl.py": "f8f23bbd42433e03ff09cded52a91854ac6a12d753ee26febb4074f56360e717", + "python/sglang/srt/multimodal/processors/muse_glimmer.py": "81b4333f5a2eed02b0f2d08e13271d26601136c2d8fed87c706a9f50e6f2c183", + "python/sglang/srt/multimodal/processors/nano_nemotron_vl.py": "8d45178821fde4e89a3c806d7a51eb0d892f030266b76b9fb88f66d5c44faad3", + "python/sglang/srt/multimodal/processors/nvila.py": "3c547888a565af32a07930baf58d1011743daa42fcdd51aac93fc935279db9e4", + "python/sglang/srt/multimodal/processors/paddleocr_vlm.py": "247c86f9477bf3f1ec508420f6e83db94eeeef43e9382d77094b854782921d0b", + "python/sglang/srt/multimodal/processors/phi4mm.py": "21ff671e86b65be4dfbc773fcc361155489994fc9b6d5dbcd4d879c19cdaab70", + "python/sglang/srt/multimodal/processors/pixtral.py": "f243baa66854711bd4a31362948f04d2870356ee0fd8c3ef03a053c8f8222443", + "python/sglang/srt/multimodal/processors/points_v15_chat.py": "d52953daf4f65f65ecc9456b90b9d096268f7eed1410b95d3f5ca47e160734bd", + "python/sglang/srt/multimodal/processors/qwen3_asr.py": "c7417cf0d8630965cdf2205f7a3d9640dd46fee3973a4f232110dc23c5b25db8", + "python/sglang/srt/multimodal/processors/qwen_audio.py": "4eebd82bf5a87ca604944f666905a0d22a4ac04875d7c9c57cd066833d2006b9", + "python/sglang/srt/multimodal/processors/qwen_vl.py": "b47003e1f0840a057519adff46fc72a9318a61e2eb3ef8cedfa9eab19e98b7f7", + "python/sglang/srt/multimodal/processors/sarashina2_vision.py": "592770bfec1a2896be592e83e4d811a35b2bfe9ae419c91902231bb9dd374246", + "python/sglang/srt/multimodal/processors/step3_vl.py": "57f60588ace2767af58024d2fe6c3bf2502abc951570922b27651ac8207381a1", + "python/sglang/srt/multimodal/processors/transformers_auto.py": "843de5bd0abfabf30baa126613890bfdb3d383933e082ddf1d9a792b42a10bc6", + "python/sglang/srt/multimodal/processors/unlimited_ocr.py": "b612e75e69d269b0d4b75625180d89171cc9455e58d3ab9e066e77fa8c175519", + "python/sglang/srt/multimodal/processors/voxtral.py": "cc3d1f6a27a05fbd9724b02bfb89c42e3906e1fb5d663a1125c71ba4f24e8b29", + "python/sglang/srt/multimodal/processors/whisper.py": "6983b089e81e3bd685b8db376e5a4fb061ed26fc73fb4294fea55db834feb445", + "python/sglang/srt/multimodal/transport/__init__.py": "f5c373399f116778c70f2da906f7685469fd13099b83e5208025f81aa3808dbb", + "python/sglang/srt/multimodal/transport/cuda_ipc.py": "03bc109511d08628ab15ef13f78967dd463d1784d45ba98e088f5b7a5b97cb95", + "python/sglang/srt/multimodal/transport/memory_pool.py": "69cc93717a553d4e0201d3ca086c27d58ecd28236e320b6db234901bdd765852", + "python/sglang/srt/multimodal/vit_cuda_graph_runner.py": "27d0131857e172992afadec1672888bb7d4b48befc3e6c10c4bbf38ed0f37d33", + "python/sglang/srt/multiplex/multiplexing_mixin.py": "a4b50c50a4c0b7b5cae39e9f5f0a6f36e6fe57ae6bc68e4518bcf1fd0ed0d51e", + "python/sglang/srt/multiplex/pdmux_context.py": "b4e6ff1aa10a19f9cdd285088424b9388574fd291edfd466e155cbaa8e876b9e", + "python/sglang/srt/observability/cpu_monitor.py": "61ee5b561c432abe4e3a86dd0a09715c82d79dbab7781e0568615bf34d65aec1", + "python/sglang/srt/observability/forward_pass_metrics.py": "197783e4f501a3651a0bfe376eda29f35cd4a7bf18b6e7b9eebf094ff285f5da", + "python/sglang/srt/observability/func_timer.py": "5bac9017a6dbc69468d3a9706bb91e5901d1a1b788e8b2ab2d836f8a8fccd179", + "python/sglang/srt/observability/label_transform.py": "3be373d06e95723d5a31486c3866fc32467bf25f0bba59d86f35c685770e05e5", + "python/sglang/srt/observability/metrics_collector.py": "9b2469b149e58d6e427dfafe82af073e61e04c825ff7d2b5dec138fd77b5c134", + "python/sglang/srt/observability/mooncake_trace.py": "1538cab22cf2573f93e1559132746508377aa8832029f9ba9fda7a565fe39385", + "python/sglang/srt/observability/ray_wrappers.py": "c04b308075ebe1637cdd514181a4e0da96e7c5b602f5a62e41d6612f570a2864", + "python/sglang/srt/observability/req_time_stats.py": "3a32af2aafbb95366a12aa6b01fa8d0c1b973f0188019ea623c69c7d285ed46f", + "python/sglang/srt/observability/request_metrics_exporter.py": "7ca23d47a1ba8ca0eed97f15354ffdd1a10cc93341588b78cc3dd74d07dc61fa", + "python/sglang/srt/observability/startup_func_log_and_timer.py": "3d1560dd9d9de4604c1627d95d1f9587319c9fd9e629392a114e3554929999a2", + "python/sglang/srt/observability/startup_time.py": "930118e13fd1ceeaf4dd78a31533eff4a474bf63bd5e53a7958933431d49e87a", + "python/sglang/srt/observability/trace.py": "c28d12b5dcfb88bfa488886c78740e6bef39047c146684a916f2889b4b859796", + "python/sglang/srt/observability/trace_async.py": "1208ed781ed1b00c9bdadd382fc99999ecd35d69131a23d3b71af406947893c3", + "python/sglang/srt/observability/utils.py": "797ed7c3ab8785bc0d8b783bbdd70420a3363a9fb473e7a6642583fb8ea16680", + "python/sglang/srt/parser/code_completion_parser.py": "22b62a8c0ead66e61f16dcdb10e1887cd3168c67318337e1e09d30f893f27457", + "python/sglang/srt/parser/conversation.py": "21b48ce77bc36f84ae30685686f53d7acfbc97a1dd5e4176da5f505665229df5", + "python/sglang/srt/parser/harmony_parser.py": "630786e1acd69b98e6cd819a00711749a391a6059cb4fa5219093f8e9e47f821", + "python/sglang/srt/parser/inkling_renderer.py": "257424c8f88a90e281b5db0427ffff3bf32aedb6f1ee4efef55d2a26abaacfa9", + "python/sglang/srt/parser/inkling_tokenizer.py": "8c3a9f8d0c05434a44902155da14bc1bd54ce22837fb7b7bc3848f2da3067120", + "python/sglang/srt/parser/jinja_template_utils.py": "27759425d3b5856095de117e1c431645d4e61e548cec3517be8f237cf0de65be", + "python/sglang/srt/parser/reasoning_parser.py": "42e798ba0ce6db8db876c576f45e40787194b15251829f2879f311e5f9427ce2", + "python/sglang/srt/parser/template_detection.py": "b81f86f61ea56619bca67ad1c37d9dc84f5a6369f36e3365f0ac135b064e9a86", + "python/sglang/srt/parser/template_manager.py": "2c7de852332f68d9ca5e535f42633372aa86e5bd69406ec8a102f43b17855b32", + "python/sglang/srt/platforms/__init__.py": "2430f325fb54aa6a1265c64149e01929140e841f450f52536b344fa1c51a7ffe", + "python/sglang/srt/platforms/cpu.py": "3e3282b95d4d817bde3a4194f2189b15b6ff4523e92c1c64e14d4fb24631d84e", + "python/sglang/srt/platforms/cuda.py": "fa43e9386319d9f410cc9a9eae4af804df949eaa1d6bcde98b184f7912e32845", + "python/sglang/srt/platforms/device_mixin.py": "1956853a6cb6ff390d525d6b4e13141d7fb04360f1257ba858744fb911b64238", + "python/sglang/srt/platforms/interface.py": "9612ea0d8a40bddc7b4f36c6965352b5d76e051638b07f2551a4f703f8681a33", + "python/sglang/srt/platforms/rocm.py": "36dd7d7330e72c2dad9666c1cef97cfd92eb38545e537184cec598b5a7b90831", + "python/sglang/srt/platforms/xpu.py": "dabb92273bc96592db184ee5e3a11094b228b293b71f8b99739d6ee4d357f636", + "python/sglang/srt/plugins/__init__.py": "3a975a73f1a7887e68c81ea7a2530250597ac8ae978efc0b0f70f038a99a3164", + "python/sglang/srt/plugins/hook_registry.py": "fe214acac324cb2f019aa1dffe1ddcb6e4691862fdd1b6a0ad5033d8167e31e9", + "python/sglang/srt/ray/__init__.py": "36fc3f0c2bb9d10de55553dc6c8e67fa2ca3e3ee4984998b1201750581b4666d", + "python/sglang/srt/ray/data_parallel_controller.py": "c510f5d6bef02376d2e6f9069f25d4c6bb704235a04f073e5206ca356bc3f301", + "python/sglang/srt/ray/engine.py": "d324c2fdfb693b3f2e5628e874ad734e20ba8bd5c5b2c8555376c7c6b9c42eda", + "python/sglang/srt/ray/http_server.py": "616b9eadc53220fc2afef31af5de5891f83f3a11ad557f210a402a3153933b95", + "python/sglang/srt/ray/scheduler_actor.py": "14c1e413098f3d808c21e81082fca3fc5f2cf210c0a2c71d6eaa801eca73c4c8", + "python/sglang/srt/runtime_context.py": "f2ddc424afdf1d3710958c553586954fc3e4399919c4473c442a865c0252545d", + "python/sglang/srt/rust_extensions/__init__.py": "0add2045c132d39d0ef7eebb016156c708223ddee6f2eb6fe514f762e8237606", + "python/sglang/srt/rust_extensions/_grpc.cpython-312-x86_64-linux-gnu.so": "1f444161d000dc5c33629181d6ce0cb0993cf4471147501e8d84d78f94c2bfbe", + "python/sglang/srt/rust_extensions/_multimodal.cpython-312-x86_64-linux-gnu.so": "db9e82757193be696867d27e1549ed072f032d3b582028b135316f0d9363d4a6", + "python/sglang/srt/rust_extensions/_server.cpython-312-x86_64-linux-gnu.so": "d7d796f29c6336a69f3e7b544f2fb02583d66350a167a9c19e610c71b374dce0", + "python/sglang/srt/rust_extensions/loader.py": "0a6408b69ba1f9107eb92f207d3949672480c5fc80ce7e7c90c0752bfed0a642", + "python/sglang/srt/sampling/custom_logit_processor.py": "e0e0ab65e2ded8975a9d161a52c92cb61f2a8a02a6af485b37912cad1171e23d", + "python/sglang/srt/sampling/penaltylib/__init__.py": "75ad2cf0aabb156ec1aecffdeb906058f2fbf5669d258fefc420e50a27b0c7ba", + "python/sglang/srt/sampling/penaltylib/frequency_penalty.py": "1f17d9124d963bdc428016f856a1715743b3d803cf55de2e8fad41550e5d8a61", + "python/sglang/srt/sampling/penaltylib/min_new_tokens.py": "96e372550b022ba0bbba853f3c95966e2f0d3b7b799ac0f4082df58198befe97", + "python/sglang/srt/sampling/penaltylib/orchestrator.py": "829be20bdfad1d6f92c9eb830f320602a92203ebbf692c7d92a325bfdc0dd2a9", + "python/sglang/srt/sampling/penaltylib/presence_penalty.py": "f9f5d234903c1084b49905521b8e0ce9cc35a22d1c3e4c047c0cb4d189c291d7", + "python/sglang/srt/sampling/penaltylib/repetition_penalty.py": "4f5948005615eacae25ae3f606699d1322e376a3bd4d2f54dc422be6a73bf157", + "python/sglang/srt/sampling/sampling_batch_info.py": "05f88297e6ca48aa187d0585dcd212c89b2918f61e1020879cd4537bc9768889", + "python/sglang/srt/sampling/sampling_params.py": "9437125033cd7abe001689cef162ba558454fb455f577e7b36b4eaa4d3f95c24", + "python/sglang/srt/server_args.py": "557d26f31c473e0cd382efce9ed2bfe8702b5ad0adc750da1250df13bb3231ef", + "python/sglang/srt/server_args_config_parser.py": "3966b1206230239aa81def9fd0008d0eab68e5ce11b7bc39f369f5570287a1e6", + "python/sglang/srt/session/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/session/session_controller.py": "ceb4398ecf4fb24c10d8256797aca06db1c353dfa2acd9577e46f01ea1093ccb", + "python/sglang/srt/session/streaming_session.py": "1243ecf5ef521d9a9e9d9bea1bddd519400826a3fe16e5073cd3cb95f5acadb3", + "python/sglang/srt/speculative/adaptive_runtime_state.py": "d4e0b6bb5a3f83f6b6eaf298e08424816ef463b5f0a7a0406fa066cfd3122496", + "python/sglang/srt/speculative/adaptive_spec_params.py": "ccf74d364972786f4debc95f8da1315313b904f5ae9389c4ed1570642dcf4de7", + "python/sglang/srt/speculative/base_spec_worker.py": "214eb3b4e19ca39438d010066cc21b15c083b656a75a5322a7b0c9ef7dc87745", + "python/sglang/srt/speculative/cpp_ngram/.clang-format": "1df5c7d8812e21f15b1bebf09f61e40fcd3887678496a4f8005e9742bd55730d", + "python/sglang/srt/speculative/cpp_ngram/external_corpus.py": "1de174578c7791bec10666f1ed8df525f1f95125f25bc0a78e81e5e54dd229d2", + "python/sglang/srt/speculative/cpp_ngram/ngram_corpus.py": "bb3fef5b318f74bb8bde9eb8917ea01c222739c017bd2509bf2ecb7621cff605", + "python/sglang/srt/speculative/decoupled_spec_io.py": "e4e0951b45d720538c26784b9dd05817f0a9e76d748cecb3efdf9a6d1acbdff5", + "python/sglang/srt/speculative/dflash_info.py": "8b11954327d01955478d97cf36c514f39ca9457d37941a2be561d03a27391a1a", + "python/sglang/srt/speculative/dflash_info_v2.py": "2cc95adae184717c208e9c7f42ae5a08e81c9d4b94c907a020d5cc249c05b1fc", + "python/sglang/srt/speculative/dflash_utils.py": "a508ee114d939aa235e405e21d8b40bf3112f4534c1e3c34f7e591fbd5ed5f04", + "python/sglang/srt/speculative/dflash_worker_v2.py": "99a606e7b5e16747237a7278ef8af74317ddd28a7d08a6030fc1e34ac9e2e575", + "python/sglang/srt/speculative/draft_utils.py": "0f9981d20765169518c5031d92de81830ebfbed8256a1ad82c7f8edfb6bc7284", + "python/sglang/srt/speculative/draft_worker_common.py": "72256f9cf886248e1414339b8288340ebfdb86ab458afc13b439a42ba2dffdba", + "python/sglang/srt/speculative/dspark_components/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/speculative/dspark_components/dspark_block_accept_estimator.py": "cb475d64d5d10329ba4aca51a64ab9ff925e17dd573ca42d13be139f3be2004c", + "python/sglang/srt/speculative/dspark_components/dspark_config.py": "a4aa2d41bd4144024afadbc720ed712f24ec34b6b95732bd5e43abe3f0d8ea7c", + "python/sglang/srt/speculative/dspark_components/dspark_draft.py": "0c3dd5e26135d59f2eb9a94aa92d80da51ece28d95d9f80b2c6e9b2171a70200", + "python/sglang/srt/speculative/dspark_components/dspark_draft_sampler.py": "d00aa4a01c85b2f09b30582ddf94c3447cf3e213be3cc979d73c52ad9d5cdd32", + "python/sglang/srt/speculative/dspark_components/dspark_kv_inject.py": "74a8ea9e90211b45fa24ad5a0d28c116839a87c59644de42e3636b6e665dae95", + "python/sglang/srt/speculative/dspark_components/dspark_observability.py": "19d885307d7eb8c5c686a4e568f8a4817f8aa7128ea7e0febf6032c35517833d", + "python/sglang/srt/speculative/dspark_components/dspark_planner.py": "2986adb17dccd7ff35c0374b10ca9c3ec5829d77711d30cd364d3371e4e64443", + "python/sglang/srt/speculative/dspark_components/dspark_sps.py": "c87a7f72ad1299cbb9bb337e0ffc3bb34de2c02624e423c717c41fc41c73ee08", + "python/sglang/srt/speculative/dspark_components/dspark_sts.py": "49b0ebd5fdee14dcbb527b24d6d682d8c9e27de769e87552cbed1bc7942bd06a", + "python/sglang/srt/speculative/dspark_components/dspark_verify.py": "9f98e504eea440ab12e0f81b8301d3489992311dc65981018fc6dedabe9f604b", + "python/sglang/srt/speculative/dspark_components/dspark_worker_v2.py": "f2aceff3a360d25f55df5b87ec77d503b3aacad2bd479235a2ffd15e2fdf3425", + "python/sglang/srt/speculative/dspark_disaggregation.py": "b93b797dd537696f957fdb8fcc2ab66435d184906871beb0ce8fb2a71f31f840", + "python/sglang/srt/speculative/eagle_disaggregation.py": "8b035325c40b2c6a430df2824f6b2f4e181ba6f1556922c59c7e4ee4b47b18c4", + "python/sglang/srt/speculative/eagle_draft_cuda_graph_runner.py": "9cafd331bebca55e67d4156d3da698fe0e728e22d48fea57b2cf1babcb9e6376", + "python/sglang/srt/speculative/eagle_draft_extend_cuda_graph_runner.py": "437d3d7090ae8f5fa0f84dbb61de071b64afa65fd088be8844e542aca3649dbe", + "python/sglang/srt/speculative/eagle_info.py": "a4f2f663db7e26dcbdf4b8b08788492f04d7c6f26546a7abadfce739b9854638", + "python/sglang/srt/speculative/eagle_utils.py": "87e9dc749e94f5899140457393389397840a2258978c021fd3ac490e9da4c053", + "python/sglang/srt/speculative/eagle_worker_common.py": "7d5bc17da41ad34230dfd76da34024496983eae5453f8b1c650a9f5f924e4934", + "python/sglang/srt/speculative/eagle_worker_v2.py": "9a66d31868385646b9fb9f78053730f55d2e885e72382a8c8dc6db9f07709271", + "python/sglang/srt/speculative/external_corpus_manager.py": "6ba215fd34397ab487aa7331ae8fb157a7a084b83fe6554eddf9468a302a5287", + "python/sglang/srt/speculative/frozen_kv_mtp_cuda_graph_runner.py": "bf74eac380ab19726f34c0d568dd6aa61ad5535da759390de3f05906e8acd01c", + "python/sglang/srt/speculative/frozen_kv_mtp_info.py": "5e5b944d39a2eac1836c9bf835c5fb588ba729d1af5a77fcea52d5367f8c267c", + "python/sglang/srt/speculative/frozen_kv_mtp_utils.py": "ef46e173c4deefc85efc74b436a381479b6dfb73648fc62a6c5630604c7f8bf6", + "python/sglang/srt/speculative/frozen_kv_mtp_worker_v2.py": "f98aebcfe52c72d0becedebbf5d36596aa40b22f82bcdec2157f0599042c02f9", + "python/sglang/srt/speculative/multi_layer_eagle_draft_extend_cuda_graph_runner.py": "1ace015e04fa6706170b16967e7b7f8850397aaed481f1595bb9e8e522479515", + "python/sglang/srt/speculative/multi_layer_eagle_utils.py": "b3236abbb4b52d39fc6ff3a111ce1aad7d2f1f4d7a064271150b73a08a41f264", + "python/sglang/srt/speculative/multi_layer_eagle_worker_v2.py": "ade61a47a47d58add7884305940281ca42dd2fdbadec219d5d14d46c64a0b640", + "python/sglang/srt/speculative/ngram_info.py": "4b8886e17ca55bba9b6706ae025eed45fae307cf42a5e98e26a08c0b7313e25d", + "python/sglang/srt/speculative/ngram_worker.py": "c042a1611193b977cb9e21297589facc57bc026600e57a7abcb4d483df860172", + "python/sglang/srt/speculative/ragged_verify.py": "5226da18ce2fd3e21ef32863ee4971f70c8c82ac6b6369d58b87f1eeca1ddded", + "python/sglang/srt/speculative/spec_info.py": "f5b9ae4b4612fdb816985c54740b5791cc8cfc096389777b6fbcc2194a63b568", + "python/sglang/srt/speculative/spec_registry.py": "1242e3fa12bd64cd3aa88efeed2cb8db2962a948c2eec047d4ba423f2b7096cd", + "python/sglang/srt/speculative/spec_utils.py": "09c51c9462b99b55f588a0adc16dda2673d64b5bed8c3dcf68e15cefced98473", + "python/sglang/srt/speculative/standalone_worker_v2.py": "1f8ee2c3e6f3d071901f9774c0a90e60acad2742682d55c4fe74b1723b35465e", + "python/sglang/srt/state_capturer/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/state_capturer/base.py": "b3dde776672ba7ac6f79ea1afcd4d482c04b3544a7e29cd05fac2aeed2ef0798", + "python/sglang/srt/state_capturer/indexer_topk.py": "5f4d0275cc07720fd62365d18c403a9a0d0aefba4cd0f41a87718ebbe98d1f79", + "python/sglang/srt/state_capturer/routed_experts.py": "08da734ff1b792236663b62833a0f33fa096de48ede12326d70a593e518c5e47", + "python/sglang/srt/tokenizer/tiktoken_tokenizer.py": "6a2147ecc62b0860780ba9ccacc55ef0a93f50a282fdacf0c5661b4fac15ef8b", + "python/sglang/srt/utils/__init__.py": "ceea07a199caadc8b0172d756baa7951af26614ebb41423fd3d2f449f123a5ea", + "python/sglang/srt/utils/aio_rwlock.py": "db32ca27e0d7ca53859a17c65464dddef6420f8dd971d9659f7671ce9f88cf6c", + "python/sglang/srt/utils/aiter.py": "83a040078acd0bf41fc4e4e89e4d39e698b5cda00bf0d44897e4810c47a87425", + "python/sglang/srt/utils/async_probe.py": "fe654a2186fdb6c2974425b4946fdc82dc53194fc19339eb87cd3ab4b895d417", + "python/sglang/srt/utils/auth.py": "016734a0263cbc2bd6657481ab11535f1cac073efb7eed4bcdbf66f81dfd3ef7", + "python/sglang/srt/utils/bench_utils.py": "323c12e868d0fd850b5d33f07322b3244c8ce6f0db18f96a3d423d4731dccfb3", + "python/sglang/srt/utils/common.py": "daa9e93e9d4aee0990560eeec60ac236757112613f7dd17b805d641c2d947072", + "python/sglang/srt/utils/cuda_ipc_transport_utils.py": "2c6a043be16879ec351ae1e803c303413315eee61125d1af1391736c182d1348", + "python/sglang/srt/utils/cuda_vmm_transport_utils.py": "a2322085fde9e9183cbbd73cae5c78eeffadd09dd846aacb83284924e49fa4ef", + "python/sglang/srt/utils/cudacore_pyspy_dump_utils.py": "5ed36362bf994a75c0f23db2a40d58a9df3ff8c731853d4c8c5823f43812c427", + "python/sglang/srt/utils/custom_op.py": "ffe4447fe63be8cc9abb47d8e277ba128e7d3d2368b05378529845caccb8f135", + "python/sglang/srt/utils/device_timer.py": "e9fea4957d945e67a1e6eef31edb9ea6a178558aff721b55bdbf32a01549b2d8", + "python/sglang/srt/utils/field_validators.py": "98ebb92fbcdbdaaac5733e10eb2cbe3cc74f370092003c8f62beba3ba46b01a5", + "python/sglang/srt/utils/flatten.py": "3a62ae210a13ca536b1f5381c4de0a7f631dbedccfc8c57f4e7d86360f7baa77", + "python/sglang/srt/utils/gauge_histogram.py": "8ab119aaf7e1c5ae497948ac51d6656e5676e4659edd410c5e940b5ed68e21db", + "python/sglang/srt/utils/hf_transformers/__init__.py": "bd270b1977cdd6e52932b7d06397f925f30887713b490357e550b52e2c9478b0", + "python/sglang/srt/utils/hf_transformers/common.py": "b65aeed19332be514a0af226d7c3c002dc20e411d2fe04f58e480bc358325738", + "python/sglang/srt/utils/hf_transformers/config.py": "c87fa91cdc8dd7e0fcd6093c751d4a5a24bfb2e895480d8b83f2b109bb92265f", + "python/sglang/srt/utils/hf_transformers/gguf_native.py": "67a1976c796179a9da0e071b14de52c7d5ec3d2fa37437152662d3a7e2cf0c0a", + "python/sglang/srt/utils/hf_transformers/mistral_utils.py": "27b383c40e9e07abb1ee60c6d080eb18f0dab8b6770b5ee9f32d1de255b83932", + "python/sglang/srt/utils/hf_transformers/processor.py": "975f78a291e9a3dc12c2848789d088b5298b419e9eab8b53d0dde3b233322ad5", + "python/sglang/srt/utils/hf_transformers/tokenizer.py": "1150719b60247ea837f4a4035688462625c55c003eca487c2f56a0afa0884e6a", + "python/sglang/srt/utils/hf_transformers_patches.py": "75656fa6d4eae5f57b9be09a153178f319cf0be78843f721ea15f3b1157282a4", + "python/sglang/srt/utils/hf_transformers_utils.py": "7936a23e92f552e8c854af19134a8e19d512998cf8d1c897fe56b30af6751f78", + "python/sglang/srt/utils/host_shared_memory.py": "d2d3b7a8c95b98422cd755ef748ec107402d1f8679866f6f584904c9abb8be53", + "python/sglang/srt/utils/http_middleware_patch.py": "8aea067707a600bf8c38b1778c6468c480e4b9890b53110f4f2a171e8b20ed6b", + "python/sglang/srt/utils/invariants.py": "05a8c4a2a7b5aa57e9099c177000b026b84f3916f2c3f0fec51ed0aefdb5d928", + "python/sglang/srt/utils/json_response.py": "779bbfd1a53433fd3f82cb5eb73839c7178b42c53a5fc393f13670d53cf77cb6", + "python/sglang/srt/utils/log_utils.py": "aa0c540a2c171c54412ab07655705fd057feeef9c45e67b0fc5f30dcedb066f7", + "python/sglang/srt/utils/model_file_verifier.py": "1ea58843dbf5d688ac870d79d8c9e1abbd5a4da6292b291793d1c148e41c42b7", + "python/sglang/srt/utils/msgspec_utils.py": "488b2a3fd0bb582d6a89c7fee668a0fc0731b8447b013b6998cd510f0dc2f1ff", + "python/sglang/srt/utils/multi_stream_utils.py": "bc0c190113d146dcdcd4d977b3c450955b62ba1a03cdb018b1584d6f2f06172f", + "python/sglang/srt/utils/network.py": "e5fa85f769b8d4cdfaddebf8944e4a1bdb92f11a8e2cdf62d2af58ba56906ae1", + "python/sglang/srt/utils/numa_utils.py": "33dbebb26f5fe420b31eda14a7f041d52fa9fb4469df7f727a42f57f08fe9f01", + "python/sglang/srt/utils/nvjpeg_decoder.py": "54b918dd2d892877dfabd7f5ef6e902eb8181e1967121597bf4b89bf2f1d1791", + "python/sglang/srt/utils/nvtx_pytorch_hooks.py": "ba2bfbfb3d6c0c4bb1a9886b2bcf846c27fc79fb1da6ae4f1607da1a07875152", + "python/sglang/srt/utils/nvtx_utils.py": "c97d6b542d463f37b54c6e983b0d6ac40ca57f0402b17584ea35103339fd5775", + "python/sglang/srt/utils/offloader.py": "1d89240584d56990174e22f31f1dd89d8585075607e14f6491a943dbd44aabed", + "python/sglang/srt/utils/patch_tokenizer.py": "97ea6b88e3a53d620b145cdff4ca2f6c217b390898fd122154813474290f02cc", + "python/sglang/srt/utils/patch_torch.py": "642b5369a7e0d09e8976e7b118bfedc574d43046170be5beff2a270834309c71", + "python/sglang/srt/utils/phase_checker.py": "0cf1b7fe0dc1145a65b88cad304a190e43f5f06767b0bb5fa13b879da275468b", + "python/sglang/srt/utils/poll_based_barrier.py": "f6f8e7df644e952b9e124ec4b998d6294aeb2fb5d547d289b125658864d807fe", + "python/sglang/srt/utils/profile_merger.py": "6ef9f3fb21cc6fbcc713506fd3d24a802818658d67e21fd42bb5b3db03409aba", + "python/sglang/srt/utils/profile_utils.py": "6ad8067398af3bf3314c375e0bb4a6703e2270043cd455cb531467f96a04eaae", + "python/sglang/srt/utils/request_logger.py": "ef9551a9b941102c59a8f4959bea2a2385898561a732728b6c846e4b6e0b5778", + "python/sglang/srt/utils/rpd_utils.py": "051f87f26cecf4a603a7c72b7c87b3a5de9510d16514b20edb316aa7f193e5c9", + "python/sglang/srt/utils/runai_utils.py": "fa0f6349a489b86ff61b7ab976ee583616e8e65b60b12cbe540b719d2522a2c8", + "python/sglang/srt/utils/scheduler_status_logger.py": "c3c31b7ad76a8041f2dd790b06cc458c621dee70cc9598e264825d236a36a071", + "python/sglang/srt/utils/slow_rank_detector.py": "f35f8a5e9df7c1ebe4e231b642e4e1b1cd7b7cb76675e328bb1c157d25ec7227", + "python/sglang/srt/utils/stale_shm_cleanup.py": "7a9047c6108ac87db752d947ec632d00f5be433b9b51cbf57178959a4b2c1896", + "python/sglang/srt/utils/tensor_bridge.py": "e2928916f851d0ea70110753a6d385c40bf9b3e904e1787aad4d65d3efc9fd14", + "python/sglang/srt/utils/token_sequence_matcher.py": "392c9c96d5832a1c1ea1b05b30cc4a0cd94151f919d30cf589e75fd858c386c9", + "python/sglang/srt/utils/torch_memory_saver_adapter.py": "196266b5ac6c7a805b36c9953fcdd9cafb0dcc3ac7a9e25aae6edf34a8c6fba9", + "python/sglang/srt/utils/torch_npu_patch_utils.py": "dc2a5d7bc2f3ed09df93bcac3159016b0884fee42693c6f70d6c7a24b1b66a0e", + "python/sglang/srt/utils/triton_load_watch.py": "f1d5ba3b5d61173e475885bade2dfe18ab2d73d7875797ccb5e62d0ebceba8f5", + "python/sglang/srt/utils/video_decoder.py": "c797bc40320a0485736c5f44df2dc1745e925ca2dce5e4eac4ca5375b9baff16", + "python/sglang/srt/utils/watchdog.py": "79a9f3b5b8a9942692ad1dfec0f8371ffb8cd5712f952cc23beee0ddc2917da1", + "python/sglang/srt/utils/weight_checker.py": "6829692cf99225a184062b1e35970ee35020621694e499829422b2a5d09c9e38", + "python/sglang/srt/utils/weight_checker_comparator.py": "78cecbe9a63036622217c1e029093ed58e8d9f6725f8a7e00cfb4029d3af0dcc", + "python/sglang/srt/weight_cache/__init__.py": "d42c3173b6fdb66de79e399d0cb85cce6d4006eff5812ea17d4c853160a1c1e1", + "python/sglang/srt/weight_cache/daemon.py": "d27b31e30c5acd81604fc245c748ba5d175ab0b2ccf0da5fc2bc5c3e7576182b", + "python/sglang/srt/weight_cache/ipc_loader.py": "a916a9d33fb9a02abe3693575473223497aac418d4718fb84e86396388ebeacc", + "python/sglang/srt/weight_cache/protocol.py": "e687631db8e443a5da97b1d6c05ab6a1cadc84e327a6c4c4fb1ea3080befde96", + "python/sglang/srt/weight_sync/tensor_bucket.py": "fc50064ea51c338262394ff0b7a849100e7c46761099e27a4478e9db0ea08cc2", + "python/sglang/srt/weight_sync/utils.py": "94c4747ddca2450dc55e6b2d58842cfd288a869d67c7e6c28beaf398562154ec", + "python/sglang/test/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/accuracy_test_runner.py": "53f692a81406c5df403bb96529767d4a0557b3df4201e317128d43798f80b9eb", + "python/sglang/test/ascend/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/ascend/disaggregation_utils.py": "5de7e9a90b9b0303b23c43499b600b40beb9208318888dab649aecce262eba2c", + "python/sglang/test/ascend/e2e/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/ascend/e2e/gen_dataset_fixed_len.py": "4da5d2a09d12ffce67b97a78bc87a4990d1a5085493c7f091b495d638c942006", + "python/sglang/test/ascend/e2e/k8s_multi_pd_mix.yaml.jinja2": "d84d1fdf00ee743294f511f62ce42665805c407a65897d19f555285d0ab223b4", + "python/sglang/test/ascend/e2e/k8s_multi_pd_mix_green.yaml.jinja2": "ccab6413054a14af98bd94a24e854de8a164d6c354d84afe62f4e055e75038e8", + "python/sglang/test/ascend/e2e/k8s_multi_pd_separation.yaml.jinja2": "21b606b5cd01d8f6c37529dcb4f0269a86abd7b451eba30719d598cdb7aa5118", + "python/sglang/test/ascend/e2e/k8s_multi_pd_separation_green.yaml.jinja2": "ce53a0d0f2318191cd59fca1c2f1e67c760d3e22d8a5c8c5db4cbde56e972cb9", + "python/sglang/test/ascend/e2e/k8s_single.yaml.jinja2": "0d624a88575d7c1b30502c8487545c5e7773df176151a451e058ed806cd1e516", + "python/sglang/test/ascend/e2e/run_evalscope.sh": "67ef6e317cc0d604a4a0b4a25da4ef4a09ecfe74bb4a2156fa6075e67393a32c", + "python/sglang/test/ascend/e2e/run_npu_e2e_test.py": "574e0e3577a4a5fc35186fd1c827cac30127b793a9b8c9a4502d92b6b8d13cd0", + "python/sglang/test/ascend/e2e/run_npu_testcase.sh": "5e7ee45cee29b04ca2cd5bc4366e5443df5276e38ed351ead0aefcfd631c0090", + "python/sglang/test/ascend/e2e/test_npu_accuracy_utils.py": "04c89c28cc112eba7cf2aafa7d5d4c7026fa7a4fb8d6e37adde1865e5134a6d3", + "python/sglang/test/ascend/e2e/test_npu_multi_node_utils.py": "5888991bbba44bae42d9dbed8b809b6cb217cafe70fba84edf5184c47edd6476", + "python/sglang/test/ascend/e2e/test_npu_performance_utils.py": "78cdff791ba3bfd4400c14eb47384b9b9887f478ab1c09cb669323d7b5316cbb", + "python/sglang/test/ascend/gsm8k_ascend_mixin.py": "312df800a466752899f879f82b20067fde73097ac8294dca5eb982c1c4fd6f4e", + "python/sglang/test/ascend/npu_eval_accuracy_kit.py": "b17ca43f03d1968d70a76cf331c318118fd47e50f3f7d57f148cf45754828266", + "python/sglang/test/ascend/output_capturer.py": "cab2cad35280e6f8886665dade4faec04dfd55a5d6d34735f4021df9d5d78993", + "python/sglang/test/ascend/run_eval.py": "4fdbe4d42dc329c365fe0b512770b4191f9aed4432a6875b5e0b71c86d2cba04", + "python/sglang/test/ascend/simple_eval_mmlu.py": "38ef544ff8e6705a34fd5e90400452ba0483854ff076af1f543694c80fc836d8", + "python/sglang/test/ascend/test_ascend_utils.py": "6b3af0a9658298f9e507c962459e54a4b79226f3ff84169d2c5092db4da6c08f", + "python/sglang/test/ascend/test_embedding_base.py": "c28e5cfd4e85d43729deebb929ecb6c6875a543ccc4c8667eb5a09226a4e1530", + "python/sglang/test/ascend/test_mmlu.py": "7af841a8cd68a32d8155d2b1f653e11805d5a77e45e9790e6346d1749730d4d0", + "python/sglang/test/ascend/test_no_hf_reward_base.py": "7bc043e499b999f5376b15119176571e6a7b14ad89a67ba9f6b7b7dbca695884", + "python/sglang/test/ascend/test_npu_logging.py": "b501b946dc4fad0db29d0cf5c88955fdc0c583ae9a35be43b3b18be7b2210eae", + "python/sglang/test/ascend/vlm_utils.py": "fa6742865d00e73c7a529a00389aeed12ac3b45a9dded733f25d9167025866ca", + "python/sglang/test/cache_consistency_jitter.py": "a0fd9e0aa0efdcfefb1aa693952af263710f7f241f483aa76aa0650909691d99", + "python/sglang/test/chunked_prefill_test_utils.py": "73d47ef760ad9781374e4c1a89d52cd5fcb56013d61d76d0ec874051cc04d61b", + "python/sglang/test/ci/__init__.py": "592afe0e73bfcf4a7b75dd7b6cb4feaa7abcb821e4ddcd1e700ceb9f8163705b", + "python/sglang/test/ci/ci_register.py": "697fffeb402a782a7213009036f0dc65f204004ced0defb3579eef95264ad201", + "python/sglang/test/ci/ci_stress_utils.py": "5e390af02e06d8c09e8e2180fe2d708aa2919e9f7847e4df8e321c2ff9b061cd", + "python/sglang/test/ci/ci_utils.py": "4247b3ccecf006b9521cb87f30bfb6f39c4aa243f4bfadce31affb7f9ca65a9c", + "python/sglang/test/cpu_test_utils.py": "2f8f0c29dc7249c1ee1e7e5d98d8f8d5d9d28dea8e16a5717ee0f4e9d4cde490", + "python/sglang/test/doc_patch.py": "ad2f38b3ecd27814209e5c06554cd381514cf75db896f9e7b72367b731942dc8", + "python/sglang/test/external_models/custom_qwen2_vl.py": "78dcf3f22c157703e49370c75b7efb3d261aa97aa15c32c34f2d5ad0c4f90828", + "python/sglang/test/few_shot_gsm8k.py": "769552ebf727fed84efad1f06a96dcf3c6b47f1f092e419e828de2a6cf8cf2fb", + "python/sglang/test/few_shot_gsm8k_engine.py": "89ebe193344e063e228e9bc0b37cc43e2253c2c654ecbeeb28bee75ad2ec6840", + "python/sglang/test/gpt_oss_common.py": "cd917f99740ed7e8259631ae5deac5e01763fca760439987197eab51af05f72f", + "python/sglang/test/hicache_spec_storage_common.py": "310fcb7e8d83a1f3eb5f68299711c8c8c1905266f820b7ab779493e0e8b3cb43", + "python/sglang/test/kernels/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kernels/deepseek_v4/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kernels/deepseek_v4/common.py": "47fc8910c9b9136556d7890acfb20439e59c936f6c8a5165e9cbbcf13be3686d", + "python/sglang/test/kernels/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kernels/kv_canary/_canary_helpers.py": "bfcbfbd529148c74300fd7b56a8acd66a81de9758a500aee691e134216584f44", + "python/sglang/test/kernels/kv_canary/_constants.py": "a99f6da2171e195462e5a2a8f527b642d9fee84d45a05657d1e65d449e290c43", + "python/sglang/test/kernels/kv_canary/_differential.py": "ed39578f31377edfb051f7dd89bf35dfa100d44115115ab8e08e34dd2165aa17", + "python/sglang/test/kernels/kv_canary/_fixtures.py": "d1a04de8486032e6ace0ba6368746ec91acc63162be79bd9f2e02b5c1b9e6181", + "python/sglang/test/kernels/kv_canary/_fuzz_driver.py": "ce71b3ee13dc7b4bc03b56af4789723f5ae02408f234a29a7bb0cc3f171f68ce", + "python/sglang/test/kernels/kv_canary/_hand_oracle.py": "348a9c460689d762aff5b1ba4d40da9c6e6f5b1bf9b62dd69afdbb571973ea45", + "python/sglang/test/kernels/kv_canary/_invariants.py": "b7e2572ff9c8011dad91b4f456b644e3b23d92b197712228f7382dae09f6a2de", + "python/sglang/test/kernels/utils.py": "f524ddeb157d2f69f58e4b011e0eff4ac06ff41f3658a1adaa4389da601bf300", + "python/sglang/test/kits/abort_timeout_kit.py": "a45688c87ed84d10b202034724ae181f251fed66bdd98e37f11c5c183feeb731", + "python/sglang/test/kits/anthropic_messages_kit.py": "e01f7d7fd7de5f62992132f8cb62f749e9cb72df9065916f48d18511e2cc6cde", + "python/sglang/test/kits/attention_unittest/__init__.py": "766d5a7a5cc6e1498034f5e0bf673dc3f2f032cca1a54dfa791dd10ff86500f9", + "python/sglang/test/kits/attention_unittest/attention_methods/__init__.py": "3153177d9b08069119c6378d229022d3d61f616bd918df230fd57b7fcaf317ec", + "python/sglang/test/kits/attention_unittest/attention_methods/dense_attention.py": "33349f5da9a2ce52cc3b2296f117a7c21021fca9384101f2ddae3a5fc803fcb4", + "python/sglang/test/kits/attention_unittest/attention_methods/dsa_attention.py": "857d8fafc6dcdb65f43d96dd2edf22d41c7501559b9b307c22290a9337589e56", + "python/sglang/test/kits/attention_unittest/attention_methods/dsv4_attention.py": "a159c26c15f158546dc53017bc607ed526ea0757e1efe2eb4dac953f77ca48af", + "python/sglang/test/kits/attention_unittest/attention_methods/dual_chunk_attention.py": "a3595b42f8a0ed7e0b3c0b9133a1e09d9543cf85f2ad6591110687d7bcf93d24", + "python/sglang/test/kits/attention_unittest/attention_methods/gdn_attention.py": "f7df7659b8e904d704ce04021e00a6fc20fdaf99f88e5828cbed09980bff786d", + "python/sglang/test/kits/attention_unittest/attention_methods/kda_attention.py": "6ff3ba80a90718971c20be63cec34bef649ab16322e60b508c2d7de951f8b709", + "python/sglang/test/kits/attention_unittest/attention_methods/lightning_attention.py": "0bd85009229b975772edc058a43e39c5fd3e6101994673c60ee8255188f32f6c", + "python/sglang/test/kits/attention_unittest/attention_methods/mamba2_attention.py": "abf71406f312974c78cf61b248d9ae6859742e2a7d4d17d0fbc8ed22af93aa74", + "python/sglang/test/kits/attention_unittest/attention_methods/mla_attention.py": "1a5b0d4df7db39149c7479f9794b3ebf042b5a186bf87c5ce15699b02aec6d6e", + "python/sglang/test/kits/attention_unittest/runner_modes/__init__.py": "67b0bd82e6f07669cdbef004c2ebfab3b3885e99d0ef4c1c7d04d2a5ab5c8d73", + "python/sglang/test/kits/attention_unittest/runner_modes/cuda_graph_decode_runner.py": "96b135a452b315b6552c4c07424f00007a766ed5b08e2fb5e08a9008a05fec97", + "python/sglang/test/kits/attention_unittest/runner_modes/metadata_invariants.py": "7b38c084c715e221a8c1fb79846fdc997d9aa744fbcc6742be286d1fb2a7427d", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_cuda_graph_runner.py": "229d21a332b5a537a518ffac181494fc97b9fdd80ec63180cec40e0f47e344a0", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_draft_extend_runner.py": "07b8f21cdbffb169a6e225c769d4af55411920b67b1511e2eda578c202e4543a", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_draft_runner.py": "36fe939882a7f5688362bbc0f4327681f3de16a50435f425268d098791f63ffe", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_target_verify_runner.py": "c702279c8655be089573dd8a605c9d1e1780008cbbab36c55e2434076fbbf68a", + "python/sglang/test/kits/attention_unittest/runner_modes/split_op_runner.py": "d130f94b06f5e8244617ea6c574983666c2b464906a779b1dd4d256c7c45aecf", + "python/sglang/test/kits/basic_api_contract_kit.py": "12da293c9ac39eaf2d24b8d1a0ff92c1da90a3822b5a5c7cd0582c9d0a4d82f6", + "python/sglang/test/kits/basic_decode_correctness_kit.py": "b11161c1b46820899eb90606e7a374de0992a1bfb1957fe62e1bfc1b16eab893", + "python/sglang/test/kits/basic_scheduler_stress_kit.py": "e0139de97468cdfa514bca3dc3a2d8c7a35f6a798673ea7831b34c30e53dfedf", + "python/sglang/test/kits/cache_hit_kit.py": "180f3327a70457648fa42b620028f5043e2bfd458bf4441f04e048271742f401", + "python/sglang/test/kits/ebnf_constrained_kit.py": "a82b070f8d217493ae4e39ff3fda414f29905b2ff2e76028e5e78b80c200ee2d", + "python/sglang/test/kits/eval_accuracy_kit.py": "c66e48dc21fe072c94981694c8c86969c1057df593273db5874a33c9296509fa", + "python/sglang/test/kits/fwd_occupancy_kit.py": "5923ed5540cf401ee841b61a119957741c67e47ca0be7bf96d8bbcd547589b04", + "python/sglang/test/kits/hellaswag_kit.py": "444710eb25cdfdfc55d20b80d67cf8081d079d5a7c79ab5b25b6e5ea4d4efd56", + "python/sglang/test/kits/json_constrained_kit.py": "03571e095b07fc33b6da8ca2b760a505d54e9e923d36349fa88ad0ef4f4d1c49", + "python/sglang/test/kits/json_mode_kit.py": "bc06c240e51a456656e70f1804d5bbd2450e967267e1ed46924852716ec5dabb", + "python/sglang/test/kits/kl_divergence_kit.py": "43e268b628e794b3575921a66e8eb4e329f7623b520957ddb543c201f0488018", + "python/sglang/test/kits/lm_eval_kit.py": "960aa82f2dd609c102ff1f7e35afc1ff3d46c4ffacd571c9a93503d47935a8ba", + "python/sglang/test/kits/matched_stop_kit.py": "eb46044a2bdd12a9fa5d751af682eed5478ba33a786a1b5e104bd6c8e5150f1f", + "python/sglang/test/kits/mmmu_vlm_kit.py": "c403eab9055ef2ccc0ca7becafc6ec12a49a744083072ed1eb6b182fb6f79015", + "python/sglang/test/kits/pause_generation_kit.py": "90619f40caf6080878b0183a838dbb9d5a3abc1f387c644c89549c04894bd748", + "python/sglang/test/kits/prefix_cache_branching_kit.py": "988c5bc42886be7e71d240c089cbdf6bb7ae897b5d0a5e62512d3c6864674969", + "python/sglang/test/kits/radix_cache_server_kit.py": "a1dbf6aa2c2d8fd4a615f61e0ec660786d2303501137c10e86b328da273dc3b1", + "python/sglang/test/kits/reasoning_kit.py": "306cb78382e64aa0be24638516c93099394730def7e1937c1741c5bacaf8bf8a", + "python/sglang/test/kits/regex_constrained_kit.py": "3d0e81e11307fbedba4712d1923f953c222a88ff8680e6e0da77470b6f914a5f", + "python/sglang/test/kits/spec_decoding_kit.py": "76d3ba7b58e2bc616146dd4088707047601f42a7ae6a27c48c4cfeb688ad9dde", + "python/sglang/test/kits/spec_server_kits.py": "7f0e9a20a9761d4c595dbb598678a18390ef0730a81a1258f745e7d118ca5c5b", + "python/sglang/test/kits/streaming_session_kit.py": "47c3c03a51f20d49e0367ed68b2f6c663c01d079a9c3ab50ffe11fca08bb50f5", + "python/sglang/test/kits/unified_radix_cache_kit.py": "6d6981ec279339ca75197ece222ad72091555f3580939a970e48f54716d78f53", + "python/sglang/test/kl_multiturn_utils.py": "6e0f44b6a7e046e7759c3005bbcbfd81a4923628f92ff19dcd9f2b991445a9d7", + "python/sglang/test/kl_test_utils.py": "2222c57f45e0c4542b0c7c6e564869822265ac8cfce371eef6936af51d0a7bc6", + "python/sglang/test/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kv_canary/consts.py": "38ba3fdb420336c66176968c991092397cb680da939b30e4ef8c5b901e228351", + "python/sglang/test/kv_canary/e2e_base.py": "491f61d4e2302649852c580091e968f9d8e75b5f797fceddd2a825e2e67841ee", + "python/sglang/test/kv_canary/fixtures.py": "167b68ae08819d0a7a509b331cb3eebecfad4fbc531867509257f1308e151080", + "python/sglang/test/kv_canary/mode_config.py": "9068fc4c3a5739c010a3e4f13d8e0f632cfa42cde1ffe1b90c228d6cf946d4bd", + "python/sglang/test/kv_canary/pd_fixture.py": "78eb12ccfefb73cf3fa4252cda596a1301d7c96a78297cd6131c87825788147b", + "python/sglang/test/kv_canary/pp_fixture.py": "8c7ac6a97775311c4598369c9ecd4496068f73080f91a7cc107c6ffe129e3b10", + "python/sglang/test/kv_canary/runner_test_base.py": "cb414740122c00e1f2f639fa280cba7b334848bc8a57cc2000ef9ea9b30c0da7", + "python/sglang/test/kv_canary/utils.py": "707f882bcc1027fefe39a9442ec3143e077407862cb74671dfc8adc161eefdad", + "python/sglang/test/kv_canary/violation_assert_mixin.py": "56d64ff645e6b22edd656a0fcce86035c90de7122e4ab708ce529638f0366d06", + "python/sglang/test/kv_canary/violation_log_utils.py": "71c36def7a1daf2e8e36feeac3f62c1cb2b1b95780f1a37a44258e438fe193c5", + "python/sglang/test/layer_ut_utils.py": "0a2402a6f7798bcf2f9e0d460c29f12788ce2b8c1ec5d326280b86f7b10b9198", + "python/sglang/test/logprob_test_utils.py": "08d839683e6271c7d4fd67357babd1d8ca679f5c4990c22bdbe034682124b5e1", + "python/sglang/test/long_prompt.txt": "37733cc60234aab491177a2eeff4237a02409bd444f63dfe810239f61cfcb085", + "python/sglang/test/lora_utils.py": "b40ede0791f2404ae66ae3ddea682fa7b93120ac1fc13881935fc0b46988837d", + "python/sglang/test/manual/disaggregation/test_chunked_prefill_abort.py": "8b32d6220f47c3f53d211ad40936198d5ec9e4df8d1a3052bfeea4ef46e641fa", + "python/sglang/test/manual/disaggregation/test_disaggregation_chunked_prefill_abort.py": "69a9c35e57a0e97d80a72486c6423f1853a38bf0a6f21d217e5ab5006369c5f3", + "python/sglang/test/manual/disaggregation/test_disaggregation_peer_liveness_abort.py": "64bacb67c2c0344a2c5024e15de3ae331a3fff1fda6c0e87cdb7250bb69a2e32", + "python/sglang/test/mock_model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/mock_model/perturb_e2e_base.py": "c20818c783010300f91ecf008f329cc887ea2388877130a78a682b6788a8a8ee", + "python/sglang/test/mock_model/utils.py": "cd3e4ff77c38ea0174e61ca2cf76b3ab867408eba42ee75f1cf801f843588138", + "python/sglang/test/nightly_bench_utils.py": "76af58d680f91d2ab10d7b09b2a95ddc570f88779ab4b0cf0ac6228f92166daa", + "python/sglang/test/nightly_utils.py": "9de169b6a285d42512eb8a52eb815a7209e5312404e68ea0fcac13fd192b7ea8", + "python/sglang/test/observability/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/observability/fake_ray.py": "0e4906334f03b9c300116c740dbd2a2da65db326871c66cfa24122b21d751639", + "python/sglang/test/otel_collector.py": "00491d1e5f3d1d8e5de0defe870c146515f2912cd335e222373d3e62da488fb0", + "python/sglang/test/performance_test_runner.py": "973f9c566424627430a9214a33dcd7536784571423c43a726578b9ecede4b761", + "python/sglang/test/precision_baseline_store.py": "c179147635b897046ae51a38b1a8560df4e4eec3a09946bf55171ff0f362b4d3", + "python/sglang/test/quant_ref_utils.py": "80c04a005e3242f1ccc5af93ae5bb79ee5893c7634f440bc793c6483e52b0040", + "python/sglang/test/run_combined_tests.py": "5854fb7686cee1107643ca057fd1a20e4bce12ed001ae87733ab839e371f1775", + "python/sglang/test/run_eval.py": "0ccae307af3ea0c6cfea9e27dbe6b60b63f7ca60a91e798a00be73187facf7cb", + "python/sglang/test/runners.py": "7a5691eb92a5e13bee014f3dcfb6c3347d446b97fd7de3bb5a5a2f37cf90e47a", + "python/sglang/test/scripted_runtime/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/scripted_runtime/background_http_poster.py": "8f29c2f03b6f1fa441e28897f5a5e3590ccdea7ddd9893fe64e9d40db70bba34", + "python/sglang/test/scripted_runtime/context/__init__.py": "d3572ec52cf1e3ae7956dc14d3d8096b2f14292d6b2c000e254050da580deeb6", + "python/sglang/test/scripted_runtime/context/api.py": "42710ca730cc29eb5ea102f539239291c4ce872a683019f0d1f385809d66b60d", + "python/sglang/test/scripted_runtime/context/engine.py": "6ee003e563df38261d4e3ed89cbccf1ed8da508b1b47f4c133c99798ca36c7c9", + "python/sglang/test/scripted_runtime/context/http_post.py": "8a3312128c20819dbe1120fa8a7a8f9f7d3c38dfb17475d2f2f817e158ef7bc9", + "python/sglang/test/scripted_runtime/context/kv_pool_exhauster.py": "c67f894b46252a4b63ae98398829b2820b2d5a982fba0dfd004a5f564a96acf1", + "python/sglang/test/scripted_runtime/context/lifecycle.py": "6b948df8881b2533b2df557af75884bad6e93a53faccad7addb269a6c1a02abd", + "python/sglang/test/scripted_runtime/context/lock_ref_exhauster.py": "6390b06b289b8df782c72ed4172e2a49c2253cc7e5469d15524bdc49809c467d", + "python/sglang/test/scripted_runtime/context/queries.py": "8d737f2d99c6e0c6be1e0f48183f39872418a76f2f222874b4b9793aae6b9f8b", + "python/sglang/test/scripted_runtime/context/radix.py": "89f0e283cecbd3085bee281b057fa78574d3bceb80c433f25483a6e6e2b687ac", + "python/sglang/test/scripted_runtime/context/req_starter.py": "f0e0ffdad547f706e0b50702f759f998193990cee97f69a221c495a6979a5e2d", + "python/sglang/test/scripted_runtime/http_server.py": "0dec1cc1b10db21eb525a11a66fb38e1b51d89a966c89b1acab749f7a5b1a2ee", + "python/sglang/test/scripted_runtime/io_struct.py": "5ac739259af031471c0719cfdbdc85f18da5592db05341c3e531b228b123380f", + "python/sglang/test/scripted_runtime/req_handle.py": "594877f5cf9f88a101728d07249ce77606d5cc076f4700266ee83890ec243e26", + "python/sglang/test/scripted_runtime/scheduler_hook.py": "4e4a13979168e3051196223704c947c182a216ecbe7a8b19a87c7b254b8a02cd", + "python/sglang/test/scripted_runtime/test_case.py": "e07bda24f8662c9b370a9b3e44c6dd9bb92572c5e13765a14fafb7126e7ae3e9", + "python/sglang/test/scripted_runtime/tokenizer_recv_proxy.py": "9ba8b8bdc1a403196d3f6b941cbfefab6b2a9d12492b73d8cd4d4c23fda61e53", + "python/sglang/test/scripted_runtime/utils.py": "65cabcf96f6dcb91364cc3b149ba9f687a33bfaa2c96a9cbca8d2978459e578d", + "python/sglang/test/scripted_runtime_chunked_helpers.py": "cf73bda447dfd82b0276564470f9d5691ffff653b19f41dd79e110aa37c34e6d", + "python/sglang/test/send_one.py": "77bc3b499742f4fa19557ccca0185ddb6ad7599a3286db6b98e9e818ccd4a3dc", + "python/sglang/test/server_fixtures/default_fixture.py": "a87f02aaf39f92c582231c78b7520772fc38dabc9f3489c508968728f9cb5253", + "python/sglang/test/server_fixtures/disaggregation_fixture.py": "b6af811f6d2a335cf0a17cfefdec889754741eb235730de85a83816c4522d1cd", + "python/sglang/test/server_fixtures/dsa_mtp_fixture.py": "2744c5356309ab12cacb2b45b3972c2faf9b64b3af79e76c3deb70a4cae2fd10", + "python/sglang/test/server_fixtures/eagle_fixture.py": "c61c67b5ab45d9d41dc4eb56b14d55a04aa2c621392744550c4b079a41b9c9fb", + "python/sglang/test/server_fixtures/hybrid_attn_backend_fixture.py": "b85b7e9d59b63daf60dee8cef0ede7f84c0c7aeae2762e326e945351a0cea722", + "python/sglang/test/server_fixtures/mmmu_fixture.py": "a8d3e51af235aa0383770c148e6ab2c79ee036f0dd6faafa43073b6f884cc7ad", + "python/sglang/test/server_fixtures/ngram_fixture.py": "92632ec57b742971eda37d6b0fff08b11621184c6f72f98cb115c21d3463079a", + "python/sglang/test/server_fixtures/pcg_spec_fixture.py": "9f90c1abcbfc6f26a4d2c4dac959b9e7c230511fc5af48ec8a0b601bec6e760f", + "python/sglang/test/server_fixtures/spec_eagle_fixture.py": "34e97921df46570466d23cb2cd983741600a1a27dfded3bd12dad6c3123e95b0", + "python/sglang/test/server_fixtures/standalone_fixture.py": "04cfd925f255f16c1b0219b210fe13d9515bd25badce13480bafe234fa44d921", + "python/sglang/test/server_fixtures/streaming_session_fixture.py": "f047ed2037607eca1e4f7d7dda9a3eee2f33f4f91c606ad1824d9de21c88a74a", + "python/sglang/test/simple_eval_aime25.py": "27963c56f4a4f4e0bd6f31079c4d17cb1ea38724e32b8d90dd34a44629ff938f", + "python/sglang/test/simple_eval_aime26.py": "a8847e0ed01e32e6ff0da16c4e9c57b4fdc41e06b769be93952e7a0b1704b892", + "python/sglang/test/simple_eval_common.py": "d5e97cc180fae031f73d73af8dd4ced974975df07651891e789ade09d0ad071f", + "python/sglang/test/simple_eval_gpqa.py": "2a1dacce92d75397490edfd88bb131dfc9fd0f5df39eacf0b668595228b4e436", + "python/sglang/test/simple_eval_humaneval.py": "d26f48589356bdfcccafd46705eecb2f19c7b058c8576a9c56d259394b2082bd", + "python/sglang/test/simple_eval_longbench_v2.py": "2cb6b7a80985f0f1751c60beb9b35c681e236b3db636164163aeeb2334c7e439", + "python/sglang/test/simple_eval_math.py": "cf6d04a5cdbe518dce86b9fb18974b98cc1d104c4c896140eb164585428b8640", + "python/sglang/test/simple_eval_mgsm.py": "41b3c1e7d6d02195903f4c9dfd855db56349335723a217714b82fa77ffe4f7b2", + "python/sglang/test/simple_eval_mixed_prefix_gsm8k.py": "582a15ab52728aa22b3190091f82e91a10e6c1a6f0eea82b37c86208abc51ebb", + "python/sglang/test/simple_eval_mmlu.py": "769a0837785460c622ba61f53ecb4c3a70db72e304acd982e1f10f3149268be6", + "python/sglang/test/simple_eval_mmmu_vlm.py": "78ede20949c24df27e1896ebd1565df44d2f672c23d6f6f28f9de50592ad97ed", + "python/sglang/test/test_deepep_utils.py": "ef8f72b1304637387aad850226185906d669783d797964de347602cad72f66d7", + "python/sglang/test/test_deterministic.py": "a9f2ff426a156a45b8f69ecfc24fbfbd6c699b4aa8cba40b26e331c0cde7664a", + "python/sglang/test/test_deterministic_utils.py": "69a9a8e8db112b96405c1bc682eedb2fa3fd5da5e43723d08fa237290bb5d2f1", + "python/sglang/test/test_marlin_utils.py": "e9911ab643ba2b793959fa4d0bf35f7f1acd490761e394dbf72fea0375379e2a", + "python/sglang/test/test_programs.py": "206edce50a73450714973cd8198729fee3abd223f8bbb5fda56c3c489d2bbe66", + "python/sglang/test/test_utils.py": "b25ac72188208942156cc1cc7a96ae5cbd0fd69111ab96ce47f5b1bfb3eac81e", + "python/sglang/test/tool_call_test_runner.py": "aafc61c33f86d2bf65355f51d4f131847196527b30a4d4de113fe17a5fcec871", + "python/sglang/test/vlm_utils.py": "8c8a770aa0c8daed2d36067480471dca8e29b070801263174c905bf6cb2e749b", + "python/sglang/test/xpu/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/xpu/simple_eval_gsm8k_xpu_mixin.py": "c41867f97e6142fa19fb3f0c1bbd6be155ed05ba7d16042f4b2b613590349ef6", + "python/sglang/test/xpu/test_xpu_utils.py": "742f270c42eb37e9680d05dc87b116114241b151139d4c202b87e52c23411df2", + "python/sglang/utils.py": "8e453ae5a32c045cc7f9ee842081e727fbede9ab9c88536ebb299eb122ad8ed8", + "python/sglang/version.py": "b10f7d9ea276972352b1e9de0eb0bbb47d8ebe64c29469e15ea016a12019bb22" +} diff --git a/provenance/qwen-multimodal-alias.json b/provenance/qwen-multimodal-alias.json index 9692978..2a2f4e5 100644 --- a/provenance/qwen-multimodal-alias.json +++ b/provenance/qwen-multimodal-alias.json @@ -1,9 +1,10 @@ { - "status": "CPU-tested candidate only; not built, published, or deployed", - "base_git_commit": "93463c3466b0de9d21776fbeff95657285df8269", - "base_profile": "responses-compat-candidate", + "status": "CPU-tested and locally built candidate; not published or deployed", + "base_main_commit": "460545bf81f1ed24205232d9371e8eb1a02f3e46", + "predecessor_profile": "responses-phase-order-candidate", "base_image": "kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", - "base_inventory_sha256": "e574ce136e79576c3970da7f479b729b21d18ef8e4fe3e49ae3a5fd521866138", + "base_inventory": "responses-phase-order-runtime-files.json", + "base_inventory_sha256": "1fc662bc6553af87a0b79f2857c910de02b8aaebb0f96fd6ac11674657dbb903", "patch": "0018-qwen-flash-next-multimodal-alias.patch", "patch_sha256": "d04808b386903db5def8d309df4d0570cc007b93a45befb41b688f2178898daa", "files": { @@ -12,8 +13,10 @@ "after": "b47003e1f0840a057519adff46fc72a9318a61e2eb3ef8cedfa9eab19e98b7f7" } }, - "source_files": 4392, - "result_inventory_sha256": "3735872b9eb7f4eb2aef99d9a56abc58ac52291cbec7e99ac3c889b6008eee13", + "source_files_before": 4392, + "source_files_after": 4392, + "inventory": "qwen-multimodal-alias-runtime-files.json", + "inventory_sha256": "c88e18731d4ef0b4cd5a71c5f4b486def1677802c86303907ee50f2317714395", "historical_live_evidence": { "image_cases_passed": 16, "video_limitation": "Short four-frame video chronology remained wrong in observed cases.", diff --git a/scripts/verify_qwen_multimodal_alias.py b/scripts/verify_qwen_multimodal_alias.py index f4e3afd..d0efcf2 100755 --- a/scripts/verify_qwen_multimodal_alias.py +++ b/scripts/verify_qwen_multimodal_alias.py @@ -18,10 +18,13 @@ def digest(path): def package_records(): manifest = json.loads((ROOT / "provenance/qwen-multimodal-alias.json").read_text()) - _, inventory = responses_package_records() - base_inventory = ROOT / "provenance/responses-compat-runtime-files.json" + _, _, predecessor = responses_package_records() + base_inventory = ROOT / "provenance" / manifest["base_inventory"] if digest(base_inventory) != manifest["base_inventory_sha256"]: raise ValueError("Base inventory digest mismatch") + inventory = json.loads(base_inventory.read_text()) + if inventory != predecessor: + raise ValueError("Base inventory differs from Responses verifier") for name, hashes in manifest["files"].items(): if inventory.get(name) != hashes["before"]: raise ValueError("Multimodal preimage mismatch: " + name) @@ -35,12 +38,16 @@ def package_records(): if series != [ "0015-qwen-flash-next-effort-alias.patch", "0016-responses-namespace-custom-boundary.patch", + "0017-responses-phase-order.patch", manifest["patch"], ]: raise ValueError("Multimodal patch order differs") - encoded = (json.dumps(dict(sorted(inventory.items())), indent=2) + "\n").encode() - if hashlib.sha256(encoded).hexdigest() != manifest["result_inventory_sha256"]: - raise ValueError("Result inventory digest mismatch") + inventory_path = ROOT / "provenance" / manifest["inventory"] + recorded_inventory = json.loads(inventory_path.read_text()) + if recorded_inventory != dict(sorted(inventory.items())): + raise ValueError("Full candidate inventory differs from predecessor chain") + if digest(inventory_path) != manifest["inventory_sha256"]: + raise ValueError("Candidate inventory digest mismatch") return manifest, inventory diff --git a/tests/test_qwen_multimodal_packaging.py b/tests/test_qwen_multimodal_packaging.py index 27a0d6b..1bd4b65 100644 --- a/tests/test_qwen_multimodal_packaging.py +++ b/tests/test_qwen_multimodal_packaging.py @@ -18,6 +18,8 @@ class QwenMultimodalPackagingTest(unittest.TestCase): def test_manifest_chain_and_runtime_compile(self): manifest, inventory = verifier.package_records() self.assertEqual(len(inventory), 4392) + self.assertEqual(manifest["source_files_before"], 4392) + self.assertEqual(manifest["source_files_after"], 4392) self.assertEqual( list(manifest["files"]), ["python/sglang/srt/multimodal/processors/qwen_vl.py"], @@ -25,6 +27,28 @@ def test_manifest_chain_and_runtime_compile(self): for name in manifest["files"]: compile((ROOT / "runtime" / name).read_bytes(), name, "exec") + def test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory(self): + dockerfile = (ROOT / "Dockerfile.qwen-multimodal-alias").read_text() + copied = { + line.split()[1].removeprefix("runtime/") + for line in dockerfile.splitlines() + if line.startswith("COPY runtime/") + } + self.assertEqual( + copied, + { + "python/sglang/srt/entrypoints/openai/serving_chat.py", + "python/sglang/srt/entrypoints/openai/protocol.py", + "python/sglang/srt/entrypoints/openai/serving_responses.py", + "python/sglang/srt/entrypoints/openai/responses_compat.py", + "python/sglang/srt/function_call/qwen3_coder_detector.py", + "python/sglang/srt/multimodal/processors/qwen_vl.py", + }, + ) + self.assertIn("qwen-multimodal-alias-runtime-files.json", dockerfile) + self.assertIn("assert actual == set(expected)", dockerfile) + self.assertIn("assert not bad", dockerfile) + def test_runtime_drift_fails_closed(self): original = verifier.digest @@ -48,3 +72,15 @@ def changed(path): with patch.object(verifier, "digest", side_effect=changed): with self.assertRaisesRegex(ValueError, "patch hash mismatch"): verifier.package_records() + + def test_inventory_drift_fails_closed(self): + original = verifier.digest + + def changed(path): + if path.name == "qwen-multimodal-alias-runtime-files.json": + return "0" * 64 + return original(path) + + with patch.object(verifier, "digest", side_effect=changed): + with self.assertRaisesRegex(ValueError, "inventory digest mismatch"): + verifier.package_records() From 3fba7f08b67689f046826705c223f5e16d3c8f42 Mon Sep 17 00:00:00 2001 From: ktsaou <2662304+ktsaou@users.noreply.github.com> Date: Mon, 14 Sep 2026 09:56:58 +0000 Subject: [PATCH 15/20] fix(runtime): surface invalid generated token failures --- Dockerfile.invalid-token-failure | 15 + README.md | 4 +- docs/invalid-token-failure.md | 58 + ...0019-invalid-generated-token-failure.patch | 163 + patches/series.invalid-token-failure | 3 + provenance/invalid-token-failure.json | 30 + .../srt/entrypoints/openai/serving_chat.py | 2633 +++++++++++++ .../entrypoints/openai/serving_responses.py | 2762 ++++++++++++++ .../sglang/srt/managers/schedule_batch.py | 3398 +++++++++++++++++ scripts/test_invalid_token_failure.sh | 55 + scripts/verify_invalid_token_failure.py | 125 + tests/runtime_invalid_token_failure.py | 271 ++ tests/test_invalid_token_packaging.py | 58 + 13 files changed, 9574 insertions(+), 1 deletion(-) create mode 100644 Dockerfile.invalid-token-failure create mode 100644 docs/invalid-token-failure.md create mode 100644 patches/0019-invalid-generated-token-failure.patch create mode 100644 patches/series.invalid-token-failure create mode 100644 provenance/invalid-token-failure.json create mode 100644 runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py create mode 100644 runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py create mode 100644 runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py create mode 100755 scripts/test_invalid_token_failure.sh create mode 100755 scripts/verify_invalid_token_failure.py create mode 100644 tests/runtime_invalid_token_failure.py create mode 100644 tests/test_invalid_token_packaging.py diff --git a/Dockerfile.invalid-token-failure b/Dockerfile.invalid-token-failure new file mode 100644 index 0000000..9021fab --- /dev/null +++ b/Dockerfile.invalid-token-failure @@ -0,0 +1,15 @@ +# Qwen Flash-Next API compatibility plus invalid generated-token failures. +# All model paths, serving arguments, and runtime settings remain external. +FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 +ARG SOURCE_REVISION +LABEL org.opencontainers.image.source="https://github.com/kanadaj/sglang" \ + org.opencontainers.image.revision="${SOURCE_REVISION}" +COPY runtime/python/sglang/srt/entrypoints/openai/protocol.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py +COPY runtime/python/sglang/srt/entrypoints/openai/responses_compat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py +COPY runtime/python/sglang/srt/function_call/qwen3_coder_detector.py /sgl-workspace/sglang/python/sglang/srt/function_call/qwen3_coder_detector.py +COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py +COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py +COPY runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py /sgl-workspace/sglang/python/sglang/srt/managers/schedule_batch.py +RUN python3 -B -c 'import pathlib; p=pathlib.Path("/sgl-workspace/sglang/python/sglang/srt"); files=[p/"entrypoints/openai"/n for n in ("serving_chat.py", "protocol.py", "serving_responses.py", "responses_compat.py")]+[p/"function_call/qwen3_coder_detector.py", p/"managers/schedule_batch.py"]; [compile(f.read_bytes(), str(f), "exec") for f in files]' +ENTRYPOINT ["python3", "-m", "sglang.launch_server"] +CMD ["--help"] diff --git a/README.md b/README.md index e33e21f..3f33f6b 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,9 @@ path constructs typed output directly and retains usage details and requested logprobs; structural splitting is limited to recognized Qwen markers and the loaded `qwen3_8_flash_next` / `_text` model types. The cumulative [Qwen Flash-Next multimodal alias profile](docs/qwen-multimodal-alias.md) additionally -restores four existing Qwen VL processor paths under the release model type. +restores four existing Qwen VL processor paths under the release model type. The +[invalid generated-token failure profile](docs/invalid-token-failure.md) surfaces +scheduler token-ID faults through Chat, Completions, Messages, and Responses clients. Historical production profiles below are unchanged; no deployment is implied. Publishable source and deployment package for the locally accepted Qwen3.8 diff --git a/docs/invalid-token-failure.md b/docs/invalid-token-failure.md new file mode 100644 index 0000000..e1c71cc --- /dev/null +++ b/docs/invalid-token-failure.md @@ -0,0 +1,58 @@ +# Invalid generated-token failures — CPU candidate only + +The scheduler currently replaces an out-of-vocabulary generated token with an +EOS token and reports an ordinary stop. A speculative step at the output limit +can further replace that result with a length finish. Clients therefore receive +a successful response even though the engine produced an invalid token ID. + +This profile reports that condition as an HTTP 500 `InvalidTokenError`, excludes +the faulty token from output, and prevents the length cap from hiding the +failure. Chat and Anthropic-compatible streams emit the serialized error and +terminate. Responses requests finish with `status=failed`, a `server_error` +payload, and `response.failed`; graceful aborts without an error status remain +cancelled. + +## Composition + +Patch `0019-invalid-generated-token-failure.patch` applies after the existing +effort and Responses compatibility patches. The patch changes the scheduler and +the Chat and Responses adapters because all three layers are required to carry +the failure to clients. Their post-patch bytes live under +`runtime.invalid-token-failure/`, leaving the predecessor profile's `runtime/` +snapshot unchanged. `Dockerfile.invalid-token-failure` combines those files with +the three unchanged API compatibility files. Model paths, serving arguments, and +runtime settings remain external. + +## CPU validation + +The runner requires the exact base image to be present locally and a pinned +Qwen tokenizer directory: + +```bash +QWEN_TOKENIZER_PATH=/absolute/release/config-directory \ + bash scripts/test_invalid_token_failure.sh +python3 scripts/verify_invalid_token_failure.py +``` + +The runtime test covers negative, vocabulary-boundary, and very large token IDs; +speculative overruns at several output caps; invalid first tokens; unchanged +ordinary stop and length finishes; tokenizer-state cleanup; serialized HTTP +status values; Chat, Anthropic Messages, and Responses streaming; and Responses +non-streaming terminals. It runs in a read-only, network-disabled, GPU-disabled +container. + +For a complete source reconstruction, export `python/sglang` from the exact base +image into `TREE`, then run: + +```bash +python3 scripts/verify_invalid_token_failure.py --tree TREE --from-image +python3 scripts/verify_invalid_token_failure.py --tree TREE +``` + +## Limits + +The candidate has CPU regression and full-source reconstruction coverage. It +has not been built, published, deployed, or exercised by deliberately forcing +an invalid token on a live GPU engine. The change does not attempt to recover +generation after an invalid token; it makes the existing fatal condition +visible to clients. diff --git a/patches/0019-invalid-generated-token-failure.patch b/patches/0019-invalid-generated-token-failure.patch new file mode 100644 index 0000000..d6d2cfe --- /dev/null +++ b/patches/0019-invalid-generated-token-failure.patch @@ -0,0 +1,163 @@ +--- a/python/sglang/srt/entrypoints/openai/serving_chat.py ++++ b/python/sglang/srt/entrypoints/openai/serving_chat.py +@@ -1618,16 +1618,17 @@ + # to the normal chunk path, matching the non-stream behavior + # in tokenizer_manager._handle_abort_finish_reason. + if finish_reason_type == "abort" and isinstance( +- finish_reason.get("status_code"), HTTPStatus ++ finish_reason.get("status_code"), int + ): +- code = finish_reason["status_code"] ++ code = HTTPStatus(finish_reason["status_code"]) + error = self.create_streaming_error_response( + finish_reason.get("message", "Generation aborted."), + code.name, + code.value, + ) + yield f"data: {error}\n\n" +- break ++ yield "data: [DONE]\n\n" ++ return + finish_reasons[index] = finish_reason + + # First chunk with role +--- a/python/sglang/srt/entrypoints/openai/serving_responses.py ++++ b/python/sglang/srt/entrypoints/openai/serving_responses.py +@@ -710,6 +710,7 @@ + return self.create_error_response(str(e)) + + status = "completed" ++ finish_reason = None + if self.use_harmony: + assert isinstance(context, HarmonyContext) + output = self._make_response_output_items_with_harmony(context) +@@ -718,7 +719,8 @@ + num_generated_tokens = context.num_output_tokens + num_cached_tokens = context.num_cached_tokens + num_reasoning_tokens = context.num_reasoning_tokens +- status = self._status_from_finish_reason(context.finish_reason) ++ finish_reason = context.finish_reason ++ status = self._status_from_finish_reason(finish_reason) + else: + assert isinstance(context, SimpleContext) + final_res = context.last_output +@@ -733,9 +735,10 @@ + elif hasattr(final_res, "meta_info"): + meta_info = final_res.meta_info + +- status = self._status_from_finish_reason( ++ finish_reason = ( + meta_info.get("finish_reason") if meta_info is not None else None + ) ++ status = self._status_from_finish_reason(finish_reason) + + output_logprobs = ( + _build_output_text_logprobs(meta_info) +@@ -756,7 +759,8 @@ + num_generated_tokens = meta_info.get("completion_tokens", 0) + num_cached_tokens = meta_info.get("cached_tokens", 0) + num_reasoning_tokens = meta_info.get("reasoning_tokens", 0) +- status = self._status_from_finish_reason(meta_info.get("finish_reason")) ++ finish_reason = meta_info.get("finish_reason") ++ status = self._status_from_finish_reason(finish_reason) + elif isinstance(final_res, dict) and ( + final_res.get("prompt_token_ids") is not None + or final_res.get("output_ids") is not None +@@ -812,6 +816,7 @@ + status=status, + usage=usage, + ) ++ response.error = self._error_from_finish_reason(finish_reason) + + if request.store: + async with self.response_store_lock: +@@ -835,9 +840,27 @@ + reason = finish_reason.get("type") + elif isinstance(finish_reason, str): + reason = finish_reason ++ if reason == "length": ++ return "incomplete" ++ if reason == "error": ++ return "failed" + if reason == "abort": ++ if ( ++ isinstance(finish_reason, dict) ++ and finish_reason.get("status_code") is not None ++ ): ++ return "failed" + return "cancelled" +- return "incomplete" if reason == "length" else "completed" ++ return "completed" ++ ++ @classmethod ++ def _error_from_finish_reason(cls, finish_reason: Any) -> Optional[dict]: ++ if cls._status_from_finish_reason(finish_reason) != "failed": ++ return None ++ message = ( ++ finish_reason.get("message") if isinstance(finish_reason, dict) else None ++ ) ++ return {"code": "server_error", "message": message or "Generation aborted"} + + def _is_thinking_enabled_for_request(self, request: ResponsesRequest) -> bool: + if not self.reasoning_parser: +@@ -2627,6 +2650,7 @@ + status=status, + usage=usage, + ) ++ final_response.error = self._error_from_finish_reason(finish_reason) + if request.store: + async with self.response_store_lock: + stored = self.response_store.get(final_response.id) +@@ -2638,12 +2662,19 @@ + + terminal_event = ( + openai_responses_types.ResponseIncompleteEvent if status == "incomplete" +- else openai_responses_types.ResponseFailedEvent if status == "cancelled" +- else openai_responses_types.ResponseCompletedEvent ++ else ( ++ openai_responses_types.ResponseFailedEvent ++ if status in ("failed", "cancelled") ++ else openai_responses_types.ResponseCompletedEvent ++ ) + ) + terminal_type = ( + "response.incomplete" if status == "incomplete" +- else "response.failed" if status == "cancelled" else "response.completed" ++ else ( ++ "response.failed" ++ if status in ("failed", "cancelled") ++ else "response.completed" ++ ) + ) + yield _send_event( + terminal_event( +--- a/python/sglang/srt/managers/schedule_batch.py ++++ b/python/sglang/srt/managers/schedule_batch.py +@@ -1603,8 +1603,14 @@ + ) + if self.eos_token_ids: + self.output_ids[offset] = next(iter(self.eos_token_ids)) +- self.finished_reason = FINISH_MATCHED_STR(matched="NaN happened") +- self.finished_len = offset + 1 ++ self.finished_reason = FINISH_ABORT( ++ "Generation produced an invalid token ID.", ++ status_code=HTTPStatus.INTERNAL_SERVER_ERROR, ++ err_type="InvalidTokenError", ++ ) ++ # Never emit the faulty token or let a speculative overrun hide ++ # the engine failure behind an ordinary length finish. ++ self.finished_len = min(offset, self.sampling_params.max_new_tokens) + return True + + return False +@@ -1632,9 +1638,8 @@ + + new_accepted_tokens = self.output_ids[-new_accepted_len:] + +- # Sanitize out-of-range / NaN token ids before any decode. ++ # Reject out-of-range token IDs before any decode. + if self._check_vocab_boundary_finish(new_accepted_tokens): +- self._cap_finished_len_at_max_new_tokens() + return + + # Stop string beats EOS/stop-token matched in the same step (speculative diff --git a/patches/series.invalid-token-failure b/patches/series.invalid-token-failure new file mode 100644 index 0000000..5d04ed8 --- /dev/null +++ b/patches/series.invalid-token-failure @@ -0,0 +1,3 @@ +0015-qwen-flash-next-effort-alias.patch +0016-responses-namespace-custom-boundary.patch +0019-invalid-generated-token-failure.patch diff --git a/provenance/invalid-token-failure.json b/provenance/invalid-token-failure.json new file mode 100644 index 0000000..c774895 --- /dev/null +++ b/provenance/invalid-token-failure.json @@ -0,0 +1,30 @@ +{ + "status": "CPU-tested candidate only; not built, published, or deployed", + "base_git_commit": "93463c3466b0de9d21776fbeff95657285df8269", + "base_profile": "responses-compat-candidate", + "base_image": "kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", + "base_inventory_sha256": "e574ce136e79576c3970da7f479b729b21d18ef8e4fe3e49ae3a5fd521866138", + "patch": "0019-invalid-generated-token-failure.patch", + "patch_sha256": "e72fea4871a88e9d4fbffe06e2e6788e7b17992bc01cdf25f80ea4699e823742", + "files": { + "python/sglang/srt/entrypoints/openai/serving_chat.py": { + "before": "6d881d19da2c4a7028b0fb179cf5cdb958480612d4192c1606dfd25f98a9ba56", + "after": "fafda72ae4ed93165917bfc1b0bb90a1b676837f9e5a7611b9f3e0be6b595f83" + }, + "python/sglang/srt/entrypoints/openai/serving_responses.py": { + "before": "d46f648b557db07a430869471fcf4d7a898d50f99e495efd5eb01911c428f215", + "after": "3ffe860246810037ad58a6e79cd370fa0199bc130c1752cfe1feef4a11e87096" + }, + "python/sglang/srt/managers/schedule_batch.py": { + "before": "4965156c669a536b40250605794de9d9aa7582fde71d188ab2ecf22e766e755a", + "after": "56b475c078d2aed7fc626dd7f41559b169498da285bf729d94b76e8abda13c42" + } + }, + "source_files": 4392, + "result_inventory_sha256": "83e45a5d191a3998a68a4c9bd41227d737e5a5e4d44513bcdebb2c713db6abd5", + "cpu_regression": { + "unpatched": "11 methods: 20 failures and 2 errors", + "patched": "11 methods passed", + "scope": "Scheduler classification and Chat, Anthropic Messages, and Responses propagation" + } +} diff --git a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py new file mode 100644 index 0000000..b36e796 --- /dev/null +++ b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py @@ -0,0 +1,2633 @@ +from __future__ import annotations + +import copy +import json +import logging +import math +import time +import uuid +from enum import Enum +from http import HTTPStatus +from typing import TYPE_CHECKING, Any, AsyncGenerator, Dict, List, Optional, Union + + +class ThinkingMode(str, Enum): + """Mode for message encoding - chat vs thinking/reasoning.""" + + CHAT = "chat" + THINKING = "thinking" + + +import jinja2 +import orjson +from fastapi import Request +from fastapi.responses import ORJSONResponse, StreamingResponse +from jsonschema import Draft202012Validator, SchemaError + +from sglang.srt.entrypoints.openai import chat_encoding, encoding_dsv4, encoding_dsv32 +from sglang.srt.entrypoints.openai.protocol import ( + ChatCompletionMessageGenericParam, + ChatCompletionRequest, + ChatCompletionResponse, + ChatCompletionResponseChoice, + ChatCompletionResponseStreamChoice, + ChatCompletionStreamResponse, + ChatCompletionTokenLogprob, + ChatMessage, + ChoiceLogprobs, + DeltaMessage, + ErrorResponse, + FunctionResponse, + LogProbs, + MessageProcessingResult, + PromptTokensDetails, + ResponseParserProtocol, + SglExt, + Tool, + ToolCall, + ToolCallProcessingResult, + ToolChoice, + TopLogprob, +) +from sglang.srt.entrypoints.openai.serving_base import OpenAIServingBase +from sglang.srt.entrypoints.openai.sse_utils import build_sse_content +from sglang.srt.entrypoints.openai.usage_processor import UsageProcessor +from sglang.srt.entrypoints.openai.utils import ( + cached_tokens_details_from_dict, + process_cached_tokens_details_from_ret, + process_hidden_states_for_response, + process_hidden_states_from_ret, + process_routed_experts_from_ret, + should_include_usage, + to_openai_style_logprobs, +) +from sglang.srt.entrypoints.request_headers import apply_header_overrides +from sglang.srt.environ import envs +from sglang.srt.function_call.core_types import ToolCallItem +from sglang.srt.function_call.function_call_parser import FunctionCallParser +from sglang.srt.function_call.json_array_parser import JsonArrayParser +from sglang.srt.function_call.utils import ( + get_json_schema_constraint, + normalize_json_schema_types, +) +from sglang.srt.managers.io_struct import GenerateReqInput +from sglang.srt.parser.conversation import generate_chat_conv +from sglang.srt.parser.jinja_template_utils import process_content_for_template_format +from sglang.srt.parser.reasoning_parser import ReasoningParser + +if TYPE_CHECKING: + from sglang.srt.managers.tokenizer_manager import TokenizerManager + from sglang.srt.parser.template_manager import TemplateManager + +logger = logging.getLogger(__name__) + +_MEDIA_CONTENT_PART_TYPES = frozenset({"image_url", "video_url", "audio_url"}) + + +def normalize_tool_content(role: str, content): + """Normalize tool message content from OpenAI array format to plain string. + + OpenAI clients may send tool content as a list of content parts + (e.g. [{"type":"text","text":"..."}]) but most chat templates expect + a plain string for tool messages. Only flatten when ALL items are + pure OpenAI text parts; preserve lists containing non-text-type items + that some templates intentionally iterate over. + """ + if role != "tool" or not isinstance(content, list): + return content + parts = content + is_openai_text_parts = all( + (isinstance(p, dict) and p.get("type") == "text") or isinstance(p, str) + for p in parts + ) + if is_openai_text_parts: + text_parts = [p.get("text", "") if isinstance(p, dict) else p for p in parts] + return " ".join(text_parts) + return content + + +def parse_tool_call_arguments(arguments: str) -> Dict[str, Any]: + """Parse OpenAI tool call arguments for chat templates.""" + try: + parsed_arguments = orjson.loads(arguments) + except orjson.JSONDecodeError as exc: + raise ValueError( + "Assistant tool call function.arguments must be valid JSON." + ) from exc + + if not isinstance(parsed_arguments, dict): + raise ValueError( + "Assistant tool call function.arguments must be a JSON object." + ) + + return parsed_arguments + + +def normalize_assistant_tool_call_arguments( + message: Dict[str, Any], *, strict: bool = True +) -> None: + """Normalize assistant history tool call arguments in-place.""" + if message.get("role") != "assistant" or not isinstance( + message.get("tool_calls"), list + ): + return + + for item in message["tool_calls"]: + function = item.get("function") if isinstance(item, dict) else None + if not isinstance(function, dict): + continue + if "arguments" in function and isinstance(function["arguments"], str): + try: + function["arguments"] = parse_tool_call_arguments(function["arguments"]) + except ValueError: + if strict: + raise + + +def _extract_max_dynamic_patch(request: ChatCompletionRequest): + img_vals = [] + vid_vals = [] + for msg in request.messages or []: + content = getattr(msg, "content", None) + if not isinstance(content, list): + continue + for part in content: + # pydantic object or dict type + if getattr(part, "type", None) == "image_url": + iu = getattr(part, "image_url", None) + mdp = getattr(iu, "max_dynamic_patch", None) if iu else None + if mdp is not None: + img_vals.append(int(mdp)) + elif getattr(part, "type", None) == "video_url": + vu = getattr(part, "video_url", None) + mdp = getattr(vu, "max_dynamic_patch", None) if vu else None + if mdp is not None: + vid_vals.append(int(mdp)) + + # TODO(yuan-luo): per-item max_dynamic_patch for both image and video + img_max_dynamic_patch = min(img_vals) if img_vals else None + vid_max_dynamic_patch = min(vid_vals) if vid_vals else None + return img_max_dynamic_patch, vid_max_dynamic_patch + + +KIMI_K3_IMAGE_PLACEHOLDER = "<|kimi_image_placeholder|>" +KIMI_K3_IMAGE_PLACEHOLDER_ESCAPED = "<| kimi_image_placeholder |>" + + +def neutralize_kimi_k3_image_placeholder(text: str) -> str: + return text.replace(KIMI_K3_IMAGE_PLACEHOLDER, KIMI_K3_IMAGE_PLACEHOLDER_ESCAPED) + + +def neutralize_kimi_k3_image_placeholder_value(value: Any) -> Any: + if isinstance(value, str): + return neutralize_kimi_k3_image_placeholder(value) + if isinstance(value, list): + return [neutralize_kimi_k3_image_placeholder_value(item) for item in value] + if isinstance(value, dict): + return { + key: neutralize_kimi_k3_image_placeholder_value(item) + for key, item in value.items() + } + return value + + +class OpenAIServingChat(OpenAIServingBase): + """Handler for /v1/chat/completions requests""" + + _default_sampling_params_logged = False + _KIMI_K3_GENERATION_STUB_TOKENS = 3 + + def __init__( + self, + tokenizer_manager: TokenizerManager, + template_manager: TemplateManager, + ): + super().__init__(tokenizer_manager) + self.template_manager = template_manager + self.tool_call_parser = self.tokenizer_manager.config_value("tool_call_parser") + self.reasoning_parser = self.tokenizer_manager.config_value("reasoning_parser") + self.default_chat_template_kwargs = ( + self.tokenizer_manager.server_args.default_chat_template_kwargs or {} + ) + self._reasoning_detector = None + if self.reasoning_parser: + try: + rp = ReasoningParser( + model_type=self.reasoning_parser, + stream_reasoning=True, + tokenizer=self.tokenizer_manager.tokenizer, + ) + self._reasoning_detector = rp.detector + except ValueError as e: + logger.warning( + "Failed to initialize reasoning detector for parser '%s': %s", + self.reasoning_parser, + e, + ) + + # Get default sampling parameters from model's generation config + self.default_sampling_params = ( + self.tokenizer_manager.model_config.get_default_sampling_params() + ) + if ( + self.default_sampling_params + and not OpenAIServingChat._default_sampling_params_logged + ): + logger.info( + f"Using default chat sampling params from model generation config: {self.default_sampling_params}", + ) + OpenAIServingChat._default_sampling_params_logged = True + + # Check if the model is a GPT-OSS model + self.is_gpt_oss = ( + hasattr(self.tokenizer_manager.model_config, "hf_config") + and hasattr(self.tokenizer_manager.model_config.hf_config, "model_type") + and self.tokenizer_manager.model_config.hf_config.model_type == "gpt_oss" + ) + self.is_gemma4 = ( + hasattr(self.tokenizer_manager.model_config, "hf_config") + and hasattr(self.tokenizer_manager.model_config.hf_config, "model_type") + and self.tokenizer_manager.model_config.hf_config.model_type + in ("gemma4", "gemma4_unified") + ) + + # Which Python-based chat encoder (if any) bypasses apply_chat_template. + # Values: "dsv32", "dsv4", or custom values set by subclass. None for default. + self.chat_encoding_spec = self._resolve_chat_encoding_spec() + self._dsv4_reasoning_effort_profile = ( + chat_encoding.resolve_dsv4_reasoning_effort_profile( + model_path=self.tokenizer_manager.model_path, + revision=self.tokenizer_manager.server_args.revision, + override=self.tokenizer_manager.model_config.hf_config.to_dict().get( + chat_encoding.DSV4_REASONING_EFFORT_PROFILE_OVERRIDE + ), + ) + if self.chat_encoding_spec == "dsv4" + else None + ) + + # Resolve the env-configured Inkling effort default once: the env var is + # frozen for the server's lifetime, and a misconfigured value should + # fail at boot, not 400 every request. + self._inkling_default_reasoning_effort: Optional[float] = ( + self._get_inkling_default_reasoning_effort() + if self.chat_encoding_spec == "inkling" + else None + ) + + # Per-request response parser for custom decoding (set by _encode_messages) + self._response_parser: Optional[ResponseParserProtocol] = None + + # Probe whether ``encode("")`` returns specials. If it does, we must + # keep ``add_special_tokens=False`` at the chat-template encode site + # to avoid double BOS; otherwise the kwarg is a no-op and dropping it + # lets slow tokenizers (e.g. Kimi's TikTokenTokenizer) stay on the + # fast internal path. + try: + self._tokenizer_auto_adds_specials = ( + len(self.tokenizer_manager.tokenizer.encode("")) > 0 + ) + except Exception: + self._tokenizer_auto_adds_specials = True + + def _handle_last_assistant_message( + self, + messages: List[Dict[str, Any]], + request: ChatCompletionRequest, + ) -> tuple[List[Dict[str, Any]], Optional[str]]: + """ + Handle continue_final_message feature: separate final assistant message. + + If continue_final_message is enabled and the last message is from assistant, + extract its content and remove it from the message list. + If continue_final_message is False and the last message is from assistant, + convert it to a user message to ensure the last message is always from user. + + Only processes text-based content (strings), ignoring multimodal content (lists). + + Args: + messages: List of message dictionaries + request: ChatCompletionRequest with continue_final_message flag + + Returns: + Tuple of (processed_messages, assistant_prefix) + - processed_messages: Messages with last assistant message handled appropriately + - assistant_prefix: Content of the last assistant message (string only), or None + """ + assistant_prefix = None + if messages and messages[-1].get("role") == "assistant": + last_content = messages[-1].get("content") + # Only process string content, ignore multimodal content (lists) + if isinstance(last_content, str): + if request.continue_final_message: + # Extract content and remove the assistant message + assistant_prefix = last_content + messages = messages[:-1] + else: + # Convert the last assistant message to user message + messages[-1] = {"role": "user", "content": last_content} + return messages, assistant_prefix + + def _append_assistant_prefix_to_prompt_ids( + self, prompt_ids: List[int], assistant_prefix: str + ) -> List[int]: + """ + Append assistant prefix to prompt_ids. + + Args: + prompt_ids: Current prompt token IDs + assistant_prefix: Assistant message content to append + + Returns: + Updated prompt_ids with assistant prefix appended + """ + encoded = self.tokenizer_manager.tokenizer.encode(assistant_prefix) + if encoded and encoded[0] == self.tokenizer_manager.tokenizer.bos_token_id: + encoded = encoded[1:] + return prompt_ids + encoded + + def _resolve_chat_encoding_spec(self) -> Optional[str]: + """Determine which chat encoding spec to use. + + Override in subclass to add custom encoding specs. + """ + return chat_encoding.resolve_chat_encoding_spec( + hf_config=self.tokenizer_manager.model_config.hf_config, + tokenizer=self.tokenizer_manager.tokenizer, + tool_call_parser=self.tool_call_parser, + ) + + def _request_id_prefix(self) -> str: + return "chatcmpl-" + + def _effective_tools(self, request: ChatCompletionRequest) -> List[Tool]: + tools = list(request.tools or []) + for message in request.messages: + if ( + isinstance(message, ChatCompletionMessageGenericParam) + and message.role in ("system", "developer") + and message.tools + ): + tools.extend(message.tools) + return tools + + def _prepare_kimi_k3_messages( + self, + messages: List[Dict[str, Any]], + request: ChatCompletionRequest, + ) -> tuple[List[Dict[str, Any]], int, Optional[str]]: + image_count = 0 + for index, message in enumerate(messages): + content = message.get("content") + if isinstance(content, list): + parts = [] + for part in content: + if not isinstance(part, dict): + continue + part_type = part.get("type") + if part_type in ("text", "input_text"): + parts.append( + { + "type": "text", + "text": neutralize_kimi_k3_image_placeholder( + part["text"] + ), + } + ) + elif part_type in ("image_url", "input_image"): + image = part.get("image_url") or {} + if isinstance(image, str): + image = {"url": image, "detail": part.get("detail")} + parts.append({"type": "image_url", "image_url": image}) + image_count += 1 + message["content"] = parts + elif isinstance(content, str): + message["content"] = neutralize_kimi_k3_image_placeholder(content) + elif content is None: + message["content"] = "" + + if message.get("role") == "assistant": + for key in ("reasoning_content", "reasoning"): + if key in message: + message[key] = neutralize_kimi_k3_image_placeholder_value( + message[key] + ) + for tool_call in message.get("tool_calls") or []: + function = ( + tool_call.get("function") + if isinstance(tool_call, dict) + else None + ) + if isinstance(function, dict) and "arguments" in function: + function["arguments"] = ( + neutralize_kimi_k3_image_placeholder_value( + function["arguments"] + ) + ) + + source = request.messages[index] + if ( + isinstance(source, ChatCompletionMessageGenericParam) + and source.role in ("system", "developer") + and source.tools + ): + message["tools"] = [ + tool.model_dump(exclude_unset=True, by_alias=True) + for tool in source.tools + ] + if message.get("role") == "developer": + message["role"] = "system" + + assistant_prefix = None + if request.continue_final_message: + messages, assistant_prefix = self._handle_last_assistant_message( + messages, request + ) + return messages, image_count, assistant_prefix + + def _encode_messages( + self, + messages: List[Dict[str, Any]], + request: ChatCompletionRequest, + thinking_mode: ThinkingMode, + tools: Optional[List[Dict]] = None, + ) -> Optional[List[int]]: + """Encode messages for custom chat_encoding_spec values. + + Returns prompt_ids if handled, None to use default encoding. + """ + if self.chat_encoding_spec == "inkling": + # Inkling: render messages -> input_ids with framing tokens + ONE placeholder per + # media (encoding/expansion happens later in InklingMultimodalProcessor). The + # server's tokenizer is the base tiktoken backend; wrap it so encode_special + # supplies the framing-token overlay. + from sglang.srt.parser.inkling_renderer import render_inkling_messages + from sglang.srt.parser.inkling_tokenizer import ( + CONTENT_TEXT, + MESSAGE_MODEL, + InklingTokenizer, + ) + + inkling_tokenizer = InklingTokenizer( + tokenizer=self.tokenizer_manager.tokenizer + ) + reasoning_effort = self._parse_inkling_reasoning_effort( + request.reasoning_effort + ) + if reasoning_effort is None: + reasoning_effort = self._inkling_default_reasoning_effort + assistant_prefix = self._pop_inkling_assistant_prefix(messages, request) + prompt_ids = render_inkling_messages( + messages, + inkling_tokenizer, + add_generation_prompt=False, + tools=tools, + reasoning_effort=reasoning_effort, + ) + if assistant_prefix is not None: + # Continue the final assistant message inside an OPEN model text + # block: header + payload, no <|end_message|> and no + # <|content_model_end_sampling|>, so the model resumes the turn. + prompt_ids += [ + inkling_tokenizer.encode_special(MESSAGE_MODEL), + inkling_tokenizer.encode_special(CONTENT_TEXT), + *inkling_tokenizer.encode_text(assistant_prefix), + ] + return prompt_ids + if self.chat_encoding_spec == "kimi_k3": + messages, image_count, assistant_prefix = self._prepare_kimi_k3_messages( + messages, request + ) + template_kwargs = dict(request.chat_template_kwargs or {}) + template_kwargs.pop("tokenize", None) + template_kwargs.pop("return_dict", None) + template_kwargs.pop("image_prompts", None) + if image_count: + template_kwargs["image_prompts"] = ["<|media_pad|>"] * image_count + + if ( + request.reasoning_effort in ("low", "high", "max") + and "thinking_effort" not in template_kwargs + ): + template_kwargs["thinking_effort"] = request.reasoning_effort + elif request.reasoning_effort not in ( + None, + "none", + "low", + "high", + "max", + ): + logger.warning( + "Kimi K3 does not support reasoning_effort=%r; using the " + "encoder default.", + request.reasoning_effort, + ) + + effective_tools = self._effective_tools(request) + if ( + effective_tools + and isinstance(request.tool_choice, str) + and request.tool_choice in ("required", "none") + ): + template_kwargs.setdefault("tool_choice", request.tool_choice) + if request.response_format is not None: + template_kwargs.setdefault( + "response_format", + request.response_format.model_dump( + exclude_unset=True, by_alias=True + ), + ) + + request_tools = ( + [ + tool.model_dump(exclude_unset=True, by_alias=True) + for tool in request.tools + ] + if request.tools + else None + ) + prompt_ids = self.tokenizer_manager.tokenizer.apply_chat_template( + messages, + tokenize=True, + add_generation_prompt=True, + tools=request_tools, + return_dict=False, + **template_kwargs, + ) + if assistant_prefix: + prompt_ids = self._append_assistant_prefix_to_prompt_ids( + prompt_ids, assistant_prefix + ) + return prompt_ids + return None + + @staticmethod + def _pop_inkling_assistant_prefix( + messages: List[Dict[str, Any]], + request: ChatCompletionRequest, + ) -> Optional[str]: + """Extract the trailing assistant text for ``continue_final_message``. + + Only a plain-string assistant message with no tool calls and no + reasoning content can be continued; anything else renders as a closed + historical turn. Mutates ``messages`` in place (callers pass a copy). + """ + if not request.continue_final_message or not messages: + return None + last = messages[-1] + if ( + last.get("role") != "assistant" + or not isinstance(last.get("content"), str) + or last.get("tool_calls") + or last.get("reasoning_content") + ): + return None + messages.pop() + return last["content"] + + @staticmethod + def _parse_inkling_reasoning_effort( + value: Optional[Union[str, float]], + ) -> Optional[float]: + """Convert an OpenAI-style reasoning_effort to an Inkling float.""" + if value is None: + return None + if isinstance(value, bool): + raise ValueError("Inkling reasoning_effort must not be a boolean") + if isinstance(value, (int, float)): + parsed = float(value) + if not math.isfinite(parsed) or not 0.0 <= parsed <= 0.99: + raise ValueError("Inkling reasoning_effort must be in [0.0, 0.99]") + return parsed + _EFFORT_MAP = { + "none": 0.0, + "minimal": 0.1, + "low": 0.2, + "medium": 0.7, + "high": 0.9, + "xhigh": 0.99, + "max": 0.99, + } + if value in _EFFORT_MAP: + return _EFFORT_MAP[value] + try: + parsed = float(value) + except (ValueError, TypeError) as exc: + raise ValueError(f"invalid Inkling reasoning_effort: {value!r}") from exc + if not math.isfinite(parsed) or not 0.0 <= parsed <= 0.99: + raise ValueError("Inkling reasoning_effort must be in [0.0, 0.99]") + return parsed + + @staticmethod + def _get_inkling_default_reasoning_effort() -> float: + """Read the default Inkling reasoning effort from the environment.""" + from sglang.srt.environ import envs + + val = envs.SGLANG_INKLING_DEFAULT_REASONING_EFFORT.get() + if not val: + return 0.9 + try: + parsed = float(val) + except (ValueError, TypeError) as exc: + raise ValueError( + "SGLANG_INKLING_DEFAULT_REASONING_EFFORT must be numeric" + ) from exc + if not math.isfinite(parsed) or not 0.0 <= parsed <= 0.99: + raise ValueError( + "SGLANG_INKLING_DEFAULT_REASONING_EFFORT must be in [0.0, 0.99]" + ) + return parsed + + def _decode_response(self, ret_item: Dict[str, Any]) -> Union[str, ErrorResponse]: + """Extract text from response.""" + return ret_item["text"] + + def _get_parsed_response_fields( + self, + reasoning_text: Optional[str], + tool_calls: Optional[List[Dict]], + ) -> tuple[Optional[str], Optional[List[Dict]]]: + """Post-process reasoning and tool_calls before building response.""" + return reasoning_text, tool_calls + + def _continuous_usage_cached_details( + self, content: Dict[str, Any] + ) -> Optional[PromptTokensDetails]: + if not self.tokenizer_manager.server_args.enable_cache_report: + return None + return UsageProcessor._details_if_cached( + content["meta_info"].get("cached_tokens", 0) + ) + + def _reported_prompt_tokens(self, meta_info: Dict[str, Any]) -> int: + prompt_tokens = meta_info.get("prompt_tokens", 0) + if self.chat_encoding_spec == "kimi_k3": + # K3's three-token assistant generation stub is model input, but the + # reference API excludes it from billed/reported prompt tokens. + prompt_tokens = max(0, prompt_tokens - self._KIMI_K3_GENERATION_STUB_TOKENS) + return prompt_tokens + + async def _generate_stream_content( + self, + content: Dict[str, Any], + index: int, + request: ChatCompletionRequest, + stream_offsets: Dict[int, int], + reasoning_parser_dict: Dict, + parser_dict: Dict, + has_tool_calls: Dict[int, bool], + choice_logprobs: Optional[Dict], + finish_reason_type: Optional[str], + continuous_usage_stats: bool, + prompt_tokens: Dict[int, int], + reasoning_tokens: Dict[int, int], + completion_tokens: Dict[int, int], + ) -> AsyncGenerator[str, None]: + """Generate SSE chunks for streaming content.""" + offset = stream_offsets.get(index, 0) + if self.tokenizer_manager.server_args.incremental_streaming_output: + delta = content["text"] + else: + delta = content["text"][offset:] + stream_offsets[index] = len(content["text"]) + + # Attach logprobs to the first chunk emitted this step (reasoning, + # tool-call, or content) so they aren't dropped when a parser is active + # nor duplicated across chunks; flush any leftover at the end. + remaining_logprobs = choice_logprobs + + # Handle reasoning content + if self.reasoning_parser and request.separate_reasoning: + reasoning_text, delta = self._process_reasoning_stream( + index, + delta, + reasoning_parser_dict, + content, + request, + finish_reason_type, + ) + if reasoning_text: + usage = None + if continuous_usage_stats: + usage = UsageProcessor.calculate_token_usage( + prompt_tokens=prompt_tokens.get(index, 0), + reasoning_tokens=reasoning_tokens.get(index, 0), + completion_tokens=completion_tokens.get(index, 0), + cached_tokens=self._continuous_usage_cached_details(content), + ).model_dump() + + yield build_sse_content( + chunk_id=content["meta_info"]["id"], + created=int(time.time()), + model=request.model, + index=index, + reasoning_content=reasoning_text, + logprobs=remaining_logprobs, + usage=usage, + ) + remaining_logprobs = None + + # Handle tool calls + if self._tool_call_parsing_active(request): + async for chunk in self._process_tool_call_stream( + index, + delta, + parser_dict, + content, + request, + has_tool_calls, + continuous_usage_stats, + flush=finish_reason_type is not None and finish_reason_type != "abort", + ): + if chunk: + yield chunk + + # Send any remaining tool call arguments when generation finishes + if finish_reason_type is not None and index in parser_dict: + parser = parser_dict[index] + remaining_chunk = self._check_for_unstreamed_tool_args( + parser, content, request, index + ) + if remaining_chunk: + yield remaining_chunk + + else: + # Regular content + if delta: + usage = None + if continuous_usage_stats: + usage = UsageProcessor.calculate_token_usage( + prompt_tokens=prompt_tokens.get(index, 0), + reasoning_tokens=reasoning_tokens.get(index, 0), + completion_tokens=completion_tokens.get(index, 0), + cached_tokens=self._continuous_usage_cached_details(content), + ).model_dump() + + yield build_sse_content( + chunk_id=content["meta_info"]["id"], + created=int(time.time()), + model=request.model, + index=index, + content=delta, + logprobs=remaining_logprobs, + usage=usage, + ) + remaining_logprobs = None + + # Flush logprobs still unattached this step — only when a parser is + # active, since _process_tool_call_stream may consume the delta and emit + # no content chunk. On the plain path an empty-delta step has no chunk + # to attach to either way, and a standalone empty-delta logprobs chunk + # is not a shape clients expect. + if remaining_logprobs is not None and ( + self.reasoning_parser or self.tool_call_parser + ): + usage = None + if continuous_usage_stats: + usage = UsageProcessor.calculate_token_usage( + prompt_tokens=prompt_tokens.get(index, 0), + reasoning_tokens=reasoning_tokens.get(index, 0), + completion_tokens=completion_tokens.get(index, 0), + cached_tokens=self._continuous_usage_cached_details(content), + ).model_dump() + + yield build_sse_content( + chunk_id=content["meta_info"]["id"], + created=int(time.time()), + model=request.model, + index=index, + logprobs=remaining_logprobs, + usage=usage, + ) + + def _tool_call_parsing_active(self, request: ChatCompletionRequest) -> bool: + """Whether this request's output runs through the tool-call parser. + + The reasoning parser is told the same thing, so channel-framed formats + keep their framing intact exactly when a tool-call parser consumes it. + """ + return bool( + request.tool_choice != "none" + and self._effective_tools(request) + and self.tool_call_parser + ) + + def _validate_request(self, request: ChatCompletionRequest) -> Optional[str]: + """Validate that the input is valid.""" + if not request.messages: + return "Messages cannot be empty." + + if request.return_sampling_mask and not request.return_meta_info: + return "return_sampling_mask requires return_meta_info=true." + + media_error = self._validate_media_content(request) + if media_error: + return media_error + + effective_tools = self._effective_tools(request) + has_message_tools = any( + isinstance(message, ChatCompletionMessageGenericParam) + and message.role in ("system", "developer") + and message.tools + for message in request.messages + ) + if ( + isinstance(request.tool_choice, str) + and request.tool_choice.lower() == "required" + and not effective_tools + ): + return "Tools cannot be empty if tool choice is set to required." + + if request.tool_choice is not None and not isinstance(request.tool_choice, str): + if not effective_tools: + return "Tools cannot be empty if tool choice is set to a specific tool." + tool_name = request.tool_choice.function.name + tool_exists = any( + tool.function.name == tool_name for tool in effective_tools + ) + if not tool_exists: + return f"Tool '{tool_name}' not found in tools list." + + if has_message_tools: + names = [tool.function.name for tool in effective_tools] + if len(names) != len(set(names)): + return "Tool names must be unique across request and message tools." + + # Validate tool definitions + for i, tool in enumerate(effective_tools): + if tool.function.parameters is None: + continue + try: + # Rewrite DB/ORM-style aliases (e.g. "varchar", "enum", "int") + # to standard JSON Schema types before validation. RecursionError + # guards against hand-crafted cyclic schemas so the request gets + # a 400 instead of crashing into a 500. + normalize_json_schema_types(tool.function.parameters) + Draft202012Validator.check_schema(tool.function.parameters) + except SchemaError as e: + return f"Tool {i} function has invalid 'parameters' schema: {str(e)}" + except RecursionError: + return ( + f"Tool {i} function 'parameters' schema is too deeply nested " + "or contains a cycle." + ) + + max_output_tokens = request.max_completion_tokens or request.max_tokens + server_context_length = self.tokenizer_manager.server_args.context_length + if ( + max_output_tokens + and server_context_length + and max_output_tokens > server_context_length + ) and not self.tokenizer_manager.server_args.allow_auto_truncate: + return ( + f"max_completion_tokens is too large: {max_output_tokens}." + f"This model supports at most {server_context_length} completion tokens." + ) + + if request.response_format and request.response_format.type == "json_schema": + schema = getattr(request.response_format.json_schema, "schema_", None) + if schema is None: + return "schema_ is required for json_schema response format request." + + return None + + def _validate_media_content(self, request: ChatCompletionRequest) -> Optional[str]: + if self.tokenizer_manager.model_config.is_multimodal: + return None + + media_type = next( + ( + part.type + for message in request.messages + if isinstance(message.content, list) + for part in message.content + if part.type in _MEDIA_CONTENT_PART_TYPES + ), + None, + ) + if media_type is None: + return None + + return ( + "Model only supports text input; " + f"received unsupported content type '{media_type}'." + ) + + def _convert_to_internal_request( + self, + request: ChatCompletionRequest, + raw_request: Request = None, + ) -> tuple[GenerateReqInput, ChatCompletionRequest]: + # Keep literal caller inputs available for diagnostics on this runtime. + if self._uses_qwen_flash_next_effort_aliases(): + request = request.model_copy() + # Own the kwargs before normalization; callers may retain/share the dict. + if request.chat_template_kwargs is not None: + request.chat_template_kwargs = dict(request.chat_template_kwargs) + reasoning_effort = ( + request.chat_template_kwargs.pop("reasoning_effort", None) + if request.chat_template_kwargs + else None + ) + if self.is_gpt_oss and reasoning_effort == "none": + raise ValueError( + f"Harmony does not support reasoning effort {reasoning_effort}" + ) + + if reasoning_effort is not None: + request.reasoning_effort = reasoning_effort + + if request.stream: + if request.return_prompt_token_ids: + raise ValueError( + "return_prompt_token_ids is not supported with streaming. " + "Please set stream=false when using return_prompt_token_ids=true." + ) + if request.return_token_ids: + raise ValueError( + "return_token_ids is not supported with streaming on " + "/v1/chat/completions. Please set stream=false when using " + "return_token_ids=true." + ) + if request.return_meta_info: + raise ValueError( + "return_meta_info is not supported with streaming. " + "Please set stream=false when using return_meta_info=true." + ) + + is_multimodal = self.tokenizer_manager.model_config.is_multimodal + + # Process messages and apply chat template + processed_messages = self._process_messages( + request, is_multimodal, request_first_reasoning_effort=True + ) + if self._uses_qwen_flash_next_effort_aliases(): + request.skip_special_tokens = processed_messages.skip_special_tokens + # Build sampling parameters + sampling_params = request.to_sampling_params( + stop=processed_messages.stop, + model_generation_config=self.default_sampling_params, + tool_call_constraint=processed_messages.tool_call_constraint, + renderer_handles_response_format=self.chat_encoding_spec == "kimi_k3", + ) + + # Handle single vs multiple requests + if request.input_ids is not None: + prompt_kwargs = {"input_ids": processed_messages.prompt_ids} + elif is_multimodal and self.chat_encoding_spec == "kimi_k3": + prompt_kwargs = {"input_ids": processed_messages.prompt_ids} + elif is_multimodal: + # Standard VLMs render a text prompt (with placeholder strings) for the MM + # processor to tokenize. Inkling's custom encoder instead produces pre-rendered + # input_ids with single placeholders; pass those through so the MM processor + # expands them rather than re-tokenizing an empty prompt. Gated on the Inkling + # encoding spec so every other model keeps the standard text path. + if ( + self.chat_encoding_spec == "inkling" + and isinstance(processed_messages.prompt_ids, list) + and processed_messages.prompt_ids + ): + prompt_kwargs = {"input_ids": processed_messages.prompt_ids} + else: + prompt_kwargs = {"text": processed_messages.prompt} + else: + if isinstance(processed_messages.prompt_ids, str): + prompt_kwargs = {"text": processed_messages.prompt_ids} + else: + prompt_kwargs = {"input_ids": processed_messages.prompt_ids} + + # Extract custom labels from raw request headers + custom_labels = self.extract_custom_labels(raw_request) + + # Extract routed_dp_rank from header (has higher priority than body) + effective_routed_dp_rank = self.extract_routed_dp_rank_from_header( + raw_request, request.routed_dp_rank + ) + + # Resolve LoRA adapter from model parameter or explicit lora_path + lora_path = self._resolve_lora_path(request.model, request.lora_path) + img_max_dynamic_patch, vid_max_dynamic_patch = _extract_max_dynamic_patch( + request + ) + adapted_request = GenerateReqInput( + **prompt_kwargs, + image_data=processed_messages.image_data, + video_data=processed_messages.video_data, + audio_data=processed_messages.audio_data, + sampling_params=sampling_params, + return_logprob=request.logprobs, + logprob_start_len=-1, + top_logprobs_num=request.top_logprobs or 0, + return_sampling_mask=request.return_sampling_mask, + stream=request.stream, + return_text_in_logprobs=True, + modalities=processed_messages.modalities, + lora_path=lora_path, + bootstrap_host=request.bootstrap_host, + bootstrap_port=request.bootstrap_port, + bootstrap_room=request.bootstrap_room, + routed_dp_rank=effective_routed_dp_rank, + disagg_prefill_dp_rank=request.disagg_prefill_dp_rank, + return_hidden_states=request.return_hidden_states, + return_routed_experts=request.return_routed_experts, + routed_experts_start_len=request.routed_experts_start_len, + rid=request.rid, + session_id=request.session_id, + extra_key=request.extra_key, + cache_salt=request.cache_salt, + require_reasoning=processed_messages.require_reasoning, + priority=request.priority, + routing_key=self.extract_routing_key(raw_request), + custom_labels=custom_labels, + custom_logit_processor=request.custom_logit_processor, + images_config=getattr(request, "images_config", None), + image_max_dynamic_patch=img_max_dynamic_patch, + video_max_dynamic_patch=vid_max_dynamic_patch, + max_dynamic_patch=getattr(request, "max_dynamic_patch", None), + use_audio_in_video=getattr(request, "use_audio_in_video", False), + return_prompt_token_ids=request.return_prompt_token_ids + or request.return_token_ids, + ) + if ( + raw_request is not None + and envs.SGLANG_ENABLE_REQUEST_HEADER_OVERRIDES.get() + ): + apply_header_overrides(adapted_request, raw_request.headers) + + return adapted_request, request + + def _uses_qwen_flash_next_effort_aliases(self) -> bool: + # Use the loaded checkpoint type, never a client-controlled model alias. + return getattr( + self.tokenizer_manager.model_config.hf_config, "model_type", None + ) in ("qwen3_8_flash_next", "qwen3_8_flash_next_text") + + def _process_messages( + self, + request: ChatCompletionRequest, + is_multimodal: bool, + *, + request_first_reasoning_effort: bool = False, + ) -> MessageProcessingResult: + """Process chat messages and apply chat template""" + if self._uses_qwen_flash_next_effort_aliases(): + # Rendering-only compatibility: retain literal API effort/provenance. + # This common path also serves Responses and message tokenization. + request = request.model_copy() + ctk = dict(request.chat_template_kwargs or {}) + effort = ctk.pop("reasoning_effort", None) + if effort is None: + effort = request.reasoning_effort + if effort is None: + effort = self.default_chat_template_kwargs.get("reasoning_effort") + if effort in ("high", "max"): + effort = "xhigh" + request.reasoning_effort = effort + request.chat_template_kwargs = ctk + request_first_reasoning_effort = True + if self.default_chat_template_kwargs: + ctk = dict(request.chat_template_kwargs or {}) + for k, v in self.default_chat_template_kwargs.items(): + # Chat normalized both explicit forms; do not reinsert a default + # over that choice. Direct Responses/tokenize keep their policy. + if ( + request_first_reasoning_effort + and k == "reasoning_effort" + and request.reasoning_effort is not None + ): + continue + ctk.setdefault(k, v) + request.chat_template_kwargs = ctk + effort = ctk.get("reasoning_effort") + if effort is not None and request.reasoning_effort is None: + request.reasoning_effort = effort + + # GptOss model needs to keep special tokens for harmony parsing + if self.is_gpt_oss or self.is_gemma4: + request.skip_special_tokens = False + + self._patch_reasoning_skip_special_tokens(request) + + thinking_mode = self._get_reasoning_from_request(request) + # SGLang's ReasonerGrammarBackend owns the reasoning prefix + # when --reasoning-parser is configured, so builtin xgrammar + # tags must describe only the post-reasoning tool-call suffix. + xgrammar_reasoning = thinking_mode and (self.reasoning_parser is None) + tool_call_constraint = None + + # Apply chat template and its stop strings + tools = None + tool_call_stop = None + required_parsed_natively = False + effective_tools = self._effective_tools(request) + if effective_tools and request.tool_choice != "none": + request.skip_special_tokens = False + if not isinstance(request.tool_choice, str): + tools = [ + item.model_dump() + for item in request.tools or [] + if item.function.name == request.tool_choice.function.name + ] or None + elif request.tools: + tools = [item.model_dump() for item in request.tools] + if self.tool_call_parser: + parser = FunctionCallParser( + effective_tools, + self.tool_call_parser, + tokenizer=self.tokenizer_manager.tokenizer, + ) + tool_call_constraint = parser.get_structure_constraint( + request.tool_choice, + parallel_tool_calls=request.parallel_tool_calls, + thinking_mode=xgrammar_reasoning, + ) + required_parsed_natively = parser.detector.parses_required_natively() + if self.chat_encoding_spec == "kimi_k3": + tool_call_stop = parser.detector.eot_token + if ( + tool_call_constraint is None + and not required_parsed_natively + and not ( + self.chat_encoding_spec == "kimi_k3" + and self.tool_call_parser == "kimi_k3" + ) + and ( + request.tool_choice == "required" + or isinstance(request.tool_choice, ToolChoice) + ) + ): + json_schema = get_json_schema_constraint( + effective_tools, + request.tool_choice, + parallel_tool_calls=request.parallel_tool_calls, + ) + tool_call_constraint = ("json_schema", json_schema) + + # When input_ids are provided, skip template tokenization entirely; + # only stop tokens and tool_call_constraint are needed. + if request.input_ids is not None: + result = MessageProcessingResult( + prompt="", + prompt_ids=request.input_ids, + image_data=None, + audio_data=None, + video_data=None, + modalities=[], + stop=request.stop or [], + ) + elif self.template_manager.chat_template_name is None: + result = self._apply_jinja_template(request, tools, is_multimodal) + else: + result = self._apply_conversation_template(request, is_multimodal) + + if tool_call_stop is not None: + if isinstance(result.stop, str): + result.stop = [result.stop] + elif result.stop is None: + result.stop = [] + else: + result.stop = list(result.stop) + if tool_call_stop not in result.stop: + result.stop.append(tool_call_stop) + + result.tool_call_constraint = tool_call_constraint + result.require_reasoning = thinking_mode + result.skip_special_tokens = request.skip_special_tokens + return result + + def _apply_jinja_template( + self, + request: ChatCompletionRequest, + tools: Optional[List[Dict]], + is_multimodal: bool, + ) -> MessageProcessingResult: + """Apply Jinja chat template""" + prompt = "" + prompt_ids = [] + openai_compatible_messages = [] + image_data = [] + video_data = [] + audio_data = [] + modalities = [] + + template_content_format = self.template_manager.jinja_template_content_format + + # Try custom encoding first (override in subclass for custom renderers) + thinking_requested = (request.chat_template_kwargs or {}).get( + "thinking", envs.SGLANG_DEFAULT_THINKING.get() + ) + thinking_mode = ( + ThinkingMode.THINKING if thinking_requested else ThinkingMode.CHAT + ) + messages = [msg.model_dump() for msg in request.messages] + for message in messages: + normalize_assistant_tool_call_arguments( + message, strict=self.chat_encoding_spec != "kimi_k3" + ) + + prompt_ids = self._encode_messages( + copy.deepcopy(messages), + request, + thinking_mode, + tools=tools, + ) + + if prompt_ids is not None: + if self.chat_encoding_spec in ("inkling", "kimi_k3"): + for message in request.messages: + msg_dict = message.model_dump() + if msg_dict.get("content") is None: + msg_dict["content"] = "" + process_content_for_template_format( + msg_dict, + "openai", + image_data, + video_data, + audio_data, + modalities, + ) + elif self.chat_encoding_spec is not None: + # dsv4/dsv32 encoding path + messages = copy.deepcopy(messages) + + # dsv4/dsv32 are text-only and consume string content; flatten + # OpenAI parts-list content here so the encoder sees a plain string. + for i, msg in enumerate(messages): + if isinstance(msg.get("content"), list): + messages[i] = process_content_for_template_format( + msg, "string", [], [], [], [] + ) + + for msg in messages: + if msg.get("content") is None: + msg["content"] = "" + processed_msg = process_content_for_template_format( + msg, + template_content_format, + image_data, + video_data, + audio_data, + modalities, + use_dpsk_v32_encoding=self.chat_encoding_spec == "dsv32", + ) + msg.update(processed_msg) + + # Handle continue_final_message: separate final assistant message + messages, assistant_prefix = self._handle_last_assistant_message( + messages, request + ) + + if messages[0]["role"] != "system": + # insert an empty system prompt to help render tool system prompt + messages.insert(0, {"role": "system", "content": ""}) + if request.tools: + messages[0]["tools"] = [tool.model_dump() for tool in request.tools] + + # Default encoding (dsv4/dsv32) + if self.chat_encoding_spec == "dsv4": + effort_source = request.reasoning_effort + if effort_source is None: + env_val = envs.SGLANG_DSV4_REASONING_EFFORT.get() + if env_val: + effort_source = env_val + reasoning_effort_profile = self._dsv4_reasoning_effort_profile + assert reasoning_effort_profile is not None + accepted_efforts = encoding_dsv4.REASONING_EFFORT_PROFILES[ + reasoning_effort_profile + ] + v4_reasoning_effort = ( + effort_source if effort_source in accepted_efforts else None + ) + if request.task is not None: + encoding_dsv4.attach_task_to_last_user_message( + messages, request.task + ) + real_input = encoding_dsv4.encode_messages( + messages, + thinking_mode=thinking_mode, + reasoning_effort=v4_reasoning_effort, + reasoning_effort_profile=reasoning_effort_profile, + ) + prompt_ids = self.tokenizer_manager.tokenizer.encode(real_input) + else: + real_input = encoding_dsv32.encode_messages( + messages, thinking_mode=thinking_mode + ) + prompt_ids = self.tokenizer_manager.tokenizer.encode(real_input) + + # Append assistant prefix if continue_final_message is enabled + if assistant_prefix: + prompt_ids = self._append_assistant_prefix_to_prompt_ids( + prompt_ids, assistant_prefix + ) + else: + for msg_dict in copy.deepcopy(messages): + if msg_dict.get("content") is None: + msg_dict["content"] = "" + + # Process content based on detected template format + processed_msg = process_content_for_template_format( + msg_dict, + template_content_format, + image_data, + video_data, + audio_data, + modalities, + ) + + processed_msg["content"] = normalize_tool_content( + processed_msg["role"], processed_msg.get("content") + ) + + openai_compatible_messages.append(processed_msg) + + # Handle continue_final_message: separate final assistant message + openai_compatible_messages, assistant_prefix = ( + self._handle_last_assistant_message(openai_compatible_messages, request) + ) + + extra_template_kwargs = {} + if request.reasoning_effort is not None: + extra_template_kwargs["reasoning_effort"] = request.reasoning_effort + if request.chat_template_kwargs: + extra_template_kwargs.update(request.chat_template_kwargs) + + rc = self.template_manager.reasoning_config + if rc is not None and rc.effort_kwarg is not None: + if request.reasoning_effort == "low": + extra_template_kwargs.setdefault(rc.effort_kwarg, True) + elif request.reasoning_effort in ("medium", "high", "max"): + logger.warning( + "Model '%s' supports only 'low' reasoning effort; " + "requested '%s' treated as default thinking", + self.tokenizer_manager.served_model_name, + request.reasoning_effort, + ) + + # Split apply_chat_template(tokenize=True) into render + encode so we + # can skip add_special_tokens=False on tokenizers that don't auto-add + # specials (Kimi-like, OpenAI-chat analogue of #25265). Chat + # templates already include role/special tokens, so the encode must + # avoid double BOS on tokenizers that would add it. + encode_kwargs = ( + {"add_special_tokens": False} + if self._tokenizer_auto_adds_specials + else {} + ) + try: + rendered_prompt = self.tokenizer_manager.tokenizer.apply_chat_template( + openai_compatible_messages, + tokenize=False, + add_generation_prompt=True, + tools=tools, + return_dict=False, + **extra_template_kwargs, + ) + prompt_ids = self.tokenizer_manager.tokenizer.encode( + rendered_prompt, **encode_kwargs + ) + except Exception: + # If the first attempt fails, try with flat function-only format. + # Some templates (e.g. Mistral) expect tools without the OpenAI wrapper. + tools = ( + [t["function"] if "function" in t else t for t in tools] + if tools + else None + ) + try: + rendered_prompt = ( + self.tokenizer_manager.tokenizer.apply_chat_template( + openai_compatible_messages, + tokenize=False, + add_generation_prompt=True, + tools=tools, + return_dict=False, + **extra_template_kwargs, + ) + ) + prompt_ids = self.tokenizer_manager.tokenizer.encode( + rendered_prompt, **encode_kwargs + ) + except (jinja2.TemplateError, TypeError) as template_error: + # Template errors (e.g., from raise_exception in Jinja templates) + # and TypeError (e.g., tojson filter on Jinja2 Undefined variables) + # should be treated as client errors (400 BadRequest) + raise ValueError(str(template_error)) from template_error + + # Append assistant prefix if continue_final_message is enabled + if assistant_prefix: + prompt_ids = self._append_assistant_prefix_to_prompt_ids( + prompt_ids, assistant_prefix + ) + + if is_multimodal: + prompt = self.tokenizer_manager.tokenizer.decode(prompt_ids) + + stop = request.stop + image_data = image_data if image_data else None + audio_data = audio_data if audio_data else None + video_data = video_data if video_data else None + modalities = modalities if modalities else [] + return MessageProcessingResult( + prompt=prompt, + prompt_ids=prompt_ids, + image_data=image_data, + video_data=video_data, + audio_data=audio_data, + modalities=modalities, + stop=stop, + ) + + def _apply_conversation_template( + self, + request: ChatCompletionRequest, + is_multimodal: bool, + ) -> MessageProcessingResult: + """Apply conversation template""" + prompt = "" + prompt_ids = [] + conv = generate_chat_conv(request, self.template_manager.chat_template_name) + + # If we should continue the final assistant message, adjust the conversation. + if ( + request.continue_final_message + and request.messages + and request.messages[-1].role == "assistant" + ): + # Remove the auto-added blank assistant turn, if present. + if conv.messages and conv.messages[-1][1] is None: + conv.messages.pop() + # Rebuild the prompt from the conversation. + prompt = conv.get_prompt() + # Strip trailing stop tokens or separators that indicate end-of-assistant. + if isinstance(conv.stop_str, list): + for stop_token in conv.stop_str: + if prompt.endswith(stop_token): + prompt = prompt[: -len(stop_token)] + elif isinstance(conv.stop_str, str) and prompt.endswith(conv.stop_str): + prompt = prompt[: -len(conv.stop_str)] + if conv.sep and prompt.endswith(conv.sep): + prompt = prompt[: -len(conv.sep)] + if getattr(conv, "sep2", None) and prompt.endswith(conv.sep2): + prompt = prompt[: -len(conv.sep2)] + else: + prompt = conv.get_prompt() + if self._get_reasoning_from_request(request) and ( + self._reasoning_detector is None + or not self._reasoning_detector.thinks_internally + ): + # Models with thinks_internally=True think without a leading token + prompt += "" # Note(Xinyuan): hard code thinking token + + image_data = conv.image_data if conv.image_data else None + video_data = conv.video_data if conv.video_data else None + audio_data = conv.audio_data if conv.audio_data else None + modalities = conv.modalities if conv.modalities else [] + stop = copy.copy(conv.stop_str or [] if not request.ignore_eos else []) + + if request.stop: + if isinstance(request.stop, str): + stop.append(request.stop) + else: + stop.extend(request.stop) + + if not is_multimodal: + prompt_ids = self.tokenizer_manager.tokenizer.encode(prompt) + + return MessageProcessingResult( + prompt=prompt, + prompt_ids=prompt_ids, + image_data=image_data, + video_data=video_data, + audio_data=audio_data, + modalities=modalities, + stop=stop, + ) + + async def _handle_streaming_request( + self, + adapted_request: GenerateReqInput, + request: ChatCompletionRequest, + raw_request: Request, + ) -> Union[StreamingResponse, ErrorResponse]: + """Handle streaming chat completion request""" + generator = self._generate_chat_stream(adapted_request, request, raw_request) + + # Kick-start the generator to trigger validation before HTTP 200 is sent. + # If validation fails (e.g., context length exceeded), we can still return + # a proper HTTP 400 error response instead of streaming it as SSE payload. + try: + first_chunk = await generator.__anext__() + except ValueError as e: + return self.create_error_response(str(e)) + + async def prepend_first_chunk(): + yield first_chunk + async for chunk in generator: + yield chunk + + return StreamingResponse( + prepend_first_chunk(), + media_type="text/event-stream", + background=self.tokenizer_manager.create_abort_task(adapted_request), + ) + + async def _generate_chat_stream( + self, + adapted_request: GenerateReqInput, + request: ChatCompletionRequest, + raw_request: Request, + ) -> AsyncGenerator[str, None]: + """Generate streaming chat completion response""" + # Parsers for tool calls and reasoning + parser_dict = {} + reasoning_parser_dict = {} + + # State tracking for streaming + is_firsts = {} + stream_offsets = {} + n_prev_tokens = {} + has_tool_calls = {} + finish_reasons = {} + + # Usage tracking + prompt_tokens = {} + reasoning_tokens = {} + completion_tokens = {} + cached_tokens = {} + hidden_states = {} + routed_experts = {} + cached_tokens_details = {} + image_tokens = {} + audio_tokens = {} + video_tokens = {} + + stream_started = False + try: + include_usage, continuous_usage_stats = should_include_usage( + request.stream_options, + self.tokenizer_manager.server_args.stream_response_default_include_usage, + ) + + async for content in self.tokenizer_manager.generate_request( + adapted_request, raw_request + ): + index = content.get("index", 0) + + prompt_tokens[index] = self._reported_prompt_tokens( + content["meta_info"] + ) + completion_tokens[index] = content["meta_info"].get( + "completion_tokens", 0 + ) + reasoning_tokens[index] = content["meta_info"].get( + "reasoning_tokens", 0 + ) + cached_tokens[index] = content["meta_info"].get("cached_tokens", 0) + hidden_states[index] = content["meta_info"].get("hidden_states", None) + routed_experts[index] = content["meta_info"].get("routed_experts", None) + cached_tokens_details[index] = content["meta_info"].get( + "cached_tokens_details", None + ) + image_tokens[index] = content["meta_info"].get("image_tokens", 0) + audio_tokens[index] = content["meta_info"].get("audio_tokens", 0) + video_tokens[index] = content["meta_info"].get("video_tokens", 0) + + # Handle logprobs + choice_logprobs = None + if request.logprobs: + n_prev_token = n_prev_tokens.get(index, 0) + total_output_logprobs = content["meta_info"][ + "output_token_logprobs_length" + ] + if n_prev_token < total_output_logprobs: + choice_logprobs = self._process_streaming_logprobs( + content, n_prev_token, total_output_logprobs + ).model_dump() + n_prev_tokens[index] = total_output_logprobs + + finish_reason = content["meta_info"].get("finish_reason", None) + finish_reason_type = finish_reason["type"] if finish_reason else None + + # Track finish_reason for each index + if finish_reason_type: + # Abort with an explicit error status_code is a system error + # (timeout, OOM, validation): emit a streaming error chunk. + # A graceful abort (no status_code, e.g. user-initiated via + # /abort_request or session lifecycle cleanup) falls through + # to the normal chunk path, matching the non-stream behavior + # in tokenizer_manager._handle_abort_finish_reason. + if finish_reason_type == "abort" and isinstance( + finish_reason.get("status_code"), int + ): + code = HTTPStatus(finish_reason["status_code"]) + error = self.create_streaming_error_response( + finish_reason.get("message", "Generation aborted."), + code.name, + code.value, + ) + yield f"data: {error}\n\n" + yield "data: [DONE]\n\n" + return + finish_reasons[index] = finish_reason + + # First chunk with role + if is_firsts.get(index, True): + is_firsts[index] = False + yield build_sse_content( + chunk_id=content["meta_info"]["id"], + created=int(time.time()), + model=request.model, + index=index, + role="assistant", + content="", + ) + stream_started = True + + # Generate streaming content (override in subclass for custom behavior) + async for chunk in self._generate_stream_content( + content=content, + index=index, + request=request, + stream_offsets=stream_offsets, + reasoning_parser_dict=reasoning_parser_dict, + parser_dict=parser_dict, + has_tool_calls=has_tool_calls, + choice_logprobs=choice_logprobs, + finish_reason_type=finish_reason_type, + continuous_usage_stats=continuous_usage_stats, + prompt_tokens=prompt_tokens, + reasoning_tokens=reasoning_tokens, + completion_tokens=completion_tokens, + ): + yield chunk + + # Send finish_reason chunks for each index that completed + for idx, finish_reason_data in finish_reasons.items(): + finish_reason_type = finish_reason_data["type"] + + # Change finish_reason to "tool_calls" if we had tool calls and stopped naturally + final_finish_reason = finish_reason_type + if has_tool_calls.get(idx, False) and finish_reason_type == "stop": + final_finish_reason = "tool_calls" + + matched_stop = finish_reason_data.get("matched") + yield build_sse_content( + chunk_id=content["meta_info"]["id"], + created=int(time.time()), + model=request.model, + index=idx, + finish_reason=final_finish_reason, + matched_stop=matched_stop, + ) + + # Send hidden states if requested + if request.return_hidden_states and hidden_states: + for index, choice_hidden_states in hidden_states.items(): + if choice_hidden_states: + response_hidden_states = process_hidden_states_for_response( + choice_hidden_states, request.return_hidden_states + ) + hidden_states_chunk = ChatCompletionStreamResponse( + id=content["meta_info"]["id"], + created=int(time.time()), + choices=[ + ChatCompletionResponseStreamChoice( + index=index, + delta=DeltaMessage( + hidden_states=response_hidden_states + ), + finish_reason=None, # Hidden states don't need finish_reason + ) + ], + model=request.model, + ) + yield f"data: {hidden_states_chunk.model_dump_json()}\n\n" + + sglext_routed = None + if request.return_routed_experts and routed_experts: + sglext_routed = next( + (v for v in routed_experts.values() if v is not None), None + ) + + sglext_details = None + if request.return_cached_tokens_details and cached_tokens_details: + first_details = next( + (v for v in cached_tokens_details.values() if v is not None), None + ) + if first_details is not None: + sglext_details = cached_tokens_details_from_dict(first_details) + + if sglext_routed is not None or sglext_details is not None: + sglext_chunk = ChatCompletionStreamResponse( + id=content["meta_info"]["id"], + created=int(time.time()), + choices=[], # sglext is at response level + model=request.model, + sglext=SglExt( + routed_experts=sglext_routed, + cached_tokens_details=sglext_details, + ), + ) + yield f"data: {sglext_chunk.model_dump_json()}\n\n" + + # Additional usage chunk + if include_usage: + # Multimodal tokens are per-prompt (input side), so aggregate + # once per prompt (first choice), matching prompt/cached semantics. + total_image_tokens = sum( + tok for idx, tok in image_tokens.items() if idx % request.n == 0 + ) + total_audio_tokens = sum( + tok for idx, tok in audio_tokens.items() if idx % request.n == 0 + ) + total_video_tokens = sum( + tok for idx, tok in video_tokens.items() if idx % request.n == 0 + ) + usage = UsageProcessor.calculate_streaming_usage( + prompt_tokens, + reasoning_tokens, + completion_tokens, + cached_tokens=cached_tokens, + n_choices=request.n, + enable_cache_report=self.tokenizer_manager.server_args.enable_cache_report, + image_tokens=total_image_tokens, + audio_tokens=total_audio_tokens, + video_tokens=total_video_tokens, + ) + usage_chunk = ChatCompletionStreamResponse( + id=content["meta_info"]["id"], + created=int(time.time()), + choices=[], # Empty choices array as per OpenAI spec + model=request.model, + usage=usage, + ) + yield f"data: {usage_chunk.model_dump_json()}\n\n" + + except ValueError as e: + if not stream_started: + raise + error = self.create_streaming_error_response(str(e)) + yield f"data: {error}\n\n" + + yield "data: [DONE]\n\n" + + async def _handle_non_streaming_request( + self, + adapted_request: GenerateReqInput, + request: ChatCompletionRequest, + raw_request: Request, + ) -> Union[ChatCompletionResponse, ErrorResponse, ORJSONResponse]: + """Handle non-streaming chat completion request""" + try: + ret = await self.tokenizer_manager.generate_request( + adapted_request, raw_request + ).__anext__() + except ValueError as e: + return self.create_error_response(str(e)) + + if not isinstance(ret, list): + ret = [ret] + + response = self._build_chat_response( + request, + ret, + int(time.time()), + ) + + return response + + def _build_chat_response( + self, + request: ChatCompletionRequest, + ret: List[Dict[str, Any]], + created: int, + ) -> Union[ChatCompletionResponse, ORJSONResponse]: + """Build chat completion response from generation results""" + if self.chat_encoding_spec == "kimi_k3": + ret = [ + { + **item, + "meta_info": { + **item["meta_info"], + "prompt_tokens": self._reported_prompt_tokens( + item["meta_info"] + ), + }, + } + for item in ret + ] + + choices = [] + + # Build sglext at response level (from first ret_item, as these are per-request) + first_ret = ret[0] + routed_experts = process_routed_experts_from_ret(first_ret, request) + cached_tokens_details = process_cached_tokens_details_from_ret( + first_ret, request + ) + response_sglext = None + if routed_experts or cached_tokens_details: + response_sglext = SglExt( + routed_experts=routed_experts, + cached_tokens_details=cached_tokens_details, + ) + + for idx, ret_item in enumerate(ret): + # Process logprobs + choice_logprobs = None + if request.logprobs: + choice_logprobs = self._process_response_logprobs(ret_item) + + # Handle hidden states + hidden_states = process_hidden_states_from_ret(ret_item, request) + + finish_reason = ret_item["meta_info"]["finish_reason"] + + text = self._decode_response(ret_item) + if isinstance(text, ErrorResponse): + return ORJSONResponse(content=text.model_dump(), status_code=text.code) + + # Handle reasoning content + reasoning_text = None + if self.reasoning_parser and request.separate_reasoning: + force_reasoning = ( + self.template_manager.force_reasoning + or self._get_reasoning_from_request(request) + ) + try: + parser = ReasoningParser( + model_type=self.reasoning_parser, + stream_reasoning=False, + force_reasoning=force_reasoning, + request=request, + tokenizer=self.tokenizer_manager.tokenizer, + tool_call_parser_active=self._tool_call_parsing_active(request), + ) + reasoning_text, text = parser.parse_non_stream(text) + except Exception as e: + logger.error(f"Reasoning parsing error: {e}") + return self.create_error_response( + "Failed to parse reasoning content", + err_type="InternalServerError", + status_code=500, + ) + + # Handle tool calls + tool_calls = None + effective_tools = self._effective_tools(request) + if self._tool_call_parsing_active(request): + history_tool_calls_cnt = self._get_history_tool_calls_cnt(request) + tool_calls, text, finish_reason = self._process_tool_calls( + text, + effective_tools, + finish_reason, + request.tool_choice, + history_tool_calls_cnt, + ) + + # Extract prompt_token_ids if requested + choice_prompt_token_ids = ( + ret_item.get("prompt_token_ids") + if request.return_prompt_token_ids or request.return_token_ids + else None + ) + choice_token_ids = ( + ret_item["output_ids"] if request.return_token_ids else None + ) + + choice_meta_info = ( + ret_item["meta_info"] if request.return_meta_info else None + ) + # NOTE: content should not be None but empty string to make sure retokenize consistency. + reasoning_text, tool_calls = self._get_parsed_response_fields( + reasoning_text, tool_calls + ) + + choice_data = ChatCompletionResponseChoice( + index=idx, + message=ChatMessage( + role="assistant", + content=text if text else "", + tool_calls=tool_calls, + reasoning_content=reasoning_text if reasoning_text else None, + ), + logprobs=choice_logprobs, + finish_reason=finish_reason["type"] if finish_reason else None, + matched_stop=( + finish_reason["matched"] + if finish_reason and "matched" in finish_reason + else None + ), + hidden_states=hidden_states, + prompt_token_ids=choice_prompt_token_ids, + token_ids=choice_token_ids, + meta_info=choice_meta_info, + ) + choices.append(choice_data) + + # Calculate usage. Multimodal tokens are per-prompt (input side), so + # aggregate once per prompt (stride by n), matching prompt/cached semantics. + image_tokens = sum( + ret[i]["meta_info"].get("image_tokens", 0) + for i in range(0, len(ret), request.n) + ) + audio_tokens = sum( + ret[i]["meta_info"].get("audio_tokens", 0) + for i in range(0, len(ret), request.n) + ) + video_tokens = sum( + ret[i]["meta_info"].get("video_tokens", 0) + for i in range(0, len(ret), request.n) + ) + usage = UsageProcessor.calculate_response_usage( + ret, + n_choices=request.n, + enable_cache_report=self.tokenizer_manager.server_args.enable_cache_report, + image_tokens=image_tokens, + audio_tokens=audio_tokens, + video_tokens=video_tokens, + ) + + return ChatCompletionResponse( + id=ret[0]["meta_info"]["id"], + created=created, + model=request.model, + choices=choices, + usage=usage, + metadata={"weight_version": ret[0]["meta_info"]["weight_version"]}, + sglext=response_sglext, + ) + + def _process_logprobs_tokens( + self, logprobs: LogProbs, use_token_index: bool = False + ) -> List[ChatCompletionTokenLogprob]: + """Common helper to process logprobs tokens for both streaming and non-streaming + + Args: + logprobs: LogProbs data from model + use_token_index: True for non-streaming (use token_idx), False for streaming (use index 0) + """ + token_logprobs = [] + + for token_idx, (token, logprob) in enumerate( + zip(logprobs.tokens, logprobs.token_logprobs) + ): + token_bytes = list(token.encode("utf-8")) + top_logprobs = [] + if logprobs.top_logprobs: + # - Non-streaming (use_token_index=True): uses token_idx for full data + # - Streaming (use_token_index=False): uses index 0 for pre-sliced data + top_logprobs_idx = token_idx if use_token_index else 0 + for top_token, top_logprob in logprobs.top_logprobs[ + top_logprobs_idx + ].items(): + top_token_bytes = list(top_token.encode("utf-8")) + top_logprobs.append( + TopLogprob( + token=top_token, + bytes=top_token_bytes, + logprob=top_logprob, + ) + ) + token_logprobs.append( + ChatCompletionTokenLogprob( + token=token, + bytes=token_bytes, + logprob=logprob, + top_logprobs=top_logprobs, + ) + ) + + return token_logprobs + + def _process_response_logprobs(self, ret_item: Dict[str, Any]) -> ChoiceLogprobs: + """Process logprobs for non-streaming response""" + logprobs = to_openai_style_logprobs( + output_token_logprobs=ret_item["meta_info"]["output_token_logprobs"], + output_top_logprobs=ret_item["meta_info"].get("output_top_logprobs", None), + ) + + token_logprobs = self._process_logprobs_tokens(logprobs, use_token_index=True) + return ChoiceLogprobs(content=token_logprobs) + + def _process_tool_call_id( + self, + call_item: ToolCallItem, + history_tool_calls_cnt: int, + ) -> str: + """Process for generating a new and unique `tool_call_id`""" + if self.tool_call_parser == "kimi_k3": + return f"{call_item.name}:{history_tool_calls_cnt + call_item.tool_index}" + if self.tool_call_parser != "kimi_k2": + # A simple uuid is sufficient for all models except for Kimi-K2. + tool_call_id = f"call_{uuid.uuid4().hex[:24]}" + return tool_call_id + tool_call_id = ( + f"functions.{call_item.name}:" + f"{history_tool_calls_cnt + call_item.tool_index}" + ) + logger.debug( + f"Process tool call idx, parser: {self.tool_call_parser}, tool_call_id: {tool_call_id}, history_cnt: {history_tool_calls_cnt}" + ) + return tool_call_id + + def _process_tool_calls( + self, + text: str, + tools: List[Any], + finish_reason: Dict[str, Any], + tool_choice: Optional[Union[str, ToolChoice]] = None, + history_tool_calls_cnt: int = 0, + ) -> ToolCallProcessingResult: + """Process tool calls in the response""" + + is_required = tool_choice == "required" or isinstance(tool_choice, ToolChoice) + + # Try model-specific parser when output is in native format. + # For required/named: only use parser when structural_tag was used + # as constraint (mirrors the streaming path). For auto: always try. + if self.tool_call_parser: + parser = FunctionCallParser( + tools, self.tool_call_parser, tokenizer=self.tokenizer_manager.tokenizer + ) + should_try_parser = ( + not is_required + or parser.detector.supports_structural_tag() + or parser.detector.parses_required_natively() + ) + if should_try_parser and parser.has_tool_call(text): + try: + text, call_info_list = parser.parse_non_stream(text) + if not call_info_list: + return ToolCallProcessingResult(None, text, finish_reason) + + tool_calls = [] + for call_info in call_info_list: + tool_id = self._process_tool_call_id( + call_info, history_tool_calls_cnt + ) + tool_calls.append( + ToolCall( + id=tool_id, + index=getattr(call_info, "tool_index", None), + function=FunctionResponse( + name=call_info.name, + arguments=call_info.parameters, + ), + ) + ) + if finish_reason["type"] == "stop": + finish_reason["type"] = "tool_calls" + finish_reason["matched"] = None + return ToolCallProcessingResult(tool_calls, text, finish_reason) + except Exception as e: + logger.error(f"Tool call parsing error: {e}") + return ToolCallProcessingResult(None, text, finish_reason) + + # json_schema constraint → JSON array output for required/named + if is_required: + original_finish_type = finish_reason["type"] + if finish_reason["type"] == "stop": + finish_reason["type"] = "tool_calls" + finish_reason["matched"] = None + try: + tool_call_data = orjson.loads(text) + tool_calls = [] + for i, tool in enumerate(tool_call_data): + call_info = ToolCallItem( + tool_index=i, + name=tool["name"], + parameters=json.dumps(tool["parameters"], ensure_ascii=False), + ) + tool_id = self._process_tool_call_id( + call_info, history_tool_calls_cnt + ) + tool_calls.append( + ToolCall( + id=tool_id, + index=i, + function=FunctionResponse( + name=tool["name"], + arguments=json.dumps( + tool["parameters"], ensure_ascii=False + ), + ), + ) + ) + return ToolCallProcessingResult(tool_calls, "", finish_reason) + except Exception as e: + logger.error(f"Tool call parsing error: {e}") + finish_reason["type"] = original_finish_type + return ToolCallProcessingResult(None, text, finish_reason) + + return ToolCallProcessingResult(None, text, finish_reason) + + def _process_streaming_logprobs( + self, + content: Dict[str, Any], + n_prev_token: int, + total_output_logprobs: int, + ) -> ChoiceLogprobs: + """Process logprobs for streaming response""" + output_token_logprobs = content["meta_info"]["output_token_logprobs"] + output_top_logprobs = content["meta_info"].get("output_top_logprobs", []) + if not self.tokenizer_manager.server_args.incremental_streaming_output: + output_token_logprobs = output_token_logprobs[ + n_prev_token:total_output_logprobs + ] + output_top_logprobs = output_top_logprobs[ + n_prev_token:total_output_logprobs + ] + logprobs = to_openai_style_logprobs( + output_token_logprobs=output_token_logprobs, + output_top_logprobs=output_top_logprobs, + ) + + token_logprobs = self._process_logprobs_tokens(logprobs, use_token_index=False) + return ChoiceLogprobs(content=token_logprobs) + + def _process_reasoning_stream( + self, + index: int, + delta: str, + reasoning_parser_dict: Dict[int, ReasoningParser], + content: Dict[str, Any], + request: ChatCompletionRequest, + finish_reason_type: Optional[str] = None, + ) -> tuple[Optional[str], str]: + """Process reasoning content in streaming response""" + if index not in reasoning_parser_dict: + is_force_reasoning = ( + self.template_manager.force_reasoning + or self._get_reasoning_from_request(request) + ) + reasoning_parser_dict[index] = ReasoningParser( + self.reasoning_parser, + request.stream_reasoning, + is_force_reasoning, + request, + tokenizer=self.tokenizer_manager.tokenizer, + tool_call_parser_active=self._tool_call_parsing_active(request), + ) + reasoning_parser = reasoning_parser_dict[index] + reasoning_text, normal_text = reasoning_parser.parse_stream_chunk(delta) + if finish_reason_type is not None and finish_reason_type != "abort": + end_reasoning_text, end_normal_text = reasoning_parser.parse_stream_end() + if end_reasoning_text: + reasoning_text = (reasoning_text or "") + end_reasoning_text + if end_normal_text: + normal_text = (normal_text or "") + end_normal_text + return reasoning_text, normal_text + + def _get_history_tool_calls_cnt(self, request: ChatCompletionRequest) -> int: + """Counts the number of tool calls in the request's message history. + + NOTE: This method is only useful for models that include self-increasing + history tool call idx in tool calls id, such as kimi-k2 + + Args: + request: The chat completion request object. + + Returns: + The total number of tool calls in the history, or 0 if not applicable. + """ + messages = getattr(request, "messages", []) + idx = 0 + for msg in messages: + if msg.role == "assistant": + tool_calls = getattr(msg, "tool_calls", None) + idx += len(list(tool_calls)) if tool_calls is not None else 0 # noqa + return idx + + def _patch_reasoning_skip_special_tokens( + self, request: ChatCompletionRequest + ) -> None: + """Keep parser-specific reasoning markers in the decoded text. + + Some reasoning parsers rely on special-token delimiters that would be + removed during detokenization when ``skip_special_tokens=True``. + """ + if self.reasoning_parser == "apertus2509": + request.skip_special_tokens = False + if self.reasoning_parser == "kimi_k3" or self.chat_encoding_spec == "kimi_k3": + request.skip_special_tokens = False + + if ( + self.reasoning_parser in ["mistral"] + and request.reasoning_effort is not None + and request.reasoning_effort != "none" + ): + request.skip_special_tokens = False + elif self.reasoning_parser == "inkling": + request.skip_special_tokens = False + elif self.reasoning_parser == "muse": + request.skip_special_tokens = False + + def wrap_reasoning_history(self, reasoning_text: str) -> str: + """Wrap prior-turn reasoning in the detector's own start/end tokens. + + Pulling the delimiters from the detector keeps adapters in lockstep + with any future parser that ships non-```` markers — Mistral's + ``[THINK]``, Gemma4's ``think_start_self_label = "thought\\n"``, etc. + Falling back to a plain string is unsafe: it would let prior + thinking text reach a non-reasoning model as ordinary assistant + content, so the caller must surface this state, not paper over it. + """ + if self._reasoning_detector is None: + raise ValueError( + "Cannot rewrap thinking history: no reasoning detector is " + "configured for this model" + ) + d = self._reasoning_detector + return ( + f"{d.think_start_token}{d.think_start_self_label}" + f"{reasoning_text}\n{d.think_end_token}" + ) + + def _reasoning_default_mode(self) -> Optional[str]: + if self._reasoning_detector is None: + return None + return self._reasoning_detector.reasoning_default + + def _get_reasoning_toggle_param(self) -> Optional[str]: + """Resolve the chat-template kwarg that toggles reasoning, if any.""" + config = self.template_manager.reasoning_config + if config is not None: + return config.toggle_param + + mode = self._reasoning_default_mode() + if mode in ("thinking", "enable_thinking"): + return mode + if mode in ("explicit_thinking", "explicit_enable_thinking"): + return mode.replace("explicit_", "") + return None + + def apply_reasoning_enabled( + self, request: ChatCompletionRequest, enabled: bool + ) -> None: + """Force the request into the requested reasoning-on/off mode. + + Mirrors the read-side logic in ``_get_reasoning_from_request``; + the two must stay in sync. Always-on models cannot be disabled, + so explicit ``enabled=False`` raises rather than silently leaving + reasoning on. + """ + if not self.reasoning_parser: + if enabled: + raise ValueError( + "Anthropic thinking is not supported for models without " + "a reasoning parser" + ) + return + + if self.reasoning_parser == "hunyuan": + request.reasoning_effort = "medium" if enabled else "no_think" + return + + if self.reasoning_parser == "inkling": + # Effort-conditioned, not toggled: "none" (0.0) is the off switch. + if not enabled: + request.reasoning_effort = "none" + return + + config = self.template_manager.reasoning_config + is_mistral = (config is not None and config.special_case == "mistral") or ( + config is None and self._reasoning_default_mode() == "mistral" + ) + if is_mistral: + request.reasoning_effort = "medium" if enabled else "none" + return + + is_always_on = (config is not None and config.special_case == "always") or ( + config is None and self._reasoning_default_mode() == "always" + ) + if is_always_on: + if not enabled: + raise ValueError( + f"Reasoning parser '{self.reasoning_parser}' is always-on " + f"and cannot be disabled via Anthropic thinking" + ) + return + + toggle_param = self._get_reasoning_toggle_param() + # The read side (``_get_reasoning_from_request``) returns False + # whenever ``config.toggle_param is None`` OR + # ``config.default_enabled is None``. The write side must mirror + # both conditions: if ``default_enabled`` is unset we cannot + # actually honor an ``enabled=True`` request even when the toggle + # name itself is resolvable, so writing the kwarg would set up the + # template to emit reasoning tokens while the parser ignores them + # (literal ```` markers leak into the assistant text). + config = self.template_manager.reasoning_config + read_side_supported = toggle_param is not None and ( + config is None or config.default_enabled is not None + ) + if not read_side_supported: + if not enabled: + return + raise ValueError( + f"Anthropic thinking is not supported for reasoning parser " + f"'{self.reasoning_parser}'" + ) + + chat_template_kwargs = dict(request.chat_template_kwargs or {}) + chat_template_kwargs[toggle_param] = enabled + request.chat_template_kwargs = chat_template_kwargs + + def _get_reasoning_from_request(self, request: ChatCompletionRequest) -> bool: + """Determine whether reasoning mode should be enabled for this request. + + NOTE: This is predefined based on model's chat template + """ + if not self.reasoning_parser: + return False + + if self.reasoning_parser == "minimax-m3": + # M3 template prefills for thinking_mode=enabled, so it never + # appears in output and reasoning must be forced. Mirrors reasoning_parser.py. + return (request.chat_template_kwargs or {}).get( + "thinking_mode" + ) == "enabled" + + if self.reasoning_parser == "hunyuan": + # Hy3-preview template emits no when reasoning_effort is + # "no_think" / "none" / unset; forcing reasoning would route all + # output into reasoning_content. + return request.reasoning_effort not in (None, "none", "no_think") + + config = self.template_manager.reasoning_config + if config is None: + # Fallback to parser-level defaults when template toggle config + # cannot be inferred (e.g., parser-only templates). + mode = ( + self._reasoning_detector.reasoning_default + if self._reasoning_detector is not None + else None + ) + if mode is None: + return False + if mode == "always": + return True + if mode == "mistral": + return ( + request.reasoning_effort is not None + and request.reasoning_effort != "none" + ) + if mode in ("thinking", "enable_thinking"): + return ( + not request.chat_template_kwargs + or request.chat_template_kwargs.get(mode) is not False + ) + if mode in ("explicit_thinking", "explicit_enable_thinking"): + toggle = mode.replace("explicit_", "") + return ( + request.chat_template_kwargs is not None + and request.chat_template_kwargs.get(toggle) is True + ) + logger.warning( + "Unknown reasoning_default mode '%s', defaulting to reasoning disabled", + mode, + ) + return False + + if config.special_case == "always": + return True + + if config.special_case == "mistral": + return ( + request.reasoning_effort is not None + and request.reasoning_effort != "none" + ) + + if config.toggle_param is None or config.default_enabled is None: + return False + + if config.default_enabled: + return ( + not request.chat_template_kwargs + or request.chat_template_kwargs.get(config.toggle_param) is not False + ) + return ( + request.chat_template_kwargs is not None + and request.chat_template_kwargs.get(config.toggle_param) is True + ) + + async def _process_tool_call_stream( + self, + index: int, + delta: str, + parser_dict: Dict[int, FunctionCallParser], + content: Dict[str, Any], + request: ChatCompletionRequest, + has_tool_calls: Dict[int, bool], + continuous_usage_stats: bool = False, + flush: bool = False, + ): + """Process tool calls in streaming response. + + With flush=True (the terminal delta), the parser also drains text it + held back waiting for a marker that can no longer arrive. + """ + effective_tools = self._effective_tools(request) + if index not in parser_dict: + is_required = request.tool_choice == "required" or isinstance( + request.tool_choice, ToolChoice + ) + # For required/named tool choice: use JsonArrayParser when the + # constrained output is plain JSON (detector doesn't support + # structural_tag or no parser configured). Use FunctionCallParser + # only when the detector supports structural_tag and will produce + # native format output. + if is_required: + use_native_parser = False + if self.tool_call_parser: + probe = FunctionCallParser( + tools=effective_tools, + tool_call_parser=self.tool_call_parser, + tokenizer=self.tokenizer_manager.tokenizer, + ) + use_native_parser = ( + probe.detector.supports_structural_tag() + or probe.detector.parses_required_natively() + ) + if use_native_parser: + parser_dict[index] = probe + else: + parser_dict[index] = JsonArrayParser() + else: + parser_dict[index] = FunctionCallParser( + tools=effective_tools, + tool_call_parser=self.tool_call_parser, + tokenizer=self.tokenizer_manager.tokenizer, + ) + + parser = parser_dict[index] + + # Handle both FunctionCallParser and JsonArrayParser + if isinstance(parser, JsonArrayParser): + result = parser.parse_streaming_increment(delta, effective_tools) + normal_text, calls = result.normal_text, result.calls + else: + normal_text, calls = parser.parse_stream_chunk(delta) + if flush: + end_text, end_calls = parser.parse_stream_end() + normal_text = (normal_text or "") + end_text + calls = list(calls) + end_calls + + # Yield normal text + if normal_text: + choice_data = ChatCompletionResponseStreamChoice( + index=index, + delta=DeltaMessage(content=normal_text), + finish_reason=None, + ) + chunk = ChatCompletionStreamResponse( + id=content["meta_info"]["id"], + created=int(time.time()), + choices=[choice_data], + model=request.model, + ) + + # Add usage stats if continuous_usage_stats is enabled + if continuous_usage_stats: + prompt_tokens = self._reported_prompt_tokens(content["meta_info"]) + completion_tokens = content["meta_info"].get("completion_tokens", 0) + reasoning_tokens = content["meta_info"].get("reasoning_tokens", 0) + chunk.usage = UsageProcessor.calculate_token_usage( + prompt_tokens=prompt_tokens, + completion_tokens=completion_tokens, + reasoning_tokens=reasoning_tokens, + cached_tokens=self._continuous_usage_cached_details(content), + ) + + yield f"data: {chunk.model_dump_json()}\n\n" + + # Yield tool calls + history_tool_calls_cnt = self._get_history_tool_calls_cnt(request) + for call_item in calls: + # Mark that this choice has tool calls + has_tool_calls[index] = True + + # Tool call ID should be generated only once per tool call + if call_item.name: + # First chunk: include ID and function name + tool_call_id = self._process_tool_call_id( + call_item, history_tool_calls_cnt + ) + function_name = call_item.name + else: + # Subsequent chunks: null ID and name for argument deltas + tool_call_id = None + function_name = None + + tool_call = ToolCall( + id=tool_call_id, + index=call_item.tool_index, + function=FunctionResponse( + name=function_name, + arguments=call_item.parameters, + ), + ) + + choice_data = ChatCompletionResponseStreamChoice( + index=index, + delta=DeltaMessage(tool_calls=[tool_call]), + finish_reason=None, + ) + chunk = ChatCompletionStreamResponse( + id=content["meta_info"]["id"], + created=int(time.time()), + choices=[choice_data], + model=request.model, + ) + + # Add usage stats if continuous_usage_stats is enabled + if continuous_usage_stats: + prompt_tokens = self._reported_prompt_tokens(content["meta_info"]) + completion_tokens = content["meta_info"].get("completion_tokens", 0) + reasoning_tokens = content["meta_info"].get("reasoning_tokens", 0) + chunk.usage = UsageProcessor.calculate_token_usage( + prompt_tokens=prompt_tokens, + completion_tokens=completion_tokens, + reasoning_tokens=reasoning_tokens, + cached_tokens=self._continuous_usage_cached_details(content), + ) + + yield f"data: {chunk.model_dump_json()}\n\n" + + def _check_for_unstreamed_tool_args( + self, + parser: Union[FunctionCallParser, JsonArrayParser], + content: Dict[str, Any], + request: ChatCompletionRequest, + index: int, + ) -> Optional[str]: + """ + Check for any remaining tool call arguments that need to be streamed + when generation finishes. This ensures tool calls are properly completed + even if the model generates the final arguments in the last chunk. + """ + # Get the detector - either from FunctionCallParser or directly if json detector + detector = parser.detector if hasattr(parser, "detector") else parser + + # Only check if we have tool calls and the detector has tracked data + if ( + not hasattr(detector, "prev_tool_call_arr") + or not detector.prev_tool_call_arr + ): + return None + + if ( + not hasattr(detector, "streamed_args_for_tool") + or not detector.streamed_args_for_tool + ): + return None + + # Get the last tool call that was being processed + tool_index = len(detector.prev_tool_call_arr) - 1 + if tool_index < 0 or tool_index >= len(detector.streamed_args_for_tool): + return None + + # Get expected vs actual arguments + expected_args = detector.prev_tool_call_arr[tool_index].get("arguments", {}) + if isinstance(expected_args, str): + expected_call = expected_args + else: + expected_call = json.dumps(expected_args, ensure_ascii=False) + actual_call = detector.streamed_args_for_tool[tool_index] + + # Check if there are remaining arguments to send + remaining_call = ( + expected_call[len(actual_call) :] + if expected_call.startswith(actual_call) + else "" + ) + + if remaining_call: + # Create tool call chunk with remaining arguments + tool_call = ToolCall( + id=None, # No ID for argument deltas + index=tool_index, + function=FunctionResponse( + name=None, # No name for argument deltas + arguments=remaining_call, + ), + ) + + choice_data = ChatCompletionResponseStreamChoice( + index=index, + delta=DeltaMessage(tool_calls=[tool_call]), + finish_reason=None, # Don't send finish_reason with this chunk + ) + + chunk = ChatCompletionStreamResponse( + id=content["meta_info"]["id"], + created=int(time.time()), + choices=[choice_data], + model=request.model, + ) + + return f"data: {chunk.model_dump_json()}\n\n" + + return None diff --git a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py new file mode 100644 index 0000000..13d46cb --- /dev/null +++ b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -0,0 +1,2762 @@ +# SPDX-License-Identifier: Apache-2.0 +# Adapted from vLLM's OpenAIServingResponses +"""Handler for /v1/responses requests""" + +from __future__ import annotations + +import asyncio +import json +import logging +import time +from contextlib import AsyncExitStack +from http import HTTPStatus +from typing import TYPE_CHECKING, Any, AsyncGenerator, AsyncIterator, Optional, Union + +import jinja2 +import openai.types.responses as openai_responses_types +import orjson +from fastapi import Request +from fastapi.responses import ORJSONResponse +from openai.types.responses import ( + ResponseOutputMessage, + ResponseOutputText, + ResponseReasoningItem, +) +from openai.types.responses.response_function_tool_call import ResponseFunctionToolCall +from openai.types.responses.response_output_text import Logprob, LogprobTopLogprob +from openai.types.responses.response_reasoning_item import ( + Content as ResponseReasoningTextContent, +) +from openai.types.responses.response_reasoning_item import ( + Summary as ResponseReasoningSummary, +) +from openai.types.responses.response_reasoning_summary_part_added_event import ( + Part as ResponseReasoningSummaryAddedPart, +) +from openai.types.responses.response_reasoning_summary_part_done_event import ( + Part as ResponseReasoningSummaryDonePart, +) +from openai_harmony import Message as OpenAIMessage + +from sglang.srt.entrypoints.context import ( + ConversationContext, + HarmonyContext, + SimpleContext, + StreamingHarmonyContext, +) +from sglang.srt.entrypoints.harmony_utils import ( + get_developer_message, + get_stop_tokens_for_assistant_actions, + get_system_message, + get_user_message, + parse_output_message, + parse_remaining_state, + parse_response_input, + render_for_completion, +) +from sglang.srt.entrypoints.openai.protocol import ( + ChatCompletionMessageParam, + ChatCompletionRequest, + Function, + MessageProcessingResult, + PromptTokenUsageInfo, + RequestResponseMetadata, + ResponsesRequest, + ResponsesResponse, + Tool, + UsageInfo, +) +from sglang.srt.entrypoints.openai.serving_chat import OpenAIServingChat +from sglang.srt.entrypoints.openai.responses_compat import ( + ToolRegistry, + qualified_name, + validated_json_calls, +) +from sglang.srt.entrypoints.openai.tool_server import MCPToolServer, ToolServer +from sglang.srt.entrypoints.openai.utils import to_openai_style_logprobs +from sglang.srt.function_call.function_call_parser import FunctionCallParser +from sglang.srt.function_call.core_types import ToolCallItem +from sglang.srt.function_call.json_array_parser import JsonArrayParser +from sglang.srt.managers.io_struct import GenerateReqInput +from sglang.srt.parser.reasoning_parser import ReasoningParser +from sglang.srt.utils import random_uuid + +if TYPE_CHECKING: + from sglang.srt.managers.tokenizer_manager import TokenizerManager + from sglang.srt.parser.template_manager import TemplateManager + +logger = logging.getLogger(__name__) + + +class _MediaInputValidationError(ValueError): + pass + + +def _build_output_text_logprobs(meta_info: dict) -> list[Logprob]: + """Reshape decoded ``meta_info`` logprobs into the Responses logprob type, + covering every generated token.""" + decoded = to_openai_style_logprobs( + output_token_logprobs=meta_info.get("output_token_logprobs"), + output_top_logprobs=meta_info.get("output_top_logprobs"), + ) + top_lists = decoded.top_logprobs or [] + logprobs: list[Logprob] = [] + for index, (token, logprob) in enumerate( + zip(decoded.tokens, decoded.token_logprobs) + ): + top_entry = top_lists[index] if index < len(top_lists) else None + top_logprobs = [ + LogprobTopLogprob( + token=top_token, + logprob=top_logprob, + bytes=list(top_token.encode("utf-8")), + ) + for top_token, top_logprob in (top_entry or {}).items() + ] + logprobs.append( + Logprob( + token=token, + logprob=logprob, + bytes=list(token.encode("utf-8")), + top_logprobs=top_logprobs, + ) + ) + return logprobs + + +def _should_emit_normal_text_as_message( + text: str, *, any_tool_call_in_progress: bool +) -> bool: + """Whether ``text`` should open / extend a user-visible message item. + + qwen3-coder separates adjacent tool-call blocks with ``\\n``, which the + streaming detector cannot tell from real content -- so whitespace arriving + while a call is open is treated as a separator. + """ + if not text: + return False + if any_tool_call_in_progress and not text.strip(): + return False + return True + + +class OpenAIServingResponses(OpenAIServingChat): + """Handler for /v1/responses requests""" + + def __init__( + self, + tokenizer_manager: TokenizerManager, + template_manager: TemplateManager, + *, + enable_prompt_tokens_details: bool = False, + tool_server: Optional[ToolServer] = None, + ) -> None: + super().__init__(tokenizer_manager, template_manager) + + # template_manager is already set by parent class; reasoning_parser comes + # from the parent, which reads the manager's control-plane overlay. + self.enable_prompt_tokens_details = enable_prompt_tokens_details + + # Parent OpenAIServingChat.__init__ already populated default_sampling_params. + if not isinstance(self.default_sampling_params, dict): + self.default_sampling_params = {} + + self.supports_browsing = ( + tool_server.has_tool("browser") if tool_server else False + ) + self.supports_code_interpreter = ( + tool_server.has_tool("python") if tool_server else False + ) + self.tool_server = tool_server + # Get from model config + self.use_harmony = ( + self.tokenizer_manager.model_config.hf_config.model_type == "gpt_oss" + ) + + if self.use_harmony: + # OpenAI models have two EOS-like tokens: <|return|> and <|call|>. + # We need to add them to the stop token ids. + if "stop_token_ids" not in self.default_sampling_params: + self.default_sampling_params["stop_token_ids"] = [] + self.default_sampling_params["stop_token_ids"].extend( + get_stop_tokens_for_assistant_actions() + ) + + # Response storage for background and retrieval operations + # Note: In production, this should use a proper storage backend (Redis, database) + # with TTL/expiration to prevent memory leaks + self.response_store: dict[str, ResponsesResponse] = {} + self._compat_registries: dict[str, ToolRegistry] = {} + self.response_store_lock = asyncio.Lock() + + # Message storage for conversation continuity + # Note: In production, this should use a proper storage backend (Redis, database) + # with TTL/expiration to prevent memory leaks + self.msg_store: dict[ + str, Union[list[ChatCompletionMessageParam], list[OpenAIMessage]] + ] = {} + + self.background_tasks: dict[str, asyncio.Task] = {} + + @staticmethod + def _has_response_tool(request: ResponsesRequest, *tool_types: str) -> bool: + return any(tool.type in tool_types for tool in (request.tools or [])) + + # error helpers dedicated for v1/responses + def create_error_response( + self, + message: str, + err_type: str = "invalid_request_error", + status_code: int = 400, + param: Optional[str] = None, + ) -> ORJSONResponse: + nested_error = { + "message": message, + "type": err_type, + "param": param, + "code": status_code, + } + return ORJSONResponse(content={"error": nested_error}, status_code=status_code) + + def create_streaming_error_response( + self, + message: str, + err_type: str = "BadRequestError", + status_code: int = 400, + ) -> str: + return json.dumps( + { + "error": { + "message": message, + "type": err_type, + "param": None, + "code": status_code, + } + } + ) + + def _request_id_prefix(self) -> str: + return "resp_" + + async def create_responses( + self, + request: ResponsesRequest, + raw_request: Optional[Request] = None, + ) -> Union[AsyncGenerator[str, None], ResponsesResponse, ORJSONResponse]: + try: + if request.background and not request.store: + raise ValueError("Background responses require store=true") + registry = ToolRegistry(request.tools, reasoning=request.reasoning, tool_choice=request.tool_choice) + if request.previous_response_id is not None: + async with self.response_store_lock: + previous = self.response_store.get(request.previous_response_id) + previous_registry = self._compat_registries.get(request.previous_response_id) + if previous is not None and previous_registry is not None: + registry.inherit_history(previous_registry, previous.output) + internal = request.model_dump(by_alias=True) + internal["tools"] = registry.functions + registry.builtins + internal["tool_choice"] = registry.choice(request.tool_choice) + if isinstance(request.input, list): + internal["input"] = [registry.replay(item) for item in request.input] + internal_request = ResponsesRequest.model_validate(internal) + internal_request._compat_registry = registry + internal_request._custom_tool_names = frozenset( + name for name, identity in registry.identities.items() if identity[2] == "custom" + ) + result = await self._create_responses_internal(internal_request, raw_request) + if isinstance(result, ORJSONResponse): + return result + if isinstance(result, ResponsesResponse): + return registry.response_model(result) + return registry.stream(result) + except ValueError as error: + return self.create_error_response(str(error)) + + async def _managed_response_stream(self, source, generation, request): + completed = False + try: + async for frame in source: + if "event: response.completed\n" in frame: + completed = True + yield frame + finally: + try: + await source.aclose() + finally: + try: + await generation.aclose() + finally: + if not completed: + self.tokenizer_manager.abort_request(rid=request.request_id) + + def _store_compat_metadata(self, request, response_id): + if request._compat_registry is not None: + self._compat_registries[response_id] = request._compat_registry + self.msg_store[response_id] = request._compat_registry.messages + + async def _create_responses_internal( + self, + request: ResponsesRequest, + raw_request: Optional[Request] = None, + ) -> Union[AsyncGenerator[str, None], ResponsesResponse, ORJSONResponse]: + # Validate model + if not self.tokenizer_manager: + return self.create_error_response("Model not loaded") + + # FIXME: If the engine is dead, raise an error + # This is required for the streaming case + + # ``tool_choice="required"`` only works with ``function`` tools. + if request.tool_choice == "required" and not any( + tool.type == "function" for tool in (request.tools or []) + ): + return self.create_error_response( + 'tool_choice="required" requires at least one tool with ' + 'type="function"; other built-in tool types cannot be forced.' + ) + + # harmony emits raw tokens; per-token logprobs aren't wired there. + if self.use_harmony and request.is_include_output_logprobs(): + return self.create_error_response( + "logprobs are not supported with gpt-oss models", param="logprobs" + ) + # streaming skips the logprobs build path; reject so the include doesn't silently no-op. + if request.stream and request.is_include_output_logprobs(): + return self.create_error_response( + "logprobs are not supported in streaming mode", param="logprobs" + ) + # harmony output opens with <|channel|>analysis<|message|>, so a whole-output + # json_schema forces "{" at the first token and the harmony parse then fails. + if self.use_harmony and request.has_json_schema_constraint(): + return self.create_error_response( + "structured output (text.format) is not supported with gpt-oss models", + param="text", + ) + if ( + self.use_harmony + and self._has_response_tool(request, "web_search", "web_search_preview") + and not self.supports_browsing + ): + return self.create_error_response( + "web_search requires a browser backend. Set EXA_API_KEY on the " + "SGLang server to enable native Exa-backed web search, or " + "configure a browser MCP tool server. Create an Exa API key at " + "https://dashboard.exa.ai/api-keys." + ) + + # Handle the previous response ID + prev_response_id = request.previous_response_id + if prev_response_id is not None: + if not prev_response_id.startswith("resp_"): + return self._make_invalid_id_error(prev_response_id) + async with self.response_store_lock: + prev_response = self.response_store.get(prev_response_id) + if prev_response is None: + return self._make_not_found_error(prev_response_id) + else: + prev_response = None + + try: + model_name = request.model + tokenizer = self.tokenizer_manager.tokenizer + processed_messages: Optional[MessageProcessingResult] = None + + if self.use_harmony: + messages, request_prompts, engine_prompts = ( + self._make_request_with_harmony(request, prev_response) + ) + require_reasoning = self._is_thinking_enabled_for_request(request) + else: + ( + messages, + request_prompts, + engine_prompts, + processed_messages, + ) = await self._make_request(request, prev_response, tokenizer) + require_reasoning = processed_messages.require_reasoning + + except _MediaInputValidationError as e: + return self.create_error_response(str(e)) + except (ValueError, TypeError, RuntimeError, jinja2.TemplateError) as e: + logger.exception("Error in preprocessing prompt inputs") + return self.create_error_response(f"{e} {e.__cause__}") + + request_metadata = RequestResponseMetadata(request_id=request.request_id) + if raw_request: + raw_request.state.request_metadata = request_metadata + + if ( + self.tool_server is not None + and isinstance(self.tool_server, MCPToolServer) + and (request.background or request.stream) + and request.tools + and any( + tool.type in ("web_search", "web_search_preview", "code_interpreter") + for tool in request.tools + ) + ): + return self.create_error_response( + "MCP tool server is not supported in background mode and " + "streaming mode" + ) + + # Schedule the request and get the result generator + generators: list[AsyncGenerator[Any, None]] = [] + tool_list = [] + if self.use_harmony: + if self.supports_browsing: + tool_list.append("browser") + if self.supports_code_interpreter: + tool_list.append("python") + async with AsyncExitStack() as exit_stack: + try: + if self.tool_server is not None: + tool_session_ctxs: dict[str, Any] = { + tool_name: exit_stack.enter_async_context( + self.tool_server.get_tool_session(tool_name) + ) + for tool_name in tool_list + } + tool_sessions = {} + for tool_name in tool_list: + tool_sessions[tool_name] = await tool_session_ctxs[tool_name] + else: + assert len(tool_list) == 0 + tool_sessions = {} + for i, engine_prompt in enumerate(engine_prompts): + # Calculate default max tokens from context length minus prompt length + if isinstance(engine_prompt, list): + prompt_length = len(engine_prompt) + elif isinstance(engine_prompt, str): + prompt_length = len(tokenizer.encode(engine_prompt)) + else: + prompt_length = 0 + + context_len = ( + self.tokenizer_manager.model_config.context_len + if hasattr(self.tokenizer_manager.model_config, "context_len") + else 4096 + ) + # Account for reserved tokens (e.g., EAGLE speculative decoding slots) + # that the tokenizer_manager adds during validation + num_reserved_tokens = self.tokenizer_manager.num_reserved_tokens + default_max_tokens = max( + context_len - prompt_length - num_reserved_tokens, 512 + ) # Ensure minimum 512 tokens + sampling_params = request.to_sampling_params( + default_max_tokens, + self.default_sampling_params, + stop=( + processed_messages.stop + if processed_messages + else request.stop + ), + tool_call_constraint=( + processed_messages.tool_call_constraint + if processed_messages + else None + ), + ) + # _process_messages set skip_special_tokens on a chat_request + # we then discard, so re-apply it to the engine sampling dict. + if processed_messages is not None and ( + not processed_messages.skip_special_tokens + ): + sampling_params["skip_special_tokens"] = False + + context: ConversationContext + if self.use_harmony: + if request.stream: + context = StreamingHarmonyContext(messages, tool_sessions) + else: + context = HarmonyContext(messages, tool_sessions) + else: + context = SimpleContext() + + # Create GenerateReqInput for SGLang + if isinstance(engine_prompt, str): + prompt_kwargs = {"text": engine_prompt} + else: + prompt_kwargs = {"input_ids": engine_prompt} + + logprob_kwargs = ( + { + "return_logprob": True, + "logprob_start_len": -1, + "top_logprobs_num": request.top_logprobs or 0, + "return_text_in_logprobs": True, + } + if request.is_include_output_logprobs() + else {} + ) + + adapted_request = GenerateReqInput( + **prompt_kwargs, + **logprob_kwargs, + image_data=( + processed_messages.image_data + if processed_messages + else None + ), + video_data=( + processed_messages.video_data + if processed_messages + else None + ), + audio_data=( + processed_messages.audio_data + if processed_messages + else None + ), + modalities=( + processed_messages.modalities + if processed_messages + else None + ), + sampling_params=sampling_params, + stream=request.stream, + rid=request.request_id, + session_id=request.session_id, + extra_key=request.extra_key, + cache_salt=request.cache_salt, + # background+stream streams on this connection, so don't detach. + background=request.background and not request.stream, + require_reasoning=require_reasoning, + ) + + generator = self._generate_with_builtin_tools( + request.request_id, + request_prompts[i], + adapted_request, + sampling_params, + context, + raw_request=raw_request, + priority=request.priority, + ) + generators.append(generator) + except ValueError as e: + return self.create_error_response(str(e)) + + assert len(generators) == 1 + (result_generator,) = generators + + # Store the input messages + if request.store: + if request._compat_registry is not None: + request._compat_registry.messages = messages + else: + self.msg_store[request.request_id] = messages + + if request.background and not request.stream: + created_time = int(time.time()) + response = ResponsesResponse.from_request( + request, + sampling_params, + model_name=model_name, + created_time=created_time, + output=[], + status="queued", + usage=None, + ) + async with self.response_store_lock: + self.response_store[response.id] = response + self._store_compat_metadata(request, response.id) + + # Run the request in the background + task = asyncio.create_task( + self._run_background_request( + request, + sampling_params, + result_generator, + context, + model_name, + tokenizer, + request_metadata, + created_time, + require_reasoning=require_reasoning, + ), + name=f"create_{response.id}", + ) + + # For cleanup + self.background_tasks[response.id] = task + task.add_done_callback( + lambda _: self.background_tasks.pop(response.id, None) + ) + return response + + if request.stream: + if self.use_harmony: + source = self.responses_stream_generator( + request, + sampling_params, + result_generator, + context, + model_name, + tokenizer, + request_metadata, + require_reasoning=require_reasoning, + ) + else: + source = self.responses_stream_generator_non_harmony( + request, + sampling_params, + result_generator, + model_name, + tokenizer, + request_metadata, + require_reasoning=require_reasoning, + ) + return self._managed_response_stream(source, result_generator, request) + try: + result: Union[ORJSONResponse, ResponsesResponse] = ( + await self.responses_full_generator( + request, + sampling_params, + result_generator, + context, + model_name, + tokenizer, + request_metadata, + require_reasoning=require_reasoning, + ) + ) + return result + except Exception as e: + return self.create_error_response(str(e)) + return self.create_error_response("Unknown error") + + async def _make_request( + self, + request: ResponsesRequest, + prev_response: Optional[ResponsesResponse], + tokenizer: Any, + ): + messages = self._construct_input_messages(request, prev_response) + + chat_tools = self._response_tools_to_chat_tools(request) + chat_request = ChatCompletionRequest( + model=request.model, + messages=messages, + stream=request.stream, + tools=chat_tools or None, + tool_choice=( + self._chat_tool_choice(request.effective_tool_choice()) + if chat_tools + else "none" + ), + parallel_tool_calls=( + request.parallel_tool_calls + if request.parallel_tool_calls is not None + else True + ), + stop=request.stop, + reasoning_effort=(request.reasoning.effort if request.reasoning else None), + chat_template_kwargs=request.chat_template_kwargs, + ) + + media_error = self._validate_media_content(chat_request) + if media_error: + raise _MediaInputValidationError(media_error) + + is_multimodal = self.tokenizer_manager.model_config.is_multimodal + processed_messages = self._process_messages(chat_request, is_multimodal) + + if is_multimodal: + request_prompts = [processed_messages.prompt] + engine_prompts = [processed_messages.prompt] + else: + request_prompts = [processed_messages.prompt_ids] + engine_prompts = [processed_messages.prompt_ids] + + return messages, request_prompts, engine_prompts, processed_messages + + def _make_request_with_harmony( + self, + request: ResponsesRequest, + prev_response: Optional[ResponsesResponse], + ): + if request.tool_choice != "auto": + raise NotImplementedError( + "Only 'auto' tool_choice is supported in " "response API" + ) + messages = self._construct_input_messages_with_harmony(request, prev_response) + prompt_token_ids = render_for_completion(messages) + engine_prompt = prompt_token_ids + return messages, [prompt_token_ids], [engine_prompt] + + async def responses_full_generator( + self, + request: ResponsesRequest, + sampling_params: Any, + result_generator: AsyncIterator[Any], + context: ConversationContext, + model_name: str, + tokenizer: Any, + request_metadata: RequestResponseMetadata, + created_time: Optional[int] = None, + *, + require_reasoning: bool, + ) -> Union[ResponsesResponse, ORJSONResponse]: + if created_time is None: + created_time = int(time.time()) + + try: + async for _ in result_generator: + pass + except asyncio.CancelledError: + return self.create_error_response("Client disconnected") + except ValueError as e: + return self.create_error_response(str(e)) + + status = "completed" + finish_reason = None + if self.use_harmony: + assert isinstance(context, HarmonyContext) + output = self._make_response_output_items_with_harmony(context) + # num_reasoning_tokens isn't wired through HarmonyContext yet; stays 0. + num_prompt_tokens = context.num_prompt_tokens + num_generated_tokens = context.num_output_tokens + num_cached_tokens = context.num_cached_tokens + num_reasoning_tokens = context.num_reasoning_tokens + finish_reason = context.finish_reason + status = self._status_from_finish_reason(finish_reason) + else: + assert isinstance(context, SimpleContext) + final_res = context.last_output + assert final_res is not None + + num_reasoning_tokens = 0 + meta_info = None + if isinstance(final_res, dict) and isinstance( + final_res.get("meta_info"), dict + ): + meta_info = final_res["meta_info"] + elif hasattr(final_res, "meta_info"): + meta_info = final_res.meta_info + + finish_reason = ( + meta_info.get("finish_reason") if meta_info is not None else None + ) + status = self._status_from_finish_reason(finish_reason) + + output_logprobs = ( + _build_output_text_logprobs(meta_info) + if request.is_include_output_logprobs() and isinstance(meta_info, dict) + else None + ) + output = self._make_response_output_items( + request, + final_res["text"], + tokenizer, + output_logprobs=output_logprobs, + require_reasoning=require_reasoning, + status=status, + ) + + if meta_info is not None: + num_prompt_tokens = meta_info.get("prompt_tokens", 0) + num_generated_tokens = meta_info.get("completion_tokens", 0) + num_cached_tokens = meta_info.get("cached_tokens", 0) + num_reasoning_tokens = meta_info.get("reasoning_tokens", 0) + finish_reason = meta_info.get("finish_reason") + status = self._status_from_finish_reason(finish_reason) + elif isinstance(final_res, dict) and ( + final_res.get("prompt_token_ids") is not None + or final_res.get("output_ids") is not None + ): + prompt_token_ids = final_res.get("prompt_token_ids") or [] + output_token_ids = final_res.get("output_ids") or [] + num_prompt_tokens = len(prompt_token_ids) + num_generated_tokens = len(output_token_ids) + num_cached_tokens = final_res.get("num_cached_tokens", 0) + elif hasattr(final_res, "prompt_token_ids") and hasattr( + final_res, "outputs" + ): + # Fallback calculation if meta_info not available + num_prompt_tokens = ( + len(final_res.prompt_token_ids) if final_res.prompt_token_ids else 0 + ) + num_generated_tokens = ( + len(final_res.outputs[0].token_ids) + if final_res.outputs and final_res.outputs[0].token_ids + else 0 + ) + num_cached_tokens = getattr(final_res, "num_cached_tokens", 0) + else: + # Final fallback + num_prompt_tokens = 0 + num_generated_tokens = 0 + num_cached_tokens = 0 + num_reasoning_tokens = 0 + + if request._compat_registry is not None: + request._compat_registry.validate_completion(output, status) + for item in output: + request._compat_registry.output_item(item) + + usage = UsageInfo( + prompt_tokens=num_prompt_tokens, + completion_tokens=num_generated_tokens, + total_tokens=num_prompt_tokens + num_generated_tokens, + reasoning_tokens=num_reasoning_tokens, + ) + if self.enable_prompt_tokens_details and num_cached_tokens: + usage.prompt_tokens_details = PromptTokenUsageInfo( + cached_tokens=num_cached_tokens + ) + request_metadata.final_usage_info = usage + + response = ResponsesResponse.from_request( + request, + sampling_params, + model_name=model_name, + created_time=created_time, + output=output, + status=status, + usage=usage, + ) + response.error = self._error_from_finish_reason(finish_reason) + + if request.store: + async with self.response_store_lock: + stored_response = self.response_store.get(response.id) + # If the response is already cancelled, don't update it + if stored_response is None or stored_response.status != "cancelled": + self.response_store[response.id] = response + self._store_compat_metadata(request, response.id) + + return response + + @staticmethod + def _wants_reasoning_summary(request: ResponsesRequest) -> bool: + return request.reasoning is not None and request.reasoning.summary is not None + + @staticmethod + def _status_from_finish_reason(finish_reason: Any) -> str: + """Distinguish length caps and engine aborts from successful stops.""" + reason = None + if isinstance(finish_reason, dict): + reason = finish_reason.get("type") + elif isinstance(finish_reason, str): + reason = finish_reason + if reason == "length": + return "incomplete" + if reason == "error": + return "failed" + if reason == "abort": + if ( + isinstance(finish_reason, dict) + and finish_reason.get("status_code") is not None + ): + return "failed" + return "cancelled" + return "completed" + + @classmethod + def _error_from_finish_reason(cls, finish_reason: Any) -> Optional[dict]: + if cls._status_from_finish_reason(finish_reason) != "failed": + return None + message = ( + finish_reason.get("message") if isinstance(finish_reason, dict) else None + ) + return {"code": "server_error", "message": message or "Generation aborted"} + + def _is_thinking_enabled_for_request(self, request: ResponsesRequest) -> bool: + if not self.reasoning_parser: + return False + # an explicit toggle wins; the key differs by family (enable_thinking vs thinking). + ctk = request.chat_template_kwargs or {} + thinking_toggles = (ctk.get("enable_thinking"), ctk.get("thinking")) + if any(toggle is False for toggle in thinking_toggles): + return False + if any(toggle is True for toggle in thinking_toggles): + return True + effort = request.reasoning.effort if request.reasoning is not None else None + if self.reasoning_parser == "hunyuan": + return effort not in (None, "none", "no_think") + if self.template_manager.force_reasoning: + return True + config = self.template_manager.reasoning_config + if config is None: + # Parser-only models (DeepSeek-R1, …) carry the thinking default in + # the detector itself. + detector = getattr(self, "_reasoning_detector", None) + mode = getattr(detector, "reasoning_default", None) if detector else None + if mode is None or mode == "always": + return mode == "always" + if mode == "mistral": + return effort is not None and effort != "none" + if mode in ("thinking", "enable_thinking"): + return effort != "none" + if mode in ("explicit_thinking", "explicit_enable_thinking"): + return False + return False + if config.special_case == "always": + return True + if config.special_case == "mistral": + return effort is not None and effort != "none" + if config.toggle_param is None or config.default_enabled is None: + return False + if effort == "none": + return False + return bool(config.default_enabled) + + def _make_response_output_items( + self, + request: ResponsesRequest, + final_output: Any, + tokenizer: Any, + output_logprobs: Optional[list] = None, + *, + require_reasoning: bool, + status: str = "completed", + ): + chat_tools = self._response_tools_to_chat_tools(request) + if self.reasoning_parser: + reasoning_parser = ReasoningParser( + model_type=self.reasoning_parser, + stream_reasoning=False, + # A template that prefills forces the parser open even + # when the request itself did not ask for reasoning, same as chat. + force_reasoning=( + self.template_manager.force_reasoning or require_reasoning + ), + request=request, + tokenizer=self.tokenizer_manager.tokenizer, + tool_call_parser_active=bool( + chat_tools + and self.tool_call_parser + and request.tool_choice != "none" + ), + ) + reasoning_content, content = reasoning_parser.parse_non_stream(final_output) + else: + reasoning_content = None + content = final_output + + output_items = [] + if reasoning_content: + # Mirror the single parsed blob into ``summary`` when the caller opts + # in via ``reasoning.summary``; full trace stays in ``content``. + wants_summary = self._wants_reasoning_summary(request) + reasoning_item = ResponseReasoningItem( + id=f"rs_{random_uuid()}", + type="reasoning", + summary=( + [ + ResponseReasoningSummary( + type="summary_text", text=reasoning_content + ) + ] + if wants_summary + else [] + ), + content=[ + ResponseReasoningTextContent( + type="reasoning_text", text=reasoning_content + ), + ], + status=None, + ) + output_items.append(reasoning_item) + + is_required = request.tool_choice == "required" or isinstance(request.tool_choice, dict) + if status != "completed" and chat_tools and is_required: + return output_items + tool_call_items: list[ResponseFunctionToolCall] = [] + parsed_via_native = False + if ( + content + and chat_tools + and self.tool_call_parser + and request.tool_choice != "none" + ): + parser = FunctionCallParser( + chat_tools, + self.tool_call_parser, + tokenizer=self.tokenizer_manager.tokenizer, + ) + if hasattr(parser.detector, "preserve_raw_input_tools"): + parser.detector.preserve_raw_input_tools = request._custom_tool_names + should_try_native = ( + not is_required or parser.detector.supports_structural_tag() + ) + if should_try_native and parser.has_tool_call(content): + if status != "completed": + return output_items + try: + content, call_info_list = parser.parse_non_stream(content) + for call_info in call_info_list: + tool_call_items.append( + ResponseFunctionToolCall( + arguments=call_info.parameters or "", + call_id=f"call_{random_uuid()[:24]}", + type="function_call", + name=call_info.name, + id=f"fc_{random_uuid()[:8]}", + status="completed", + ) + ) + parsed_via_native = bool(call_info_list) + except Exception as e: + logger.error("Tool call parsing error: %s", e) + + if content and chat_tools and is_required and not parsed_via_native: + for name, arguments in validated_json_calls( + content, {tool.function.name for tool in chat_tools} + ): + tool_call_items.append( + ResponseFunctionToolCall( + arguments=arguments, + call_id=f"call_{random_uuid()[:24]}", + type="function_call", + name=name, + id=f"fc_{random_uuid()[:8]}", + status="completed", + ) + ) + content = "" + + if content: + output_text = ResponseOutputText( + text=content, + annotations=[], # TODO + type="output_text", + # logprobs cover all generated tokens, not just the stripped content. + logprobs=output_logprobs, + ) + message = ResponseOutputMessage( + id=f"msg_{random_uuid()}", + content=[output_text], + role="assistant", + status="completed", + type="message", + ) + output_items.append(message) + output_items.extend(tool_call_items) + return output_items + + def _make_response_output_items_with_harmony( + self, + context: HarmonyContext, + ): + output_items = [] + num_init_messages = context.num_init_messages + for msg in context.messages[num_init_messages:]: + output_items.extend(parse_output_message(msg)) + # Handle the generation stopped in the middle (if any). + last_items = parse_remaining_state(context.parser) + if last_items: + output_items.extend(last_items) + return output_items + + @staticmethod + def _chat_tool_choice(tool_choice: Any) -> Any: + """Nest an ``effective_tool_choice()`` result the way chat expects: + ``{"type":"function","name":X}`` -> ``{...,"function":{"name":X}}``.""" + if not isinstance(tool_choice, dict): + return tool_choice + return {"type": "function", "function": {"name": tool_choice["name"]}} + + @staticmethod + def _response_tools_to_chat_tools(request: ResponsesRequest) -> list[Tool]: + # Only ``function`` tools flow to chat; built-ins go through harmony. + chat_tools = [] + for tool in ToolRegistry(request.tools).functions: + chat_tools.append( + Tool( + type="function", + function=Function( + name=tool["name"], + description=tool.get("description"), + parameters=tool.get("parameters"), + strict=tool.get("strict") or False, + ), + ) + ) + return chat_tools + + @staticmethod + def _normalize_response_content_part_for_chat(content_part: Any) -> Any: + # Default detail=\"auto\" and lift flat min/max_dynamic_patch onto + # image_url so the image preprocessor sees them. + if hasattr(content_part, "model_dump"): + content_part = content_part.model_dump(exclude_none=True) + if not isinstance(content_part, dict): + return content_part + + part_type = content_part.get("type") + if part_type in ("input_text", "output_text"): + return {"type": "text", "text": content_part.get("text", "")} + + if part_type == "input_image": + image_url = content_part.get("image_url") + if isinstance(image_url, dict): + image_url_obj = image_url.copy() + else: + image_url_obj = {"url": image_url} + if not image_url_obj.get("detail"): + image_url_obj["detail"] = content_part.get("detail") or "auto" + for key in ("min_dynamic_patch", "max_dynamic_patch"): + if key in content_part and key not in image_url_obj: + image_url_obj[key] = content_part[key] + return {"type": "image_url", "image_url": image_url_obj} + + if part_type == "text": + return content_part + + if part_type == "image_url": + image_url = content_part.get("image_url") + if isinstance(image_url, str): + image_url = { + "url": image_url, + "detail": content_part.get("detail", "auto"), + } + elif isinstance(image_url, dict): + image_url = image_url.copy() + if not image_url.get("detail"): + image_url["detail"] = content_part.get("detail") or "auto" + return {**content_part, "image_url": image_url} + + return content_part + + @classmethod + def _normalize_response_message_for_chat(cls, message: Any) -> Any: + """Convert one Responses-API input item to a chat-completions message.""" + if hasattr(message, "model_dump"): + message = message.model_dump(exclude_none=True) + if not isinstance(message, dict): + return message + + # Most chat templates only recognize system/user/assistant/tool; + # collapse ``developer`` to ``system`` at the boundary. + if message.get("role") == "developer": + message = {**message, "role": "system"} + + msg_type = message.get("type") + if msg_type in ("function_call", "custom_tool_call"): + # Coerce ``arguments`` to a valid JSON-object string so the chat + # template's unconditional ``orjson.loads`` survives truncated or + # dict-shaped echoes. + raw = message.get("arguments") + if msg_type == "custom_tool_call": + if not isinstance(message.get("input"), str): + raise ValueError("Custom tool input must be a string") + raw = json.dumps({"input": message["input"]}, ensure_ascii=False) + if isinstance(raw, str): + try: + parsed = orjson.loads(raw) if raw else None + except orjson.JSONDecodeError: + parsed = None + if not isinstance(parsed, dict): + raw = "{}" + elif isinstance(raw, dict): + raw = orjson.dumps(raw).decode("utf-8") + else: + raw = "{}" + return { + "role": "assistant", + "tool_calls": [ + { + "id": message.get("call_id") or message.get("id"), + "type": "function", + "function": { + "name": qualified_name(message.get("name"), message.get("namespace")), + "arguments": raw, + }, + } + ], + } + if msg_type in ("function_call_output", "custom_tool_call_output"): + # ``output`` may be a string or an array of content parts (OpenAI + # allows both); the chat tool message needs a string, so flatten. + out = message.get("output", "") + if isinstance(out, list): + out = [cls._normalize_response_content_part_for_chat(part) for part in out] + return { + "role": "tool", + "tool_call_id": message.get("call_id"), + "content": out, + } + # Reasoning items render as {role: assistant, reasoning_content}; + # empty ones drop instead of injecting an empty assistant block. + if msg_type == "reasoning": + # Prefer ``summary``; fall back to ``content`` only when summary + # is empty, since clients often populate both with the same text. + def _collect(parts): + out: list[str] = [] + for entry in parts or []: + if isinstance(entry, dict): + text = entry.get("text") + if text: + out.append(text) + return out + + text_parts = _collect(message.get("summary")) + if not text_parts: + text_parts = _collect(message.get("content")) + if not text_parts: + return None + return { + "role": "assistant", + "reasoning_content": "\n".join(text_parts), + } + if msg_type not in (None, "message"): + raise ValueError(f"Unsupported Responses API input item type: {msg_type!r}") + + content = message.get("content") + if not isinstance(content, list): + return { + k: v + for k, v in message.items() + if v is not None and k not in ("id", "status", "type") + } + + return { + k: v + for k, v in { + **message, + "content": [ + cls._normalize_response_content_part_for_chat(part) + for part in content + ], + }.items() + if v is not None and k not in ("id", "status", "type") + } + + @staticmethod + def _output_message_text(output_item: Any) -> Optional[str]: + """Return assistant text from a ``message`` output item (joining + ``output_text`` parts with newlines), or None for non-message items.""" + if isinstance(output_item, ResponseReasoningItem): + return None + if hasattr(output_item, "model_dump"): + output_item = output_item.model_dump(exclude_none=True) + if not isinstance(output_item, dict): + return None + if output_item.get("type") != "message": + return None + + text_parts = [] + for content in output_item.get("content") or []: + if isinstance(content, ResponseOutputText): + text_parts.append(content.text) + continue + if hasattr(content, "model_dump"): + content = content.model_dump(exclude_none=True) + if isinstance(content, dict) and content.get("type") == "output_text": + text = content.get("text") + if text is not None: + text_parts.append(text) + + return "\n".join(text_parts) if text_parts else None + + @staticmethod + def _merge_consecutive_assistant_messages( + messages: list, + ) -> list: + """Collapse runs of consecutive ``assistant`` dicts into one entry, + joining ``content`` and concatenating ``tool_calls`` and + ``reasoning_content`` so a logical turn renders as a single block.""" + merged: list = [] + for msg in messages: + if ( + isinstance(msg, dict) + and msg.get("role") == "assistant" + and merged + and isinstance(merged[-1], dict) + and merged[-1].get("role") == "assistant" + ): + prev = merged[-1] = dict(merged[-1]) + # Lift mixed str/list content to list parts so non-text parts + # (e.g. image_url) survive when the two sides differ in shape. + new_content = msg.get("content") + if new_content is not None and new_content != "": + prev_content = prev.get("content") + if prev_content is None or prev_content == "": + prev["content"] = new_content + elif isinstance(prev_content, str) and isinstance(new_content, str): + sep = "\n\n" if prev_content and new_content else "" + prev["content"] = prev_content + sep + new_content + else: + + def _as_parts(c): + if isinstance(c, list): + return list(c) + if isinstance(c, str) and c: + return [{"type": "text", "text": c}] + return [] + + prev["content"] = _as_parts(prev_content) + _as_parts( + new_content + ) + new_calls = msg.get("tool_calls") + if new_calls: + prev_calls = prev.get("tool_calls") or [] + prev["tool_calls"] = prev_calls + list(new_calls) + new_reasoning = msg.get("reasoning_content") + if new_reasoning: + prev_reasoning = prev.get("reasoning_content") + prev["reasoning_content"] = ( + f"{prev_reasoning}\n{new_reasoning}" + if prev_reasoning + else new_reasoning + ) + continue + merged.append(msg) + return merged + + def _construct_input_messages( + self, + request: ResponsesRequest, + prev_response: Optional[ResponsesResponse] = None, + ) -> list[ChatCompletionMessageParam]: + messages: list[ChatCompletionMessageParam] = [] + if request.instructions: + messages.append( + { + "role": "system", + "content": request.instructions, + } + ) + + # Prepend the conversation history + if prev_response is not None: + # Add the previous messages + prev_msg = self.msg_store[prev_response.id] + messages.extend(prev_msg) + + for output_item in prev_response.output: + if isinstance(output_item, ResponseFunctionToolCall): + messages.append(self._normalize_response_message_for_chat(output_item)) + continue + assistant_text = self._output_message_text(output_item) + if assistant_text is None: + continue + messages.append({"role": "assistant", "content": assistant_text}) + + # Append the new input + # Responses API supports simple text inputs without chat format + if isinstance(request.input, str): + messages.append({"role": "user", "content": request.input}) + else: + for input_item in request.input: + normalized = self._normalize_response_message_for_chat(input_item) + if normalized is not None: + messages.append(normalized) # type: ignore + + # One Responses-API assistant turn maps to multiple input items + # (message + function_call(s)); collapse them into one chat message + # so chat templates render a single assistant block per turn. + messages = self._merge_consecutive_assistant_messages(messages) + + # Most chat templates expect a single leading ``system`` message; + # coalesce any ``instructions`` + interleaved ``developer`` entries. + system_chunks: list[str] = [] + other_msgs: list = [] + for m in messages: + if isinstance(m, dict) and m.get("role") == "system": + content = m.get("content") + if isinstance(content, str): + system_chunks.append(content) + elif isinstance(content, list): + for part in content: + if isinstance(part, dict): + text = part.get("text") + if isinstance(text, str): + system_chunks.append(text) + else: + other_msgs.append(m) + if system_chunks: + return [ + {"role": "system", "content": "\n\n".join(system_chunks)} + ] + other_msgs + return other_msgs + + def _construct_input_messages_with_harmony( + self, + request: ResponsesRequest, + prev_response: Optional[ResponsesResponse], + ) -> list[OpenAIMessage]: + messages: list[OpenAIMessage] = [] + if prev_response is None: + # New conversation. + reasoning_effort = request.reasoning.effort if request.reasoning else None + tool_types = [tool.type for tool in request.tools] + enable_browser = ( + any(t in tool_types for t in ("web_search", "web_search_preview")) + and self.tool_server is not None + ) + enable_code_interpreter = ( + "code_interpreter" in tool_types and self.tool_server is not None + ) + sys_msg = get_system_message( + reasoning_effort=reasoning_effort, + browser_description=( + self.tool_server.get_tool_description("browser") + if self.tool_server and enable_browser + else None + ), + python_description=( + self.tool_server.get_tool_description("python") + if self.tool_server and enable_code_interpreter + else None + ), + ) + messages.append(sys_msg) + dev_msg = get_developer_message(request.instructions, request.tools) + messages.append(dev_msg) + else: + # Continue the previous conversation. + # FIXME: Currently, request params like reasoning and + # instructions are ignored. + prev_msgs = self.msg_store[prev_response.id] + # Remove the previous chain-of-thoughts if there is a new "final" + # message. + if ( + len(prev_msgs) > 0 + and hasattr(prev_msgs[-1], "channel") + and prev_msgs[-1].channel == "final" + ): # type: ignore[union-attr] + prev_final_msg_idx = -1 + for i in range(len(prev_msgs) - 2, -1, -1): + if ( + hasattr(prev_msgs[i], "channel") + and prev_msgs[i].channel == "final" + ): # type: ignore[union-attr] + prev_final_msg_idx = i + break + recent_turn_msgs = prev_msgs[prev_final_msg_idx + 1 :] + del prev_msgs[prev_final_msg_idx + 1 :] + for msg in recent_turn_msgs: + if ( + hasattr(msg, "channel") and msg.channel != "analysis" + ): # type: ignore[union-attr] + prev_msgs.append(msg) + messages.extend(prev_msgs) + # Append the new input. + # Responses API supports simple text inputs without chat format. + if isinstance(request.input, str): + messages.append(get_user_message(request.input)) + else: + if prev_response is not None: + prev_outputs = list(prev_response.output) + else: + prev_outputs = [] + for response_msg in request.input: + if isinstance(response_msg, dict) and response_msg.get("type") == "function_call": + response_msg = ResponseFunctionToolCall.model_validate(response_msg) + messages.append(parse_response_input(response_msg, prev_outputs)) + if isinstance(response_msg, ResponseFunctionToolCall): + prev_outputs.append(response_msg) + return messages + + async def _run_background_request( + self, + request: ResponsesRequest, + sampling_params: Any, + result_generator: AsyncIterator[Any], + context: ConversationContext, + model_name: str, + tokenizer: Any, + request_metadata: RequestResponseMetadata, + created_time: Optional[int] = None, + *, + require_reasoning: bool, + ): + try: + # Update the status to "in_progress" + async with self.response_store_lock: + stored_response = self.response_store.get(request.request_id) + assert stored_response is not None + stored_response.status = "in_progress" + + response = await self.responses_full_generator( + request, + sampling_params, + result_generator, + context, + model_name, + tokenizer, + request_metadata, + created_time, + require_reasoning=require_reasoning, + ) + except Exception as e: + logger.exception("Background request failed for %s", request.request_id) + response = self.create_error_response(str(e)) + + if isinstance(response, ORJSONResponse): + # If the request has failed, update the status to "failed" + response_id = request.request_id + async with self.response_store_lock: + stored_response = self.response_store.get(response_id) + assert stored_response is not None + if stored_response.status not in ("completed", "cancelled"): + stored_response.status = "failed" + + async def retrieve_responses( + self, + response_id: str, + ) -> Union[ResponsesResponse, ORJSONResponse]: + if not response_id.startswith("resp_"): + return self._make_invalid_id_error(response_id) + + async with self.response_store_lock: + response = self.response_store.get(response_id) + registry = self._compat_registries.get(response_id) + + if response is None: + return self._make_not_found_error(response_id) + if registry is not None: + try: + return registry.response_model(response) + except ValueError as error: + return self.create_error_response(str(error)) + return response + + async def cancel_responses( + self, + response_id: str, + ) -> Union[ResponsesResponse, ORJSONResponse]: + result = await self._cancel_responses_internal(response_id) + registry = self._compat_registries.get(response_id) + if isinstance(result, ResponsesResponse) and registry is not None: + try: + return registry.response_model(result) + except ValueError as error: + return self.create_error_response(str(error)) + return result + + async def _cancel_responses_internal( + self, + response_id: str, + ) -> Union[ResponsesResponse, ORJSONResponse]: + if not response_id.startswith("resp_"): + return self._make_invalid_id_error(response_id) + + async with self.response_store_lock: + response = self.response_store.get(response_id) + if response is None: + return self._make_not_found_error(response_id) + + prev_status = response.status + if prev_status not in ("queued", "in_progress"): + # already terminal; a second cancel is a no-op, return as-is. + return response + + # Update the status to "cancelled" + response.status = "cancelled" + + # The response_id is the same as the rid used when submitting the request + self.tokenizer_manager.abort_request(rid=response_id) + + if task := self.background_tasks.get(response_id): + task.cancel() + try: + await task + except asyncio.CancelledError: + logger.exception("Background task for %s was cancelled", response_id) + return response + + def _make_invalid_id_error(self, response_id: str): + return self.create_error_response( + message=( + f"Invalid 'response_id': '{response_id}'. " + "Expected an ID that begins with 'resp'." + ), + err_type="invalid_request_error", + param="response_id", + ) + + def _make_not_found_error(self, response_id: str): + return self.create_error_response( + message=f"Response with id '{response_id}' not found.", + err_type="invalid_request_error", + status_code=HTTPStatus.NOT_FOUND, + param="response_id", + ) + + async def responses_stream_generator( + self, + request: ResponsesRequest, + sampling_params: Any, + result_generator: AsyncIterator[StreamingHarmonyContext], + context: StreamingHarmonyContext, + model_name: str, + tokenizer: Any, + request_metadata: RequestResponseMetadata, + created_time: Optional[int] = None, + *, + require_reasoning: bool, + ) -> AsyncGenerator[str, None]: + # TODO: + # 1. Handle disconnect + + created_time = created_time or int(time.time()) + + sequence_number = 0 + + def _send_event(event): + nonlocal sequence_number + # Set sequence_number if the event has this attribute + if hasattr(event, "sequence_number"): + event.sequence_number = sequence_number + sequence_number += 1 + # Get event type from the event's type field if it exists + event_type = getattr(event, "type", "unknown") + return ( + f"event: {event_type}\n" + f"data: {event.model_dump_json(indent=None)}\n\n" + ) + + current_content_index = 0 + current_output_index = 0 + current_item_id = f"item_{random_uuid()}" + sent_output_item_added = False + + initial_response = ResponsesResponse.from_request( + request, + sampling_params, + model_name=model_name, + created_time=created_time, + output=[], + status="in_progress", + usage=None, + ).model_dump() + yield _send_event( + openai_responses_types.ResponseCreatedEvent( + type="response.created", + sequence_number=-1, + response=initial_response, + ) + ) + yield _send_event( + openai_responses_types.ResponseInProgressEvent( + type="response.in_progress", + sequence_number=-1, + response=initial_response, + ) + ) + + async for ctx in result_generator: + # Only process context objects that implement the `is_expecting_start()` method, + # which indicates they support per-turn streaming (e.g., StreamingHarmonyContext). + # Contexts without this method are skipped, as they do not represent a new turn + # or are not compatible with per-turn handling in the /v1/responses endpoint. + if not hasattr(ctx, "is_expecting_start"): + continue + + if ctx.is_expecting_start(): + current_output_index += 1 + sent_output_item_added = False + + if len(ctx.parser.messages) > 0: + previous_item = ctx.parser.messages[-1] + if previous_item.recipient is not None: + # Deal with tool call here + pass + elif previous_item.channel == "analysis": + reasoning_item = ResponseReasoningItem( + id=f"rs_{random_uuid()}", + type="reasoning", + summary=[], + content=[ + ResponseReasoningTextContent( + text=previous_item.content[0].text, + type="reasoning_text", + ), + ], + status="completed", + ) + yield _send_event( + openai_responses_types.ResponseReasoningTextDoneEvent( + type="response.reasoning_text.done", + item_id=current_item_id, + sequence_number=-1, + output_index=current_output_index, + content_index=current_content_index, + text=previous_item.content[0].text, + ) + ) + yield _send_event( + openai_responses_types.ResponseOutputItemDoneEvent( + type="response.output_item.done", + sequence_number=-1, + output_index=current_output_index, + item=reasoning_item, + ) + ) + elif previous_item.channel == "final": + text_content = openai_responses_types.ResponseOutputText( + type="output_text", + text=previous_item.content[0].text, + annotations=[], + ) + yield _send_event( + openai_responses_types.ResponseTextDoneEvent( + type="response.output_text.done", + sequence_number=-1, + output_index=current_output_index, + content_index=current_content_index, + text=previous_item.content[0].text, + logprobs=[], + item_id=current_item_id, + ) + ) + yield _send_event( + openai_responses_types.ResponseContentPartDoneEvent( + type="response.content_part.done", + sequence_number=-1, + item_id=current_item_id, + output_index=current_output_index, + content_index=current_content_index, + part=text_content, + ) + ) + yield _send_event( + openai_responses_types.ResponseOutputItemDoneEvent( + type="response.output_item.done", + sequence_number=-1, + output_index=current_output_index, + item=openai_responses_types.ResponseOutputMessage( + id=current_item_id, + type="message", + role="assistant", + content=[text_content], + status="completed", + ), + ) + ) + + if ctx.parser.last_content_delta: + if ( + ctx.parser.current_channel == "final" + and ctx.parser.current_recipient is None + ): + if not sent_output_item_added: + sent_output_item_added = True + yield _send_event( + openai_responses_types.ResponseOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=current_output_index, + item=openai_responses_types.ResponseOutputMessage( + id=current_item_id, + type="message", + role="assistant", + content=[], + status="in_progress", + ), + ) + ) + yield _send_event( + openai_responses_types.ResponseContentPartAddedEvent( + type="response.content_part.added", + sequence_number=-1, + output_index=current_output_index, + item_id=current_item_id, + content_index=current_content_index, + part=openai_responses_types.ResponseOutputText( + type="output_text", + text="", + annotations=[], + logprobs=None, + ), + ) + ) + yield _send_event( + openai_responses_types.ResponseTextDeltaEvent( + type="response.output_text.delta", + sequence_number=-1, + content_index=current_content_index, + output_index=current_output_index, + item_id=current_item_id, + delta=ctx.parser.last_content_delta, + # TODO, use logprobs from ctx.last_request_output + logprobs=[], + ) + ) + elif ( + ctx.parser.current_channel == "analysis" + and ctx.parser.current_recipient is None + ): + if not sent_output_item_added: + sent_output_item_added = True + yield _send_event( + openai_responses_types.ResponseOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=current_output_index, + item=openai_responses_types.ResponseReasoningItem( + type="reasoning", + id=current_item_id, + summary=[], + status="in_progress", + ), + ) + ) + yield _send_event( + openai_responses_types.ResponseContentPartAddedEvent( + type="response.content_part.added", + sequence_number=-1, + output_index=current_output_index, + item_id=current_item_id, + content_index=current_content_index, + # TODO: migrate this to + # ResponseReasoningTextContent for now + part=openai_responses_types.ResponseOutputText( + type="output_text", + text="", + annotations=[], + logprobs=None, + ), + ) + ) + # TODO: migrate to OpenAI types once updated. + yield _send_event( + openai_responses_types.ResponseReasoningTextDeltaEvent( + type="response.reasoning_text.delta", + item_id=current_item_id, + output_index=current_output_index, + content_index=current_content_index, + delta=ctx.parser.last_content_delta, + sequence_number=-1, + ) + ) + + if ctx.is_assistant_action_turn() and len(ctx.parser.messages) > 0: + previous_item = ctx.parser.messages[-1] + if ( + self.supports_browsing + and previous_item.recipient is not None + and previous_item.recipient.startswith("browser.") + ): + function_name = previous_item.recipient[len("browser.") :] + action = None + parsed_args = orjson.loads(previous_item.content[0].text) + if function_name == "search": + action = openai_responses_types.response_function_web_search.ActionSearch( + type="search", + query=parsed_args["query"], + ) + elif function_name == "open": + action = openai_responses_types.response_function_web_search.ActionOpenPage( + type="open_page", + # TODO: translate to url + url=f"cursor:{parsed_args.get('cursor', '')}", + ) + elif function_name == "find": + action = openai_responses_types.response_function_web_search.ActionFind( + type="find", + pattern=parsed_args["pattern"], + # TODO: translate to url + url=f"cursor:{parsed_args.get('cursor', '')}", + ) + else: + raise ValueError(f"Unknown function name: {function_name}") + + yield _send_event( + openai_responses_types.ResponseOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=current_output_index, + item=openai_responses_types.response_function_web_search.ResponseFunctionWebSearch( + # TODO: generate a unique id for web search call + type="web_search_call", + id=current_item_id, + action=action, + status="in_progress", + ), + ) + ) + yield _send_event( + openai_responses_types.ResponseWebSearchCallInProgressEvent( + type="response.web_search_call.in_progress", + sequence_number=-1, + output_index=current_output_index, + item_id=current_item_id, + ) + ) + yield _send_event( + openai_responses_types.ResponseWebSearchCallSearchingEvent( + type="response.web_search_call.searching", + sequence_number=-1, + output_index=current_output_index, + item_id=current_item_id, + ) + ) + + # enqueue + yield _send_event( + openai_responses_types.ResponseWebSearchCallCompletedEvent( + type="response.web_search_call.completed", + sequence_number=-1, + output_index=current_output_index, + item_id=current_item_id, + ) + ) + yield _send_event( + openai_responses_types.ResponseOutputItemDoneEvent( + type="response.output_item.done", + sequence_number=-1, + output_index=current_output_index, + item=openai_responses_types.ResponseFunctionWebSearch( + type="web_search_call", + id=current_item_id, + action=action, + status="completed", + ), + ) + ) + + if ( + self.supports_code_interpreter + and previous_item.recipient is not None + and previous_item.recipient.startswith("python") + ): + yield _send_event( + openai_responses_types.ResponseOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=current_output_index, + item=openai_responses_types.ResponseCodeInterpreterToolCallParam( + type="code_interpreter_call", + id=current_item_id, + code="", + container_id="auto", + outputs=[], + status="in_progress", + ), + ) + ) + yield _send_event( + openai_responses_types.ResponseCodeInterpreterCallInProgressEvent( + type="response.code_interpreter_call.in_progress", + sequence_number=-1, + output_index=current_output_index, + item_id=current_item_id, + ) + ) + # TODO: do we need to add delta event here? + yield _send_event( + openai_responses_types.ResponseCodeInterpreterCallCodeDoneEvent( + type="response.code_interpreter_call_code.done", + sequence_number=-1, + output_index=current_output_index, + item_id=current_item_id, + code=previous_item.content[0].text, + ) + ) + yield _send_event( + openai_responses_types.ResponseCodeInterpreterCallInterpretingEvent( + type="response.code_interpreter_call.interpreting", + sequence_number=-1, + output_index=current_output_index, + item_id=current_item_id, + ) + ) + yield _send_event( + openai_responses_types.ResponseCodeInterpreterCallCompletedEvent( + type="response.code_interpreter_call.completed", + sequence_number=-1, + output_index=current_output_index, + item_id=current_item_id, + ) + ) + yield _send_event( + openai_responses_types.ResponseOutputItemDoneEvent( + type="response.output_item.done", + sequence_number=-1, + output_index=current_output_index, + item=openai_responses_types.ResponseCodeInterpreterToolCallParam( + type="code_interpreter_call", + id=current_item_id, + code=previous_item.content[0].text, + container_id="auto", + # TODO: add outputs here + outputs=[], + status="completed", + ), + ) + ) + + async def empty_async_generator(): + for _ in (): + yield + + final_response = await self.responses_full_generator( + request, + sampling_params, + empty_async_generator(), + context, + model_name, + tokenizer, + request_metadata, + created_time=created_time, + require_reasoning=require_reasoning, + ) + response_dict = final_response.model_dump() + # OpenAI SDK's Tool union may not know extended types; drop echo. + response_dict["tools"] = [] + + yield _send_event( + openai_responses_types.ResponseCompletedEvent( + type="response.completed", + sequence_number=-1, + response=response_dict, + ) + ) + + async def responses_stream_generator_non_harmony( + self, + request: ResponsesRequest, + sampling_params: Any, + result_generator: AsyncIterator[Any], + model_name: str, + tokenizer: Any, + request_metadata: RequestResponseMetadata, + created_time: Optional[int] = None, + *, + require_reasoning: bool, + ) -> AsyncGenerator[str, None]: + """Stream a /v1/responses response as typed OpenAI SSE events for + non-harmony models. Each engine chunk is run through the reasoning + and function-call parsers; leftover text becomes + ``response.output_text.delta``. + """ + + created_time = created_time or int(time.time()) + sequence_number = 0 + + def _send_event(event): + nonlocal sequence_number + if hasattr(event, "sequence_number"): + event.sequence_number = sequence_number + sequence_number += 1 + event_type = getattr(event, "type", "unknown") + return ( + f"event: {event_type}\n" + f"data: {event.model_dump_json(indent=None)}\n\n" + ) + + # The streaming Response* event models echo ``tools`` through a + # narrower OpenAI SDK Tool union; strip it to avoid pydantic + # validation failures on extended tool types. + def _sanitize_response_dict(d: dict) -> dict: + d["tools"] = [] + return d + + initial_response = _sanitize_response_dict( + ResponsesResponse.from_request( + request, + sampling_params, + model_name=model_name, + created_time=created_time, + output=[], + status="in_progress", + usage=None, + ).model_dump() + ) + yield _send_event( + openai_responses_types.ResponseCreatedEvent( + type="response.created", + sequence_number=-1, + response=initial_response, + ) + ) + yield _send_event( + openai_responses_types.ResponseInProgressEvent( + type="response.in_progress", + sequence_number=-1, + response=initial_response, + ) + ) + + chat_tools = self._response_tools_to_chat_tools(request) + is_required = request.tool_choice == "required" or isinstance(request.tool_choice, dict) + required_buffer = "" + tool_parser: Optional[Union[FunctionCallParser, JsonArrayParser]] = None + if chat_tools and request.tool_choice != "none": + native_supports_structural_tag = False + if self.tool_call_parser: + probe = FunctionCallParser( + chat_tools, + self.tool_call_parser, + tokenizer=self.tokenizer_manager.tokenizer, + ) + native_supports_structural_tag = ( + probe.detector.supports_structural_tag() + ) + if is_required and not native_supports_structural_tag: + tool_parser = JsonArrayParser() + elif self.tool_call_parser: + tool_parser = FunctionCallParser( + chat_tools, + self.tool_call_parser, + tokenizer=self.tokenizer_manager.tokenizer, + ) + if hasattr(tool_parser.detector, "preserve_raw_input_tools"): + tool_parser.detector.preserve_raw_input_tools = request._custom_tool_names + reasoning_parser_obj: Optional[ReasoningParser] = None + if self.reasoning_parser: + reasoning_parser_obj = ReasoningParser( + model_type=self.reasoning_parser, + stream_reasoning=True, + # A template that prefills forces the parser open even + # when the request itself did not ask for reasoning, same as chat. + force_reasoning=( + self.template_manager.force_reasoning or require_reasoning + ), + request=request, + tokenizer=self.tokenizer_manager.tokenizer, + tool_call_parser_active=isinstance(tool_parser, FunctionCallParser), + ) + + current_output_index = -1 + reasoning_state = { + "open": False, + "item_id": "", + "output_index": -1, + "text": "", + } + message_state = { + "open": False, + "item_id": "", + "output_index": -1, + "text": "", + } + tool_call_states: dict[int, dict[str, Any]] = {} + # Items closed during the stream, in wire order. Feeds the final + # ``response.completed`` snapshot and the stored response. + emitted_items: list = [] + + prompt_tokens = 0 + completion_tokens = 0 + cached_tokens = 0 + total_tokens_meta = 0 + reasoning_tokens_meta = 0 + finish_reason: Optional[dict[str, Any]] = None + flushed = False + stream_offset = 0 + incremental = self.tokenizer_manager.server_args.incremental_streaming_output + + def _open_reasoning_item() -> str: + nonlocal current_output_index + current_output_index += 1 + item_id = f"rs_{random_uuid()}" + reasoning_state.update( + open=True, item_id=item_id, output_index=current_output_index, text="" + ) + return item_id + + wants_summary = self._wants_reasoning_summary(request) + + def _close_reasoning_item(): + if not reasoning_state["open"]: + return [] + text = reasoning_state["text"] + completed_item = ResponseReasoningItem( + id=reasoning_state["item_id"], + type="reasoning", + summary=( + [ResponseReasoningSummary(type="summary_text", text=text)] + if wants_summary + else [] + ), + content=[ + ResponseReasoningTextContent(type="reasoning_text", text=text), + ], + status="completed", + ) + events: list = [] + if wants_summary: + events.append( + _send_event( + openai_responses_types.ResponseReasoningSummaryTextDoneEvent( + type="response.reasoning_summary_text.done", + item_id=reasoning_state["item_id"], + sequence_number=-1, + output_index=reasoning_state["output_index"], + summary_index=0, + text=text, + ) + ) + ) + events.append( + _send_event( + openai_responses_types.ResponseReasoningSummaryPartDoneEvent( + type="response.reasoning_summary_part.done", + item_id=reasoning_state["item_id"], + sequence_number=-1, + output_index=reasoning_state["output_index"], + summary_index=0, + part=ResponseReasoningSummaryDonePart( + type="summary_text", text=text + ), + ) + ) + ) + else: + events.append( + _send_event( + openai_responses_types.ResponseReasoningTextDoneEvent( + type="response.reasoning_text.done", + item_id=reasoning_state["item_id"], + sequence_number=-1, + output_index=reasoning_state["output_index"], + content_index=0, + text=text, + ) + ) + ) + events += [ + _send_event( + openai_responses_types.ResponseOutputItemDoneEvent( + type="response.output_item.done", + sequence_number=-1, + output_index=reasoning_state["output_index"], + item=completed_item, + ) + ), + ] + emitted_items.append(completed_item) + reasoning_state["open"] = False + return events + + def _open_message_item() -> str: + nonlocal current_output_index + current_output_index += 1 + item_id = f"msg_{random_uuid()}" + message_state.update( + open=True, item_id=item_id, output_index=current_output_index, text="" + ) + return item_id + + def _close_message_item(): + if not message_state["open"]: + return [] + text = message_state["text"] + text_content = openai_responses_types.ResponseOutputText( + type="output_text", text=text, annotations=[], logprobs=None + ) + completed_item = ResponseOutputMessage( + id=message_state["item_id"], + type="message", + role="assistant", + content=[text_content], + status="completed", + ) + events = [ + _send_event( + openai_responses_types.ResponseTextDoneEvent( + type="response.output_text.done", + sequence_number=-1, + output_index=message_state["output_index"], + content_index=0, + text=text, + logprobs=[], + item_id=message_state["item_id"], + ) + ), + _send_event( + openai_responses_types.ResponseContentPartDoneEvent( + type="response.content_part.done", + sequence_number=-1, + item_id=message_state["item_id"], + output_index=message_state["output_index"], + content_index=0, + part=text_content, + ) + ), + _send_event( + openai_responses_types.ResponseOutputItemDoneEvent( + type="response.output_item.done", + sequence_number=-1, + output_index=message_state["output_index"], + item=completed_item, + ) + ), + ] + emitted_items.append(completed_item) + message_state["open"] = False + return events + + def _close_tool_call_state(tool_index: int): + if self._status_from_finish_reason(finish_reason) != "completed": + return [] + state = tool_call_states.get(tool_index) + if state is None or state.get("done"): + return [] + arguments = state["arguments"] + completed_item = ResponseFunctionToolCall( + arguments=arguments, + call_id=state["call_id"], + name=state["name"] or "", + type="function_call", + id=state["item_id"], + status="completed", + ) + if request._compat_registry is not None: + request._compat_registry.output_item(completed_item) + events = [ + _send_event( + openai_responses_types.ResponseFunctionCallArgumentsDoneEvent( + type="response.function_call_arguments.done", + sequence_number=-1, + item_id=state["item_id"], + output_index=state["output_index"], + arguments=arguments, + name=state["name"] or "", + ) + ), + _send_event( + openai_responses_types.ResponseOutputItemDoneEvent( + type="response.output_item.done", + sequence_number=-1, + output_index=state["output_index"], + item=completed_item, + ) + ), + ] + emitted_items.append(completed_item) + state["done"] = True + return events + + try: + async for ctx in result_generator: + if isinstance(ctx, dict): + chunk = ctx + else: + chunk = getattr(ctx, "last_output", None) + if not isinstance(chunk, dict): + continue + meta = chunk.get("meta_info") or {} + prompt_tokens = meta.get("prompt_tokens", prompt_tokens) + completion_tokens = meta.get("completion_tokens", completion_tokens) + cached_tokens = meta.get("cached_tokens", cached_tokens) + total_tokens_meta = meta.get("total_tokens", total_tokens_meta) + reasoning_tokens_meta = meta.get( + "reasoning_tokens", reasoning_tokens_meta + ) + finish_reason = meta.get("finish_reason") or finish_reason + + text = chunk.get("text", "") or "" + if incremental: + delta = text + else: + delta = text[stream_offset:] + stream_offset = len(text) + if not delta and finish_reason is None: + continue + # finish_reason is sticky, so it would otherwise re-flush. + flush = ( + not flushed + and finish_reason is not None + and self._status_from_finish_reason(finish_reason) == "completed" + ) + flushed = flushed or flush + + if reasoning_parser_obj is not None: + reasoning_chunk, delta = reasoning_parser_obj.parse_stream_chunk( + delta + ) + if flush: + end_reasoning, end_normal = ( + reasoning_parser_obj.parse_stream_end() + ) + if end_reasoning: + reasoning_chunk = (reasoning_chunk or "") + end_reasoning + if end_normal: + delta = (delta or "") + end_normal + else: + reasoning_chunk = None + + if reasoning_chunk: + if message_state["open"]: + for ev in _close_message_item(): + yield ev + if not reasoning_state["open"]: + item_id = _open_reasoning_item() + yield _send_event( + openai_responses_types.ResponseOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=reasoning_state["output_index"], + item=ResponseReasoningItem( + id=item_id, + type="reasoning", + summary=[], + content=[], + status="in_progress", + ), + ) + ) + # Clients that opt into ``reasoning.summary`` render + # off the ``reasoning_summary_text.*`` event stream, + # so mirror the trace into a summary part. + if wants_summary: + yield _send_event( + openai_responses_types.ResponseReasoningSummaryPartAddedEvent( + type="response.reasoning_summary_part.added", + item_id=item_id, + output_index=reasoning_state["output_index"], + summary_index=0, + part=ResponseReasoningSummaryAddedPart( + type="summary_text", text="" + ), + sequence_number=-1, + ) + ) + reasoning_state["text"] += reasoning_chunk + if wants_summary: + yield _send_event( + openai_responses_types.ResponseReasoningSummaryTextDeltaEvent( + type="response.reasoning_summary_text.delta", + item_id=reasoning_state["item_id"], + output_index=reasoning_state["output_index"], + summary_index=0, + delta=reasoning_chunk, + sequence_number=-1, + ) + ) + else: + yield _send_event( + openai_responses_types.ResponseReasoningTextDeltaEvent( + type="response.reasoning_text.delta", + item_id=reasoning_state["item_id"], + output_index=reasoning_state["output_index"], + content_index=0, + delta=reasoning_chunk, + sequence_number=-1, + ) + ) + + if not delta and not flush: + continue + + if isinstance(tool_parser, JsonArrayParser): + required_buffer += delta + normal_text, tool_calls = "", [] + if flush and required_buffer.strip(): + tool_calls = [ + ToolCallItem(tool_index=index, name=name, parameters=arguments) + for index, (name, arguments) in enumerate( + validated_json_calls(required_buffer, {tool.function.name for tool in chat_tools}) + ) + ] + elif tool_parser is not None: + normal_text, tool_calls = tool_parser.parse_stream_chunk(delta) + if flush: + end_text, end_calls = tool_parser.parse_stream_end() + normal_text = (normal_text or "") + end_text + tool_calls = list(tool_calls) + end_calls + else: + normal_text, tool_calls = delta, [] + + def _emit_tool_calls(calls): + nonlocal current_output_index + if calls: + if reasoning_state["open"]: + for ev in _close_reasoning_item(): + yield ev + if message_state["open"]: + for ev in _close_message_item(): + yield ev + + for call in calls: + tool_index = call.tool_index + state = tool_call_states.get(tool_index) + if state is None or state.get("done"): + # Close other open calls first, so their + # output_item.done precedes the next added. + for other_index in list(tool_call_states): + if other_index != tool_index: + for ev in _close_tool_call_state(other_index): + yield ev + current_output_index += 1 + item_id = f"fc_{random_uuid()[:8]}" + call_id = f"call_{random_uuid()[:24]}" + state = { + "item_id": item_id, + "call_id": call_id, + "output_index": current_output_index, + "name": call.name or "", + "arguments": "", + "added": False, + "done": False, + } + tool_call_states[tool_index] = state + if not state["added"]: + if request._compat_registry is not None: + request._compat_registry.output_identity(state["name"]) + state["added"] = True + yield _send_event( + openai_responses_types.ResponseOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=state["output_index"], + item=ResponseFunctionToolCall( + arguments="", + call_id=state["call_id"], + name=state["name"], + type="function_call", + id=state["item_id"], + status="in_progress", + ), + ) + ) + if call.parameters: + state["arguments"] += call.parameters + yield _send_event( + openai_responses_types.ResponseFunctionCallArgumentsDeltaEvent( + type="response.function_call_arguments.delta", + sequence_number=-1, + item_id=state["item_id"], + output_index=state["output_index"], + delta=call.parameters, + ) + ) + + def _emit_normal_text(): + if normal_text and _should_emit_normal_text_as_message( + normal_text, + any_tool_call_in_progress=any( + not s.get("done") for s in tool_call_states.values() + ), + ): + if reasoning_state["open"]: + for ev in _close_reasoning_item(): + yield ev + for tool_index in list(tool_call_states): + for ev in _close_tool_call_state(tool_index): + yield ev + if not message_state["open"]: + item_id = _open_message_item() + yield _send_event( + openai_responses_types.ResponseOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=message_state["output_index"], + item=ResponseOutputMessage( + id=item_id, + type="message", + role="assistant", + content=[], + status="in_progress", + ), + ) + ) + yield _send_event( + openai_responses_types.ResponseContentPartAddedEvent( + type="response.content_part.added", + sequence_number=-1, + output_index=message_state["output_index"], + item_id=message_state["item_id"], + content_index=0, + part=openai_responses_types.ResponseOutputText( + type="output_text", + text="", + annotations=[], + logprobs=None, + ), + ) + ) + message_state["text"] += normal_text + yield _send_event( + openai_responses_types.ResponseTextDeltaEvent( + type="response.output_text.delta", + sequence_number=-1, + content_index=0, + output_index=message_state["output_index"], + item_id=message_state["item_id"], + delta=normal_text, + logprobs=[], + ) + ) + + # The parser's (text, calls) tuple is unordered, but positions + # are recoverable: continuing arguments precede this delta's + # text, a newly opened call follows it. Classify first -- + # emitting mutates tool_call_states. + def _is_continuing(call): + state = tool_call_states.get(call.tool_index) + return state is not None and not state.get("done") + + continuing = [c for c in tool_calls if _is_continuing(c)] + opening = [c for c in tool_calls if not _is_continuing(c)] + + for ev in _emit_tool_calls(continuing): + yield ev + for ev in _emit_normal_text(): + yield ev + for ev in _emit_tool_calls(opening): + yield ev + except Exception: + logger.exception("Error while streaming /v1/responses") + failed = _sanitize_response_dict( + ResponsesResponse.from_request( + request, + sampling_params, + model_name=model_name, + created_time=created_time, + output=[], + status="failed", + usage=None, + ).model_dump() + ) + yield _send_event( + openai_responses_types.ResponseFailedEvent( + type="response.failed", + sequence_number=-1, + response=failed, + ) + ) + return + + status = self._status_from_finish_reason(finish_reason) + for ev in _close_reasoning_item(): + yield ev + for ev in _close_message_item(): + yield ev + if status == "completed": + for tool_index in list(tool_call_states): + for ev in _close_tool_call_state(tool_index): + yield ev + + final_output_items = list(emitted_items) + if request._compat_registry is not None: + request._compat_registry.validate_completion(final_output_items, status) + + usage = UsageInfo( + prompt_tokens=prompt_tokens, + completion_tokens=completion_tokens, + total_tokens=total_tokens_meta or (prompt_tokens + completion_tokens), + reasoning_tokens=reasoning_tokens_meta, + ) + if self.enable_prompt_tokens_details and cached_tokens: + usage.prompt_tokens_details = PromptTokenUsageInfo( + cached_tokens=cached_tokens + ) + request_metadata.final_usage_info = usage + + final_response = ResponsesResponse.from_request( + request, + sampling_params, + model_name=model_name, + created_time=created_time, + output=final_output_items, + status=status, + usage=usage, + ) + final_response.error = self._error_from_finish_reason(finish_reason) + if request.store: + async with self.response_store_lock: + stored = self.response_store.get(final_response.id) + if stored is None or stored.status != "cancelled": + self.response_store[final_response.id] = final_response + self._store_compat_metadata(request, final_response.id) + + response_dict = _sanitize_response_dict(final_response.model_dump()) + + terminal_event = ( + openai_responses_types.ResponseIncompleteEvent if status == "incomplete" + else ( + openai_responses_types.ResponseFailedEvent + if status in ("failed", "cancelled") + else openai_responses_types.ResponseCompletedEvent + ) + ) + terminal_type = ( + "response.incomplete" if status == "incomplete" + else ( + "response.failed" + if status in ("failed", "cancelled") + else "response.completed" + ) + ) + yield _send_event( + terminal_event( + type=terminal_type, + sequence_number=-1, + response=response_dict, + ) + ) + + async def _generate_with_builtin_tools( + self, + request_id: str, + request_prompt: Any, + adapted_request: GenerateReqInput, + sampling_params: Any, + context: ConversationContext, + raw_request: Optional[Request] = None, + priority: Optional[int] = None, + **kwargs, + ) -> AsyncGenerator[Any, None]: + """Generate with builtin tool support for harmony-based models.""" + orig_priority = priority or 0 + + while True: + # Generate using SGLang's tokenizer manager + generator = self.tokenizer_manager.generate_request( + adapted_request, raw_request + ) + + try: + async for res in generator: + context.append_output(res) + yield context + finally: + await generator.aclose() + + if not context.need_builtin_tool_call(): + # The model did not ask for a tool call, so we're done. + break + + # Call the tool and update the context with the result. + tool_output = await context.call_tool() + context.append_output(tool_output) + + # Prepare for the next generation turn + # Render the updated conversation for the next completion + prompt_token_ids = context.render_for_completion() + + # Update the adapted request with new prompt + adapted_request = GenerateReqInput( + input_ids=prompt_token_ids, + sampling_params=sampling_params, + stream=adapted_request.stream, + rid=request_id, + session_id=adapted_request.session_id, + extra_key=adapted_request.extra_key, + cache_salt=adapted_request.cache_salt, + return_logprob=adapted_request.return_logprob, + logprob_start_len=adapted_request.logprob_start_len, + top_logprobs_num=adapted_request.top_logprobs_num, + return_text_in_logprobs=adapted_request.return_text_in_logprobs, + return_hidden_states=adapted_request.return_hidden_states, + background=adapted_request.background, + require_reasoning=adapted_request.require_reasoning, + ) + + # Update sampling params with reduced max_tokens + if hasattr(sampling_params, "max_new_tokens") or isinstance( + sampling_params, dict + ): + context_len = getattr( + self.tokenizer_manager.model_config, "context_len", 4096 + ) + num_reserved_tokens = self.tokenizer_manager.num_reserved_tokens + remaining_tokens = ( + context_len - len(prompt_token_ids) - num_reserved_tokens + ) + + if isinstance(sampling_params, dict): + sampling_params["max_new_tokens"] = max(remaining_tokens, 1) + else: + sampling_params.max_new_tokens = max(remaining_tokens, 1) + + # Slightly reduce priority for subsequent tool calls + priority = orig_priority - 1 diff --git a/runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py b/runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py new file mode 100644 index 0000000..2c993ec --- /dev/null +++ b/runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py @@ -0,0 +1,3398 @@ +from __future__ import annotations + +from sglang.srt.dllm.config import DllmConfig +from sglang.srt.model_executor.forward_batch_info import ForwardBatch +from sglang.srt.runtime_context import ( + get_exec, + get_schedule, + get_serving, + get_spec, + mamba_cache_chunk_size, + mamba_checkpoint_grid, + mamba_extra_buffer_enabled, + mamba_extra_buffer_lazy_enabled, +) +from sglang.srt.utils.common import ( + Range, + ceil_align, + flatten_arrays_to_pinned_cpu, + is_pin_memory_available, +) + +# Copyright 2023-2024 SGLang Team +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +""" +Store information about requests and batches. + +The following is the flow of data structures for a batch: + +ScheduleBatch -> ForwardBatch + +- ScheduleBatch is managed by `scheduler.py::Scheduler`. + It contains high-level scheduling data. Most of the data is on the CPU. +- ForwardBatch is managed by `model_runner.py::ModelRunner`. + It contains low-level tensor data. Most of the data consists of GPU tensors. + It is constructed directly from a ScheduleBatch by `ForwardBatch.init_new`. +""" + +import copy +import dataclasses +import logging +import re +import sys +from array import array +from concurrent.futures import Future +from enum import Enum, auto +from functools import lru_cache +from http import HTTPStatus +from typing import ( + TYPE_CHECKING, + Any, + Dict, + List, + Literal, + NamedTuple, + Optional, + Set, + Tuple, + Union, +) + +import msgspec +import numpy as np +import torch + +from sglang.srt.constrained.base_grammar_backend import BaseGrammarObject +from sglang.srt.disaggregation.base import BaseKVSender +from sglang.srt.disaggregation.decode_schedule_batch_mixin import ( + ScheduleBatchDisaggregationDecodeMixin, +) +from sglang.srt.disaggregation.utils import FAKE_BOOTSTRAP_HOST, DisaggregationMode +from sglang.srt.dllm.mixin.req import ReqDllmMixin +from sglang.srt.environ import envs +from sglang.srt.hardware_backend.npu.dsv4.dsv4_common_hooks import ( + maybe_evict_dsv4_state, +) +from sglang.srt.managers.embed_types import PositionalEmbeds +from sglang.srt.managers.scheduler_components.new_token_ratio_tracker import ( + NewTokenRatioTracker, +) +from sglang.srt.mem_cache.allocation import ( + alloc_for_decode, + alloc_for_extend, +) +from sglang.srt.mem_cache.allocation_sizing import get_alloc_reserve_per_decode +from sglang.srt.mem_cache.allocator import BaseTokenToKVPoolAllocator +from sglang.srt.mem_cache.base_prefix_cache import ( + BasePrefixCache, + MatchPrefixParams, + zero_match_result, +) +from sglang.srt.mem_cache.common import ( + evict_from_tree_cache, + free_swa_out_of_window_slots, + release_kv_cache, +) +from sglang.srt.mem_cache.memory_pool import ReqToTokenPool +from sglang.srt.mem_cache.radix_cache import RadixKey +from sglang.srt.model_executor.forward_batch_info import ( + CaptureHiddenMode, + ForwardBatch, + ForwardMode, +) +from sglang.srt.multimodal.transport.cuda_ipc import ( + DEFER_CUDA_IPC_FEATURE_RECONSTRUCTION_KEY, + CudaIpcTensorTransportProxy, +) +from sglang.srt.observability.metrics_collector import ( + DPCooperationInfo, + SchedulerMetricsCollector, +) +from sglang.srt.observability.req_time_stats import ( + APIServerReqTimeStats, + DPControllerReqTimeStats, + SchedulerReqTimeStats, +) +from sglang.srt.runtime_context import get_parallel +from sglang.srt.sampling.sampling_batch_info import SamplingBatchInfo +from sglang.srt.sampling.sampling_params import SamplingParams +from sglang.srt.server_args import ServerArgs +from sglang.srt.utils import flatten_nested_list +from sglang.srt.utils.token_sequence_matcher import TokenSequenceMatcher + +if TYPE_CHECKING: + from typing import Any, Dict + + from sglang.srt.configs.model_config import ModelConfig + from sglang.srt.managers.hisparse_coordinator import HiSparseCoordinator + from sglang.srt.managers.scheduler_components.metrics_reporter import PrefillStats + from sglang.srt.session.session_controller import Session + from sglang.srt.speculative.spec_info import SpecInput, SpeculativeAlgorithm + +INIT_INCREMENTAL_DETOKENIZATION_OFFSET = 5 + +# Constant used as the base offset for MM (multimodal) pad values. +# This ensures pad_values don't overlap with valid text token IDs. +MM_PAD_SHIFT_VALUE = 1_000_000 + +logger = logging.getLogger(__name__) + + +ReturnHiddenStatesMode = Union[bool, Literal["last"]] + + +def get_return_hidden_states_mode( + return_hidden_states: ReturnHiddenStatesMode, +) -> CaptureHiddenMode: + if return_hidden_states is True: + return CaptureHiddenMode.FULL + if return_hidden_states == "last": + return CaptureHiddenMode.LAST + if return_hidden_states is False: + return CaptureHiddenMode.NULL + raise ValueError( + "return_hidden_states must be a boolean or the string literal 'last'." + ) + + +def get_request_return_hidden_states_mode( + return_hidden_states: Union[List[ReturnHiddenStatesMode], ReturnHiddenStatesMode], +) -> CaptureHiddenMode: + if isinstance(return_hidden_states, list): + return max( + (get_return_hidden_states_mode(mode) for mode in return_hidden_states), + default=CaptureHiddenMode.NULL, + ) + return get_return_hidden_states_mode(return_hidden_states) + + +def get_batch_return_hidden_states_mode(reqs: List[Req]) -> CaptureHiddenMode: + mode = CaptureHiddenMode.NULL + for req in reqs: + mode = max(mode, req.return_hidden_states_mode) + return mode + + +def need_return_hidden_states( + return_hidden_states: Union[List[ReturnHiddenStatesMode], ReturnHiddenStatesMode], +) -> bool: + return get_request_return_hidden_states_mode(return_hidden_states).need_capture() + + +@lru_cache(maxsize=1) +def sanity_check_mm_pad_shift_value(vocab_size: int) -> None: + if vocab_size > MM_PAD_SHIFT_VALUE: + raise ValueError( + f"Model vocab_size ({vocab_size}) exceeds MM_PAD_SHIFT_VALUE ({MM_PAD_SHIFT_VALUE}). " + f"MM pad_values may overlap with valid token IDs. " + f"Please increase MM_PAD_SHIFT_VALUE in schedule_batch.py." + ) + + +def split_cached_prefix_by_tier( + prefix_len: int, host_hit_len: int, storage_hit_len: int +) -> tuple[int, int, int]: + """Split a request's cached prefix into (device, host, storage) tokens. + + prefix_len is len(prefix_indices) AFTER host load-back, so it contains the + host-loaded portion; host_hit_len in turn contains the storage-prefetched + portion (storage is clamped to it to handle edge cases). + """ + storage = min(host_hit_len, storage_hit_len) + host = host_hit_len - storage + device = max(0, prefix_len - host_hit_len) + return device, host, storage + + +def _compute_pad_value(hash: int) -> int: + """Compute pad value from hash.""" + return MM_PAD_SHIFT_VALUE + (hash % (1 << 30)) + + +class BaseFinishReason: + def to_json(self): + raise NotImplementedError() + + +class FINISH_MATCHED_TOKEN(BaseFinishReason): + def __init__(self, matched: Union[int, List[int]]): + super().__init__() + self.matched = matched + + def to_json(self): + return { + "type": "stop", # to match OpenAI API's return value + "matched": self.matched, + } + + +class FINISH_MATCHED_STR(BaseFinishReason): + def __init__(self, matched: str): + super().__init__() + self.matched = matched + + def to_json(self): + return { + "type": "stop", # to match OpenAI API's return value + "matched": self.matched, + } + + +class FINISHED_MATCHED_REGEX(BaseFinishReason): + def __init__(self, matched: str): + super().__init__() + self.matched = matched + + def to_json(self): + return { + "type": "stop", # to match OpenAI API's return value + "matched": self.matched, + } + + +class FINISH_LENGTH(BaseFinishReason): + def __init__(self, length: int): + super().__init__() + self.length = length + + def to_json(self): + return { + "type": "length", # to match OpenAI API's return value + "length": self.length, + } + + +class FINISH_ABORT(BaseFinishReason): + def __init__(self, message=None, status_code=None, err_type=None): + super().__init__() + self.message = message or "Aborted" + self.status_code = status_code + self.err_type = err_type + + def to_json(self): + return { + "type": "abort", + "message": self.message, + "status_code": self.status_code, + "err_type": self.err_type, + } + + +class Modality(Enum): + IMAGE = auto() + VIDEO = auto() + AUDIO = auto() + + @staticmethod + def from_str(modality_str: str): + try: + return Modality[modality_str.upper()] + except KeyError: + raise ValueError( + f"Invalid modality string: {modality_str}. Valid modalities are: {[m.name for m in Modality]}" + ) + + @staticmethod + def all(): + return [Modality.IMAGE, Modality.VIDEO, Modality.AUDIO] + + +class MultimodalInputFormat(Enum): + NORMAL = auto() + PROCESSOR_OUTPUT = auto() + PRECOMPUTED_EMBEDDING = auto() + + +@dataclasses.dataclass +class MultimodalDataItem: + """ + One MultimodalDataItem represents a single multimodal input (one image, one video, or one audio). + For example, if there are 3 images and 1 audio, there will be 4 MultimodalDataItems. + + Each item has its own hash and pad_value, enabling per-image RadixAttention caching. + + We put the common fields first and the model-specific fields in model_specific_data. + """ + + modality: Modality + hash: int = None + pad_value: int = None + offsets: Optional[list] = None + + format: MultimodalInputFormat = MultimodalInputFormat.NORMAL + + # the raw features returned by processor, e.g. pixel_values or audio_features + feature: Union[torch.Tensor, np.ndarray] = None + # the precomputed embeddings, passed as final encoder embeddings + # One and only one of the feature and precomputed_embeddings will be empty + precomputed_embeddings: Optional[Union[torch.Tensor, np.ndarray]] = None + + # Model-specific data stored in a dictionary + model_specific_data: dict[str, Any] = dataclasses.field(default_factory=dict) + + def __getattr__(self, name: str): + if ( + "model_specific_data" in self.__dict__ + and name in self.__dict__["model_specific_data"] + ): + return self.__dict__["model_specific_data"][name] + else: + raise AttributeError( + f"'{self.__class__.__name__}' object has no attribute '{name}'" + ) + + def __setitem__(self, key: str, value: Any): + if key in self.__dict__: + self.__dict__[key] = value + else: + self.model_specific_data[key] = value + + def set(self, key: str, value: Any): + self.__setitem__(key, value) + + def set_hash(self, hash_value: int) -> None: + self.hash = hash_value + self.pad_value = _compute_pad_value(hash_value) + + @staticmethod + def is_empty_list(l): + if l is None: + return True + return len([item for item in flatten_nested_list(l) if item is not None]) == 0 + + def set_pad_value(self): + """ + Set the pad value after first hashing the data + """ + if self.pad_value is not None: + return + + from sglang.srt.multimodal.cache import resolve_multimodal_item_hash + + self.hash = resolve_multimodal_item_hash( + existing_hash=self.hash, + feature=self.feature, + precomputed_embeddings=self.precomputed_embeddings, + ) + self.pad_value = _compute_pad_value(self.hash) + + def is_modality(self, modality: Modality) -> bool: + return self.modality == modality + + def is_audio(self): + return self.modality == Modality.AUDIO + + def is_image(self): + return self.modality == Modality.IMAGE + + def is_video(self): + return self.modality == Modality.VIDEO + + def is_valid(self) -> bool: + return self.is_image() or self.is_video() or self.is_audio() + + def validate(self): + ... + # TODO + + def is_precomputed_embedding(self): + return self.format == MultimodalInputFormat.PRECOMPUTED_EMBEDDING + + @staticmethod + def from_dict(obj: dict): + kwargs = dict(obj) + modality = kwargs.pop("modality") + if isinstance(modality, str): + modality = Modality[modality] + ret = MultimodalDataItem(modality=modality, **kwargs) + ret.validate() + return ret + + def has_cuda_ipc_proxy(self): + return ( + isinstance(self.feature, CudaIpcTensorTransportProxy) + or isinstance(self.precomputed_embeddings, CudaIpcTensorTransportProxy) + or any( + isinstance(value, CudaIpcTensorTransportProxy) + for value in self.model_specific_data.values() + ) + ) + + def reconstruct(self, target_device: int, ipc_consumer_count: int = 1): + """materialize cuda ipc proxy tensors in-place on target_device""" + if isinstance(self.feature, CudaIpcTensorTransportProxy): + consumer_count = self._resolve_transport_consumer_count( + self.feature, ipc_consumer_count + ) + if consumer_count == 1: + self.feature = self.feature.reconstruct_on_target_device(target_device) + else: + self.feature = self.feature.reconstruct_on_target_device( + target_device, consumer_count=consumer_count + ) + if isinstance(self.precomputed_embeddings, CudaIpcTensorTransportProxy): + self.precomputed_embeddings = ( + self.precomputed_embeddings.reconstruct_on_target_device(target_device) + ) + for extra_key in self.model_specific_data: + if isinstance( + self.model_specific_data[extra_key], CudaIpcTensorTransportProxy + ): + extra_data = self.model_specific_data[ + extra_key + ].reconstruct_on_target_device(target_device) + self.model_specific_data[extra_key] = extra_data + + def can_defer_cuda_ipc_feature_reconstruction(self) -> bool: + """Whether a DP-aware model will materialize this feature lazily. + + Hashing and pad-value generation must already have completed on the + tokenizer worker. Any additional IPC proxy would still need eager + reconstruction, so keep the narrow fast path feature-only. + """ + return ( + self.model_specific_data.get( + DEFER_CUDA_IPC_FEATURE_RECONSTRUCTION_KEY, False + ) + and self.hash is not None + and self.pad_value is not None + and isinstance(self.feature, CudaIpcTensorTransportProxy) + and not isinstance(self.precomputed_embeddings, CudaIpcTensorTransportProxy) + and not any( + isinstance(value, CudaIpcTensorTransportProxy) + for value in self.model_specific_data.values() + ) + ) + + def acknowledge_deferred_cuda_ipc_feature(self, consumer_count: int = 1): + """Release a lazy IPC feature when an embedding-cache hit skips ViT.""" + if isinstance(self.feature, CudaIpcTensorTransportProxy): + consumer_count = self._resolve_transport_consumer_count( + self.feature, consumer_count + ) + self.feature.acknowledge_consumption(consumer_count) + + @staticmethod + def _resolve_transport_consumer_count(proxy, requested_count: int) -> int: + """Clamp a group acknowledgement to the proxy's actual consumer set.""" + proxy_count = getattr( + proxy, + "total_consumer_count", + getattr(proxy, "consumer_count", requested_count), + ) + return min(requested_count, proxy_count) + + +@dataclasses.dataclass +class MultimodalProcessorOutput: + """Raw output from multimodal processors before scheduler-side preparation (pad, hash). + + This is the typed replacement for the dict previously returned by + ``BaseMultimodalProcessor.process_mm_data_async``. Preprocessed inputs may + already carry ``pad_value`` and ``hash`` to avoid hashing the same tensor once + per scheduler TP rank. + """ + + mm_items: List[MultimodalDataItem] + input_ids: Optional[List[int]] = None + padded_input_ids: Optional[List[int]] = None + + # image + im_token_id: Optional[int] = None + im_start_id: Optional[int] = None + im_end_id: Optional[int] = None + slice_start_id: Optional[int] = None + slice_end_id: Optional[int] = None + + # video + video_token_id: Optional[int] = None + + # audio + audio_token_id: Optional[int] = None + audio_start_id: Optional[int] = None + audio_end_id: Optional[int] = None + + # QWen2-VL related + mrope_positions: Optional[torch.Tensor] = None + mrope_position_delta: Optional[torch.Tensor] = None + + # Moss-VL related + vision_position_ids: Optional[torch.Tensor] = None + media_nums_per_sample: Optional[List[int]] = None + visible_frame_counts: Optional[torch.Tensor] = None + + # for transformers-compatibility + token_type_ids: Optional[torch.Tensor] = None + + @staticmethod + def from_dict(d: dict) -> MultimodalProcessorOutput: + return MultimodalProcessorOutput( + mm_items=d["mm_items"], + input_ids=d.get("input_ids"), + padded_input_ids=d.get("padded_input_ids"), + im_token_id=d.get("im_token_id"), + im_start_id=d.get("im_start_id"), + im_end_id=d.get("im_end_id"), + slice_start_id=d.get("slice_start_id"), + slice_end_id=d.get("slice_end_id"), + video_token_id=d.get("video_token_id"), + audio_token_id=d.get("audio_token_id"), + audio_start_id=d.get("audio_start_id"), + audio_end_id=d.get("audio_end_id"), + mrope_positions=d.get("mrope_positions"), + mrope_position_delta=d.get("mrope_position_delta"), + vision_position_ids=d.get("vision_position_ids"), + media_nums_per_sample=d.get("media_nums_per_sample"), + visible_frame_counts=d.get("visible_frame_counts"), + ) + + @staticmethod + def build_padded_input_ids(input_ids, mm_items: List[MultimodalDataItem]): + """pad the input_ids with mm_items if it's not already padded""" + if input_ids is None or not mm_items: + return None + + for item in mm_items: + if item.pad_value is None or item.offsets is None: + return None + + if isinstance(input_ids, torch.Tensor): + padded_input_ids = input_ids.flatten().tolist() + else: + padded_input_ids = list(input_ids) + + for item in mm_items: + for start, end in item.offsets: + padded_input_ids[start : end + 1] = [item.pad_value] * (end - start + 1) + return padded_input_ids + + +@dataclasses.dataclass +class MultimodalInputs: + """The multimodal data related inputs.""" + + # items of data + mm_items: List[MultimodalDataItem] + padded_input_ids: Optional[List[int]] = None + image_pad_len: Optional[list] = None + num_image_tokens: Optional[int] = None + + # image + im_token_id: Optional[int] = None + im_start_id: Optional[int] = None + im_end_id: Optional[int] = None + slice_start_id: Optional[int] = None + slice_end_id: Optional[int] = None + + # video + video_token_id: Optional[int] = None + + # audio + audio_token_id: Optional[int] = None + audio_start_id: Optional[int] = None + audio_end_id: Optional[int] = None + + # QWen2-VL related + mrope_positions: Optional[torch.Tensor] = None + mrope_position_delta: Optional[torch.Tensor] = None + mrope_position_delta_repeated_cache: Optional[torch.Tensor] = None + + # Moss-VL related + vision_position_ids: Optional[torch.Tensor] = None + media_nums_per_sample: Optional[List[int]] = None + visible_frame_counts: Optional[torch.Tensor] = None + + def release_features(self): + """Release feature tensors to free GPU memory.""" + for item in self.mm_items: + item.feature = None + + @staticmethod + def from_processor_output(obj: MultimodalProcessorOutput): + mm_items = obj.mm_items + assert isinstance(mm_items, list) + mm_items = [item for item in mm_items if item.is_valid()] + + # try reconstructing from cuda-ipc + reconstruct_device = None + for mm_item in mm_items: + if ( + mm_item.has_cuda_ipc_proxy() + and not mm_item.can_defer_cuda_ipc_feature_reconstruction() + ): + if reconstruct_device is None: + reconstruct_device = torch.cuda.current_device() + mm_item.reconstruct(reconstruct_device) + + if envs.SGLANG_MM_BUFFER_SIZE_MB.get() > 0: + # Multi-modal feature hashing optimization: + # When SGLANG_MM_BUFFER_SIZE_MB > 0, we temporarily move feature tensors to GPU + # for faster hash computation, while avoiding OOM issues. + from sglang.srt.managers.mm_utils import ( + init_feature_buffer, + is_feature_buffer_initialized, + reset_buffer_offset, + try_add_to_buffer, + ) + + device = torch.cuda.current_device() if torch.cuda.is_available() else "cpu" + if not is_feature_buffer_initialized(): + init_feature_buffer(device) + reset_buffer_offset() + for item in mm_items: + if item.feature is not None: + if isinstance(item.feature, torch.Tensor): + item.feature = try_add_to_buffer(item.feature) + + for item in mm_items: + item.set_pad_value() + + if envs.SGLANG_MM_BUFFER_SIZE_MB.get() > 0: + for item in mm_items: + if item.feature is not None: + item.feature = item.feature.to("cpu", non_blocking=True) + + mm_inputs = MultimodalInputs( + mm_items=mm_items, + padded_input_ids=obj.padded_input_ids, + ) + optional_args = [ + "mrope_positions", + "mrope_position_delta", + "im_token_id", + "im_start_id", + "im_end_id", + "video_token_id", + "slice_start_id", + "slice_end_id", + "audio_start_id", + "audio_end_id", + "audio_token_id", + "vision_position_ids", + "media_nums_per_sample", + "visible_frame_counts", + ] + for arg in optional_args: + val = getattr(obj, arg, None) + if val is not None: + setattr(mm_inputs, arg, val) + + return mm_inputs + + def contains_image_inputs(self) -> bool: + return any(item.is_image() for item in self.mm_items) + + def contains_video_inputs(self) -> bool: + return any(item.is_video() for item in self.mm_items) + + def contains_audio_inputs(self) -> bool: + return any(item.is_audio() for item in self.mm_items) + + def contains_mm_input(self) -> bool: + return any(True for item in self.mm_items if item.is_valid()) + + def compute_mm_token_counts(self) -> Tuple[int, int, int]: + """Count prompt tokens consumed by each modality (image, audio, video). + + A modality's token count is the total span covered by its items' + offsets. Returns a (image_tokens, audio_tokens, video_tokens) tuple. + """ + image_tokens = audio_tokens = video_tokens = 0 + for item in self.mm_items: + if not item.offsets: + continue + num_tokens = sum(end - start + 1 for start, end in item.offsets) + if item.is_image(): + image_tokens += num_tokens + elif item.is_audio(): + audio_tokens += num_tokens + elif item.is_video(): + video_tokens += num_tokens + return image_tokens, audio_tokens, video_tokens + + def merge(self, other: MultimodalInputs): + """ + merge image inputs when requests are being merged + """ + + # args needed to be merged + optional_args = [ + "mm_items", + "image_pad_len", + ] + for arg in optional_args: + self_arg = getattr(self, arg, None) + if self_arg is not None: + setattr(self, arg, self_arg + getattr(other, arg)) + + mrope_positions = self.mrope_positions + if mrope_positions is not None: + if other.mrope_positions is None: + self.mrope_positions = mrope_positions + else: + self.mrope_positions = torch.cat( + [self.mrope_positions, other.mrope_positions], dim=1 + ) + + mrope_position_delta = self.mrope_position_delta + if mrope_position_delta is not None: + if other.mrope_position_delta is None: + self.mrope_position_delta = mrope_position_delta + else: + self.mrope_position_delta = torch.cat( + [self.mrope_position_delta, other.mrope_position_delta], dim=0 + ) + + for key, val in other.__dict__.items(): + if "_id" in key: + # set token_ids + if getattr(self, key, None) is None: + setattr(self, key, getattr(other, key, None)) + # other args would be kept intact + + +@dataclasses.dataclass(slots=True, kw_only=True) +class ReqLogprob: + top_logprobs_num: int + token_ids_logprob: Optional[List[int]] + input_token_logprobs_val: Optional[List[float]] = None + input_token_logprobs_idx: Optional[List[int]] = None + input_top_logprobs_val: Optional[List[List[float]]] = None + input_top_logprobs_idx: Optional[List[List[int]]] = None + # Flat replacements for the rows above (see + # build_flat_input_top_logprobs_arrays); when set, the nested rows are + # emptied and the arrays ship instead. + input_top_logprobs_val_flat: Optional[np.ndarray] = None + input_top_logprobs_idx_flat: Optional[np.ndarray] = None + input_top_logprobs_flat_null_prefix: Optional[int] = None + input_token_ids_logprobs_val: Optional[List[List[float]]] = None + input_token_ids_logprobs_idx: Optional[List[List[int]]] = None + output_token_logprobs_val: Optional[list] = None + output_token_logprobs_idx: Optional[list] = None + output_top_logprobs_val: Optional[list] = None + output_top_logprobs_idx: Optional[list] = None + # Can contain either lists or GPU tensors (delayed copy optimization for prefill-only scoring) + output_token_ids_logprobs_val: Optional[List[Union[List[float], torch.Tensor]]] = ( + None + ) + output_token_ids_logprobs_idx: Optional[list] = None + + +@dataclasses.dataclass(slots=True, kw_only=True) +class ReqKvInfo: + kv_allocated_len: int + # The length of KV that have been removed in swa cache. + # SWA KV cache eviction behavior differs by cache type: + # - Radix cache: KV in range [cache_protected_len, swa_evicted_seqlen) is freed manually in + # `ScheduleBatch.maybe_evict_swa`; KV in range [0, cache_protected_len) is freed during radix cache eviction. + # - Chunk cache: KV in range [0, swa_evicted_seqlen) is freed manually in `ScheduleBatch.maybe_evict_swa`. + swa_evicted_seqlen: int + + +class Req(ReqDllmMixin): + """The input and output status of a request.""" + + def __init__( + self, + rid: str, + origin_input_text: str, + origin_input_ids: array[int], + sampling_params: SamplingParams, + return_logprob: bool = False, + top_logprobs_num: int = 0, + dllm_config: Optional[DllmConfig] = None, + token_ids_logprob: List[int] = None, + return_sampling_mask: bool = False, + return_flat_raw_top_logprobs: bool = False, + stream: bool = False, + origin_input_ids_unpadded: Optional[array[int]] = None, + lora_id: Optional[str] = None, + input_embeds: Optional[List[List[float]]] = None, + positional_embed_overrides: Optional[PositionalEmbeds] = None, + token_type_ids: List[int] = None, + session: Optional[Session] = None, + custom_logit_processor: Optional[str] = None, + require_reasoning: bool = False, + return_hidden_states: ReturnHiddenStatesMode = False, + return_routed_experts: bool = False, + routed_experts_start_len: int = 0, + return_indexer_topk: bool = False, + eos_token_ids: Optional[Set[int]] = None, + bootstrap_host: Optional[str] = None, + bootstrap_port: Optional[int] = None, + bootstrap_room: Optional[int] = None, + disagg_mode: Optional[DisaggregationMode] = None, + routed_dp_rank: Optional[int] = None, + disagg_prefill_dp_rank: Optional[int] = None, + vocab_size: Optional[int] = None, + priority: Optional[int] = None, + metrics_collector: Optional[SchedulerMetricsCollector] = None, + extra_key: Optional[str] = None, + routing_key: Optional[str] = None, + dimensions: Optional[int] = None, + http_worker_ipc: Optional[str] = None, + time_stats: Optional[ + Union[APIServerReqTimeStats, DPControllerReqTimeStats] + ] = None, + return_pooled_hidden_states: bool = False, + multi_item_delimiter_indices: Optional[List[int]] = None, + session_id: Optional[str] = None, + cache_salt: Optional[str] = None, + ): + # Input and output info + self.rid = rid + self.origin_input_ids = origin_input_ids + self.origin_input_ids_unpadded = ( + origin_input_ids_unpadded + if origin_input_ids_unpadded + else self.origin_input_ids + ) # Before image padding + # Each decode stage's output ids. Append-only by contract: + # _refresh_fill_ids infers how many output tokens are already in + # full_untruncated_fill_ids from lengths alone, so in-place rewrites + # that preserve length would silently corrupt fill_ids. + self.output_ids = array("q") + # Full untruncated sequence: origin + output (+ DLLM mask block). + # Kept in sync by _refresh_fill_ids; admission only updates + # extend_range, never mutates this array's length. + self.full_untruncated_fill_ids = array("q") + self.extend_range: Optional[Range] = None + self.dllm_initialized: bool = False + + self.session = session + self.session_id = session_id + # Used by the session radix cache to reject registration after a close/reopen. + self.session_generation: Optional[int] = None + self.input_embeds = input_embeds + self.positional_embed_overrides = positional_embed_overrides + self.multi_item_delimiter_indices = multi_item_delimiter_indices + + # For req-level memory management + self.kv_committed_len = 0 + self.kv: Optional[ReqKvInfo] = None + + # for cross-encoder model + self.token_type_ids = token_type_ids + + # Tokens in [0, swa_evict_floor) are protected from SWA window eviction. + # This is used by prefill-aware SWA models such as Unlimited-OCR to keep prompt/image KV visible during decode. + self.swa_evict_floor: int = 0 + + # The index of the extend / decode batch + self.extend_batch_idx = 0 + self.decode_batch_idx = 0 + + # For multi-http worker + self.http_worker_ipc = http_worker_ipc + + # Require reasoning for the request + self.require_reasoning = require_reasoning + + # State indicating whether the reasoning phase has finished (only meaningful when require_reasoning is True) + self._is_reasoning_over = False + self.reasoning_tokens = 0 + self._think_end_matcher: Optional[TokenSequenceMatcher] = None + self._think_end_match_len = 0 + + # Sampling info + if isinstance(sampling_params.custom_params, dict): + sampling_params = copy.copy(sampling_params) + sampling_params.custom_params = sampling_params.custom_params | { + "__req__": self + } + self.sampling_params = sampling_params + self.custom_logit_processor = custom_logit_processor + self.return_hidden_states = return_hidden_states + self.return_hidden_states_mode = get_return_hidden_states_mode( + return_hidden_states + ) + + # Extra key for caller-defined request classification. + if lora_id is not None: + extra_key = ( + extra_key or "" + ) + lora_id # lora_id is concatenated to the extra key + + self.extra_key = extra_key + self.cache_salt = cache_salt or None + self.lora_id = lora_id + self.routing_key = routing_key + + # Memory pool info + self.req_pool_idx: Optional[int] = None + self.mamba_pool_idx: Optional[torch.Tensor] = None # shape (1) + self.mamba_ping_pong_track_buffer: Optional[torch.Tensor] = None # shape (2) + self.mamba_next_track_idx: Optional[int] = None # 0 or 1 + self.mamba_last_track_idx: Optional[int] = None # 0 or 1 + self.mamba_last_track_seqlen: Optional[int] = ( + None # seq len of the last cached mamba state + ) + # the branching point seqlen to track mamba state. If set, given by prefix match, + # it will be the tracked seqlen in the ping pong buffer for the right prefill pass. + self.mamba_branching_seqlen: Optional[int] = None + # Deferred COW: source mamba pool index from radix cache node (copy on forward stream) + self.mamba_cow_src_index: Optional[torch.Tensor] = None + # Deferred clear: newly allocated mamba slot needs zeroing on forward stream + self.mamba_needs_clear: bool = False + # Lazy extra buffer: skip radix cache insert when prealloc failed at + # boundary — the forward overwrites the only slot, corrupting the state. + self.mamba_lazy_is_insert: bool = True + + # Check finish + self.tokenizer = None + self.finished_reason: Optional[BaseFinishReason] = None + # finished position (in output_ids), used when checking stop conditions with speculative decoding + self.finished_len = None + # Whether this request has finished output + self.finished_output = None + # If we want to abort the request in the middle of the event loop, + # set to_finish instead of directly setting finished_reason. + # Note: We should never set finished_reason in the middle, the req will get filtered and never respond + self.to_finish: Optional[BaseFinishReason] = None + self.stream = stream + self.eos_token_ids = eos_token_ids + self.vocab_size = vocab_size + self.priority = priority + + # For incremental decoding + # ----- | --------- read_ids -------| + # ----- | surr_ids | + # xxxxx | xxxxxxxxxxx | xxxxxxxxxxx | + # ----- ^ ----------- ^ ----------- ^ + # ----- 1 ----------- 2 ----------- 3 + # 1: surr_offset + # 2: read_offset + # 3: last token + self.surr_offset = None # Surrounding offset to defeat the cleanup algorithm + self.read_offset = None + self.decoded_text = "" + + # For multimodal inputs + self.multimodal_inputs: Optional[MultimodalInputs] = None + # Pre-computed multimodal prompt token counts; populated on the prefill + # node and transferred to decode via the metadata buffer in disagg (PD) mode. + self.mm_image_tokens: int = 0 + self.mm_audio_tokens: int = 0 + self.mm_video_tokens: int = 0 + + # Prefix info + # The indices to kv cache for the shared prefix. + self.prefix_indices: torch.Tensor = torch.empty((0,), dtype=torch.int64) + # TODO(ispobock): rename to last_device_node + self.last_node: Any = None + self.last_host_node: Any = None + self.best_match_node: Any = None + # Per-component host hit lengths split off from host_hit_length: + self.host_hit_length = 0 + self.swa_host_hit_length = 0 + self.mamba_host_hit_length = 0 + # Total cached prefix length (on-device prefix_indices + host_hit_length), + # capped at the max allowed prefix. Set during prefix matching at schedule + # time and used to estimate uncached tokens / sort by longest prefix for + # load reporting. + self.num_matched_prefix_tokens = 0 + # Tokens loaded from storage backend (L3) during prefetch for this request + self.storage_hit_length = 0 + # The node to lock until for swa radix tree lock ref + self.swa_uuid_for_lock: Optional[int] = None + # Whether the prefill-time SWA tree lock has been released early + self.swa_prefix_lock_released: bool = False + # per-component nodes this req skipped locking (e.g. mamba on the decode + # hold, already COW'd), so their dec releases only what it took. + self.skip_lock_node_ids: dict = {} + # The prefix length that is inserted into the tree cache + self.cache_protected_len: int = 0 + + # Whether or not if it is chunked. It increments whenever + # it is chunked, and decrement whenever chunked request is + # processed. + self.inflight_middle_chunks = 0 + + # For retraction + self.is_retracted = False + # Indicates if the req has ever been retracted. + self.retracted_stain = False + + # Incremental streamining + self.send_token_offset: int = 0 + self.send_decode_id_offset: int = 0 + # TODO (Byron): send_output_token_logprobs_offset and send_decode_id_offset can be different in disaggregation mode + # because the decode server does not have the first output token logprobs + self.send_output_token_logprobs_offset: int = 0 + self.send_output_sampling_mask_offset: int = 0 + + # Logprobs (arguments) + self.return_logprob = return_logprob + # Start index to compute logprob from. + self.logprob_start_len = 0 + self.logprob = ReqLogprob( + top_logprobs_num=top_logprobs_num, + token_ids_logprob=token_ids_logprob, + ) + self.temp_scaled_logprobs = False + self.top_p_normalized_logprobs = False + self.return_sampling_mask = return_sampling_mask + self.return_flat_raw_top_logprobs = return_flat_raw_top_logprobs + + # Logprobs (return values) + # True means the input logprob has been already sent to detokenizer. + self.input_logprob_sent: bool = False + # Temporary holder to store input_token_logprobs. + self.input_token_logprobs: Optional[List[Tuple[int]]] = None + self.temp_input_top_logprobs_val: Optional[List[torch.Tensor]] = None + self.temp_input_top_logprobs_idx: Optional[List[int]] = None + self.temp_input_token_ids_logprobs_val: Optional[List[float]] = None + self.temp_input_token_ids_logprobs_idx: Optional[List[int]] = None + + if return_logprob: + # shape: (bs, 1) + self.logprob.output_token_logprobs_val = [] + self.logprob.output_token_logprobs_idx = [] + # shape: (bs, k) + self.logprob.output_top_logprobs_val = [] + self.logprob.output_top_logprobs_idx = [] + # Can contain either lists or GPU tensors (delayed copy optimization for prefill-only scoring) + self.logprob.output_token_ids_logprobs_val = [] + self.logprob.output_token_ids_logprobs_idx = [] + if return_sampling_mask: + self.output_token_sampling_mask = [] + self.output_token_sampling_logprobs = [] + else: + self.output_token_sampling_mask = None + self.output_token_sampling_logprobs = None + self.hidden_states: List[List[float]] = [] + self.hidden_states_tensor = None # Note: use tensor instead of list to transfer hidden_states when PD + MTP + self.output_topk_p = None + self.output_topk_index = None + self.output_dsa_topk_indices = None + + # capture routed experts + self.return_routed_experts = return_routed_experts + self.routed_experts_start_len = routed_experts_start_len + self.routed_experts: Optional[torch.Tensor] = ( + None # cpu tensor: shape (seqlen, topk) + ) + + self.return_indexer_topk = return_indexer_topk + self.indexer_topk: Optional[torch.Tensor] = ( + None # cpu tensor: shape (seqlen, num_indexer_layers, index_topk) + ) + # Customized info + self.customized_info: Optional[Dict[str, List[Any]]] = None + + # Embedding (return values) + self.embedding = None + + # Constrained decoding + self.grammar_key: Optional[Tuple[str, str]] = None + self.grammar: Optional[Union[BaseGrammarObject, Future[BaseGrammarObject]]] = ( + None + ) + self.grammar_wait_ct = 0 + + # The number of cached tokens that were already cached in the KV cache + self.cached_tokens = 0 + self.already_computed = 0 + + # Detailed breakdown of cached tokens by source (for HiCache) + self.cached_tokens_device = 0 # Tokens from device cache (GPU) + self.cached_tokens_host = 0 # Tokens from host cache (CPU memory) + self.cached_tokens_storage = 0 # Tokens from L3 storage backend + self._cache_breakdown_computed = ( + False # Track if breakdown was already computed + ) + + # Per-request count of verification forward passes. + self.spec_verify_ct = 0 + + # Per-request count of accepted draft tokens (excludes the bonus token). + self.spec_num_correct_drafts = 0 + + self.spec_num_block_accept_tokens = 0 + + self.spec_num_cap_tokens = 0 + + # Acceptance histogram for speculative decoding. + # List index = number of accepted tokens in a step, List value = count of steps with that many accepted tokens. + # Example: histogram[0] = 5 means 5 steps with 0 accepted tokens, histogram[3] = 10 means 10 steps with 3 accepted tokens. + self.spec_correct_drafts_histogram: List[int] = [] + + self.spec_cap_lens_histogram: List[int] = [] + + # The number of times this request has been retracted / preempted. + self.retraction_count = 0 + self.retraction_mb_id = None + + # For observability + self.metrics_collector = metrics_collector + if time_stats is not None: + self.time_stats = SchedulerReqTimeStats.new_from_obj(time_stats) + else: + self.time_stats = SchedulerReqTimeStats(disagg_mode=disagg_mode) + self.time_stats.set_metrics_collector(metrics_collector) + self.time_stats.set_scheduler_recv_time() + self.has_log_time_stats: bool = False + + # For disaggregation + self.bootstrap_host: str = bootstrap_host + self.bootstrap_port: Optional[int] = bootstrap_port + self.bootstrap_room: Optional[int] = bootstrap_room + # Decode-local: the already-emitted boundary token to replay when a + # retracted request is rebootstrapped. Set in pause_generation(retract) + # and consumed in the decode transfer commit; never plumbed to prefill. + self.pd_rebootstrap_forced_output_id: Optional[int] = None + self.skip_radix_cache_insert = bootstrap_host == FAKE_BOOTSTRAP_HOST + self.disagg_kv_sender: Optional[BaseKVSender] = None + + self.routed_dp_rank: Optional[int] = routed_dp_rank + self.disagg_prefill_dp_rank: Optional[int] = disagg_prefill_dp_rank + + # the start index of the sent kv cache + # We want to send it chunk by chunk for chunked prefill. + # After every chunk forward, we do the following: + # kv_send(req.input_ids[req.start_send_idx:req.extend_range.end]) + # start_send_idx = req.extend_range.end + self.start_send_idx: int = 0 + + # For overlap schedule, we delay the kv transfer until `process_batch_result_disagg_prefill` rather than `process_prefill_chunk` in non-overlap + # This is because kv is not ready in `process_prefill_chunk`. + # We use `tmp_end_idx` to store the end index of the kv cache to send. + self.tmp_end_idx: int = -1 + # Decode-side cached-prefix length; base of the staging chunk grid + # (start_send_idx starts here but advances with every send). + self.disagg_decode_prefix_len: int = 0 + # At-rest device-resident prefix end, snapshotted on the request's + # first prefill batch; the cached-prefix early-send never goes past it. + self.early_send_prefix_end: Optional[int] = None + self.metadata_buffer_index: int = -1 + # Used in overlap sequence to signal that an optimistic request should + # abort chunking. Set in create_sender, consumed in process_batch_result. + self.pending_bootstrap = False + # Number of optimistic prefill forward passes started. preserved across retracts. + self.prefill_attempt_count = 0 + + # For Matryoshka embeddings + self.dimensions = dimensions + + # Whether to return pooled hidden states (pre-head transformer output) + self.return_pooled_hidden_states = return_pooled_hidden_states + self.pooled_hidden_state = None + + # For diffusion LLM + self.init_diffusion_llm(dllm_config) + + # For hisparse + self.hisparse_staging = False + + @property + def seqlen(self) -> int: + """Get the current sequence length of the request.""" + return len(self.origin_input_ids) + len(self.output_ids) + + @property + def is_prefill_only(self) -> bool: + """Check if this request is prefill-only (no token generation needed).""" + # NOTE: when spec is enabled, prefill_only optimizations are disabled + + spec_alg = get_spec().speculative_algorithm + return self.sampling_params.max_new_tokens == 0 and spec_alg is None + + @property + def output_ids_through_stop(self) -> array[int]: + """Get the output ids through the stop condition. Stop position is included.""" + if self.finished_len is not None: + return self.output_ids[: self.finished_len] + return self.output_ids + + def needs_host_load_back(self) -> bool: + """Whether any cache layer has a host hit that needs L2 H2D load_back.""" + return ( + self.host_hit_length > 0 + or self.swa_host_hit_length > 0 + or self.mamba_host_hit_length > 0 + ) + + def effective_kv_committed_len(self) -> int: + # Report only the prompt prefix so thinking + answer fall into the + # overallocated range and are reclaimed by release_kv_cache. #22373. + if get_serving().strip_thinking_cache and self.reasoning_tokens > 0: + return min(self.kv_committed_len, len(self.origin_input_ids)) + return self.kv_committed_len + + def update_spec_correct_drafts_histogram(self, num_correct_drafts: int): + """Update the speculative decoding acceptance histogram. + + Args: + num_correct_drafts: Number of correct draft tokens (no bonus) in this step. + """ + if len(self.spec_correct_drafts_histogram) <= num_correct_drafts: + self.spec_correct_drafts_histogram.extend( + [0] * (num_correct_drafts - len(self.spec_correct_drafts_histogram) + 1) + ) + self.spec_correct_drafts_histogram[num_correct_drafts] += 1 + + def update_spec_cap_lens_histogram(self, cap_len: int): + cap_len = int(cap_len) + if len(self.spec_cap_lens_histogram) <= cap_len: + self.spec_cap_lens_histogram.extend( + [0] * (cap_len - len(self.spec_cap_lens_histogram) + 1) + ) + self.spec_cap_lens_histogram[cap_len] += 1 + + def extend_image_inputs(self, image_inputs): + if self.multimodal_inputs is None: + self.multimodal_inputs = image_inputs + else: + self.multimodal_inputs.merge(image_inputs) + + def finished(self) -> bool: + # Whether request reached finished condition + return self.finished_reason is not None + + def set_extend_range(self, start: int, end: int) -> None: + self.extend_range = Range(start, end) + + def get_fill_ids(self) -> array: + return self.full_untruncated_fill_ids[: self.extend_range.end] + + def _refresh_fill_ids(self) -> None: + """Keep full_untruncated_fill_ids == origin_input_ids + output_ids by + appending only the new output tokens. + + Falls back to a full rebuild when the in-place append is invalid: + - aliasing: scheduler_pp_mixin assigns full_untruncated_fill_ids = + origin_input_ids directly, so extending in place would write output + tokens into the origin; + - lengths disagree: fresh req (array still empty), retraction + (output_ids reset to empty), or set_finish_with_abort (origin + replaced by a 1-token stub). + """ + n_have_output = len(self.full_untruncated_fill_ids) - len(self.origin_input_ids) + if ( + self.full_untruncated_fill_ids is not self.origin_input_ids + and 0 <= n_have_output <= len(self.output_ids) + ): + self.full_untruncated_fill_ids.extend(self.output_ids[n_have_output:]) + else: + self.full_untruncated_fill_ids = self.origin_input_ids + self.output_ids + + def init_next_round_input( + self, + tree_cache: Optional[BasePrefixCache] = None, + cow_mamba: Optional[bool] = None, + ): + if self.is_dllm(): + self._init_fill_ids_for_dllm() + self.determine_dllm_phase() + else: + self._refresh_fill_ids() + + input_len = len(self.full_untruncated_fill_ids) + + # Streaming sessions reuse committed KV from the session slot, so + # custom logprob_start_len is not supported — override to -1. + if ( + self.session is not None + and self.session.streaming + and self.return_logprob + and self.logprob_start_len >= 0 + ): + logger.warning( + "logprob_start_len=%d is not supported for streaming sessions " + "and will be ignored (rid=%s). Only new-token logprobs are returned.", + self.logprob_start_len, + self.rid, + ) + self.logprob_start_len = -1 + + # Pass the full array with a raw-token cap (limit) instead of slicing, + # avoiding an O(context) copy per prefill-batch build. + token_ids_to_match = self.full_untruncated_fill_ids + key_limit: Optional[int] = self._compute_max_prefix_len(input_len) + + # SWA lives in a per-request ring that's not content-stable and is never + # stored in the radix tree, so a reused prefix carries stale SWA. Cap the + # match by the trailing sliding window so it gets re-prefilled, rewriting + # this request's SWA ring. No-op for other layouts. + if tree_cache is not None: + reprefill_tail = tree_cache.swa_reprefill_tail_tokens() + if reprefill_tail: + capped = max(0, input_len - reprefill_tail) + key_limit = capped if key_limit is None else min(key_limit, capped) + + # Disable prefix caching when embed overrides are present: same token IDs + # with different override vectors must not share cached KV values. + if self.positional_embed_overrides is not None: + token_ids_to_match = array("q") + key_limit = None + + if tree_cache is not None: + if cow_mamba is None: + cow_mamba = tree_cache.supports_mamba() + # unified_kv SWA lives in a per-request ring that is not content-stable + # and never cached in the radix tree, so a reused prefix carries stale + # SWA. Cap the match by the trailing sliding window so it is re-prefilled + # into this request's ring. No-op for other layouts (returns 0). + reprefill_tail = tree_cache.swa_reprefill_tail_tokens() + if reprefill_tail: + capped = max(0, input_len - reprefill_tail) + key_limit = capped if key_limit is None else min(key_limit, capped) + match_result = tree_cache.match_prefix( + MatchPrefixParams( + key=RadixKey( + token_ids=token_ids_to_match, + extra_key=self.extra_key, + limit=key_limit, + cache_salt=self.cache_salt, + ), + req=self, + cow_mamba=cow_mamba, + ) + ) + if envs.SGLANG_RADIX_FORCE_MISS.get(): + match_result = zero_match_result( + tree_cache, match_result, extra_key=self.extra_key + ) + ( + self.prefix_indices, + self.last_node, + self.last_host_node, + self.best_match_node, + self.host_hit_length, + self.swa_host_hit_length, + self.mamba_host_hit_length, + self.mamba_branching_seqlen, + ) = ( + match_result.device_indices, + match_result.last_device_node, + match_result.last_host_node, + match_result.best_match_node, + match_result.host_hit_length, + match_result.swa_host_hit_length, + match_result.mamba_host_hit_length, + match_result.mamba_branching_seqlen, + ) + if match_result.cache_protected_len is not None: + self.cache_protected_len = match_result.cache_protected_len + else: + self.cache_protected_len = len(self.prefix_indices) + + if self.is_dllm(): + self._update_block_offset_for_dllm() + + if ( + self.is_retracted + and self.multimodal_inputs is not None + and self.multimodal_inputs.mrope_positions is not None + ): + from sglang.srt.managers.mm_utils import ( + extend_mrope_positions_for_retracted_request, + ) + + self.multimodal_inputs.mrope_positions = ( + extend_mrope_positions_for_retracted_request( + self.multimodal_inputs.mrope_positions, len(self.output_ids) + ) + ) + + def _compute_max_prefix_len(self, input_len: int) -> int: + # NOTE: the matched length is at most 1 less than the input length to enable logprob computation + max_prefix_len = input_len - 1 + if self.return_logprob and self.logprob_start_len >= 0: + max_prefix_len = min(max_prefix_len, self.logprob_start_len) + return max(max_prefix_len, 0) + + # Based on https://github.com/vllm-project/vllm/blob/7a64d24aad69e4d2548aa0bf528d9fe63428ab01/vllm/transformers_utils/detokenizer.py#L194-L313 + def init_incremental_detokenize(self): + first_iter = self.surr_offset is None or self.read_offset is None + + output_ids = self.output_ids_through_stop + + if first_iter: + self.read_offset = len(self.origin_input_ids_unpadded) + self.surr_offset = max( + self.read_offset - INIT_INCREMENTAL_DETOKENIZATION_OFFSET, 0 + ) + self.surr_and_decode_ids = ( + self.origin_input_ids_unpadded[self.surr_offset :] + output_ids + ) + self.cur_decode_ids_len = len(output_ids) + else: + self.surr_and_decode_ids.extend(output_ids[self.cur_decode_ids_len :]) + self.cur_decode_ids_len = len(output_ids) + + return self.surr_and_decode_ids, self.read_offset - self.surr_offset + + def _stop_match_tail_len(self, new_accepted_len: int) -> int: + max_len_tail_str = max( + self.sampling_params.stop_str_max_len + 1, + self.sampling_params.stop_regex_max_len + 1, + ) + # Cover all newly accepted tokens so an early stop string is not missed + # when speculative decoding accepts multiple tokens per step. + return min( + max_len_tail_str + max(new_accepted_len - 1, 0), len(self.output_ids) + ) + + def tail_str(self, new_accepted_len: int = 1) -> str: + # Check stop strings and stop regex patterns together + if ( + len(self.sampling_params.stop_strs) == 0 + and len(self.sampling_params.stop_regex_strs) == 0 + ): + return "" + + tail_len = self._stop_match_tail_len(new_accepted_len) + return self.tokenizer.decode(self.output_ids[-tail_len:]) + + def check_match_stop_str_prefix(self) -> bool: + """ + Check if the suffix of tail_str overlaps with any stop_str prefix + """ + if not self.sampling_params.stop_strs: + return False + + tail_str = self.tail_str() + + # Early return if tail_str is empty + if not tail_str: + return False + + for stop_str in self.sampling_params.stop_strs: + if not stop_str: + continue + # Check if stop_str is contained in tail_str (fastest check first) + if stop_str in tail_str: + return True + + # Check if tail_str suffix matches stop_str prefix + # Only check if stop_str is not empty, it's for stream output + min_len = min(len(tail_str), len(stop_str)) + for i in range(1, min_len + 1): + if tail_str[-i:] == stop_str[:i]: + return True + + return False + + def _check_token_based_finish(self, new_accepted_tokens: List[int]) -> bool: + if self.sampling_params.ignore_eos: + return False + + # Check stop token ids + matched_eos = False + + for i, token_id in enumerate(new_accepted_tokens): + if self.sampling_params.stop_token_ids: + matched_eos |= token_id in self.sampling_params.stop_token_ids + if self.eos_token_ids: + matched_eos |= token_id in self.eos_token_ids + if self.tokenizer is not None: + matched_eos |= token_id == self.tokenizer.eos_token_id + if self.tokenizer.additional_stop_token_ids: + matched_eos |= token_id in self.tokenizer.additional_stop_token_ids + if matched_eos: + self.finished_reason = FINISH_MATCHED_TOKEN(matched=token_id) + matched_pos = len(self.output_ids) - len(new_accepted_tokens) + i + self.finished_len = matched_pos + 1 + return True + + return False + + def _locate_str_stop_finished_len( + self, + new_accepted_len: int, + *, + stop_str: Optional[str] = None, + stop_regex: Optional[str] = None, + ) -> int: + """Map a matched stop string/regex to output_ids length (stop included).""" + + def matched(text: str) -> bool: + if stop_str is not None: + return stop_str in text + return re.search(stop_regex, text) is not None + + tail_len = self._stop_match_tail_len(new_accepted_len) + start = len(self.output_ids) - tail_len + token_window = self.output_ids[start:] + + # Old prefixes were checked in the previous step. + for token_count in range( + max(1, len(token_window) - new_accepted_len + 1), len(token_window) + ): + if matched(self.tokenizer.decode(token_window[:token_count])): + return start + token_count + + # The full tail window is already known to match by the caller. + return len(self.output_ids) + + def _check_str_based_finish(self, new_accepted_len: int = 1): + if ( + len(self.sampling_params.stop_strs) > 0 + or len(self.sampling_params.stop_regex_strs) > 0 + ): + tail_str = self.tail_str(new_accepted_len) + + # Check stop strings + if len(self.sampling_params.stop_strs) > 0: + for stop_str in self.sampling_params.stop_strs: + stop_str_in_tail = stop_str in tail_str + if stop_str_in_tail or stop_str in self.decoded_text: + self.finished_reason = FINISH_MATCHED_STR(matched=stop_str) + if stop_str_in_tail: + self.finished_len = self._locate_str_stop_finished_len( + new_accepted_len, stop_str=stop_str + ) + return True + + # Check stop regex + if len(self.sampling_params.stop_regex_strs) > 0: + for stop_regex_str in self.sampling_params.stop_regex_strs: + # Seatbelt, not validation: patterns are checked at ingress + # (Python's `normalize`, or the rust server's stricter + # `stop_regex_bound`). This runs per decode step on the hot + # path, so an `re.error` escaping here would take the whole + # scheduler down over one malformed request. Fail that request + # instead. + try: + matched = re.search(stop_regex_str, tail_str) + except (re.error, RecursionError) as e: + logger.warning( + "req %s: invalid stop_regex %r (%s); aborting the request", + self.rid, + stop_regex_str, + e, + ) + self.finished_reason = FINISH_ABORT( + f"invalid stop_regex {stop_regex_str!r}: {e}", + HTTPStatus.BAD_REQUEST, + "BadRequestError", + ) + break + if matched: + self.finished_reason = FINISHED_MATCHED_REGEX( + matched=stop_regex_str + ) + self.finished_len = self._locate_str_stop_finished_len( + new_accepted_len, stop_regex=stop_regex_str + ) + return True + + return False + + def _check_vocab_boundary_finish(self, new_accepted_tokens: List[int] = None): + for i, token_id in enumerate(new_accepted_tokens): + if token_id < 0 or ( + self.vocab_size is not None and token_id >= self.vocab_size + ): + offset = len(self.output_ids) - len(new_accepted_tokens) + i + if self.sampling_params.stop_token_ids: + self.output_ids[offset] = next( + iter(self.sampling_params.stop_token_ids) + ) + if self.eos_token_ids: + self.output_ids[offset] = next(iter(self.eos_token_ids)) + self.finished_reason = FINISH_ABORT( + "Generation produced an invalid token ID.", + status_code=HTTPStatus.INTERNAL_SERVER_ERROR, + err_type="InvalidTokenError", + ) + # Never emit the faulty token or let a speculative overrun hide + # the engine failure behind an ordinary length finish. + self.finished_len = min(offset, self.sampling_params.max_new_tokens) + return True + + return False + + def _cap_finished_len_at_max_new_tokens(self) -> None: + """Demote a stop matched beyond the length budget to a length finish. + + Speculative decoding can accept a run that both crosses + ``max_new_tokens`` and contains a stop; a stop located past the cap + must not extend the emitted output beyond the cap. + """ + max_new_tokens = self.sampling_params.max_new_tokens + if self.finished_len is not None and self.finished_len > max_new_tokens: + self.finished_reason = FINISH_LENGTH(length=max_new_tokens) + self.finished_len = max_new_tokens + + def update_finish_state(self, new_accepted_len: int = 1): + if self.finished(): + return + + if self.to_finish: + self.finished_reason = self.to_finish + self.to_finish = None + return + + new_accepted_tokens = self.output_ids[-new_accepted_len:] + + # Reject out-of-range token IDs before any decode. + if self._check_vocab_boundary_finish(new_accepted_tokens): + return + + # Stop string beats EOS/stop-token matched in the same step (speculative + # decoding can accept >1 token): token-based would trim only the last + # token and leak the stop string. + if self._check_str_based_finish(new_accepted_len): + self._cap_finished_len_at_max_new_tokens() + return + + # Stop token/EOS beats the length cap for the same reason: a spec accept + # run can cross max_new_tokens in the very step the EOS lands, and a + # length-first finish would keep the over-accepted tokens after the EOS + # (up to the cap) in the emitted output. + if self._check_token_based_finish(new_accepted_tokens): + self._cap_finished_len_at_max_new_tokens() + return + + if len(self.output_ids) >= self.sampling_params.max_new_tokens: + self.finished_reason = FINISH_LENGTH( + length=self.sampling_params.max_new_tokens + ) + self.finished_len = self.sampling_params.max_new_tokens + return + + if self.grammar is not None and self.grammar.is_terminated(): + self.finished_reason = FINISH_MATCHED_TOKEN(matched=self.output_ids[-1]) + return + + def reset_for_retract(self): + # Increment retraction count before resetting other state. We should not reset this + # since we are tracking the total number of retractions for each request. + self.retraction_count += 1 + + self.prefix_indices = torch.empty((0,), dtype=torch.int64) + self.routed_experts = None + self.indexer_topk = None + self.last_node = None + self.cache_protected_len = 0 + self.num_matched_prefix_tokens = 0 + self.swa_uuid_for_lock = None + self.swa_prefix_lock_released = False + self.skip_lock_node_ids = {} + self.extend_range = None + self.dllm_initialized = False + self.is_retracted = True + self.retracted_stain = True + self.input_token_logprobs = None + self.temp_input_top_logprobs_val = None + self.temp_input_top_logprobs_idx = None + self.temp_input_token_ids_logprobs_val = None + self.temp_input_token_ids_logprobs_idx = None + self.inflight_middle_chunks = 0 + self.mamba_pool_idx = None + self.mamba_ping_pong_track_buffer = None + self.mamba_next_track_idx = None + self.mamba_last_track_idx = None + self.mamba_last_track_seqlen = None + self.mamba_branching_seqlen = None + self.mamba_cow_src_index = None + self.mamba_needs_clear = False + self.already_computed = 0 + assert self.kv is None, "expect it is already released" + self.kv_committed_len = 0 + self.extend_batch_idx = 0 + self.decode_batch_idx = 0 + + # When using input_embeds, we cannot easily mix the original input embeddings + # with the newly generated output token IDs during re-prefill of retracted request. + # output_ids will have no use, but will lead to wrong size cache indexes. + # Therefore, we discard the generated output_ids and restart prefill and generation + # to ensure shape consistency in KV cache. + if self.input_embeds is not None: + self.output_ids = array("q") + + def offload_kv_cache(self, req_to_token_pool, token_to_kv_pool_allocator): + token_indices = req_to_token_pool.req_to_token[ + self.req_pool_idx, : self.seqlen - 1 + ] + # Copies over both the kv cache and mamba state if available + self.kv_cache_cpu = token_to_kv_pool_allocator.get_cpu_copy( + token_indices, mamba_indices=self.mamba_pool_idx + ) + + def load_kv_cache(self, req_to_token_pool, token_to_kv_pool_allocator): + token_indices = req_to_token_pool.req_to_token[ + self.req_pool_idx, : self.seqlen - 1 + ] + # Loads both the kv cache and mamba state if exists + token_to_kv_pool_allocator.load_cpu_copy( + self.kv_cache_cpu, token_indices, mamba_indices=self.mamba_pool_idx + ) + del self.kv_cache_cpu + + def build_rebootstrap_payload(self) -> dict: + """Build the prefill ``/generate`` payload that asks the original prefill + worker to recompute this request's prefix KV under the current weights + (PD true-retraction rebootstrap). + + ``input_ids`` are coerced to plain ``int`` so the payload is always + JSON-serializable even when ``origin_input_ids``/``output_ids`` hold + numpy scalars. The sampling-param allow-list forces ``max_new_tokens=1`` + and drops stop/grammar/min_new_tokens so the recompute only re-derives + the prefix KV and samples a single handoff token. The already-emitted + boundary token is replayed on the *decode* side (the transfer commit + overrides the sampled handoff with it), so it is intentionally not sent + to the prefill here. + """ + # TODO: multi-modal requests are not supported here. The payload only + # carries token ``input_ids`` and drops any image/audio/video inputs, so + # the rebootstrap recompute would not reproduce the original prefix KV + # for multi-modal requests. Add multi-modal support before enabling it. + sp = self.sampling_params + return { + "input_ids": [int(x) for x in self.origin_input_ids] + + [int(x) for x in self.output_ids], + "sampling_params": { + "max_new_tokens": 1, + "temperature": sp.temperature, + "top_p": sp.top_p, + "top_k": sp.top_k, + "min_p": sp.min_p, + "frequency_penalty": sp.frequency_penalty, + "presence_penalty": sp.presence_penalty, + "repetition_penalty": sp.repetition_penalty, + "ignore_eos": sp.ignore_eos, + "skip_special_tokens": sp.skip_special_tokens, + "spaces_between_special_tokens": sp.spaces_between_special_tokens, + "no_stop_trim": sp.no_stop_trim, + }, + "return_logprob": False, + "stream": False, + "rid": self.rid, + "bootstrap_host": self.bootstrap_host, + "bootstrap_port": self.bootstrap_port, + "bootstrap_room": self.bootstrap_room, + "priority": self.priority, + "extra_key": self.extra_key, + "cache_salt": self.cache_salt, + "routing_key": self.routing_key, + "disagg_prefill_dp_rank": self.disagg_prefill_dp_rank, + } + + def log_time_stats(self): + # If overlap schedule, we schedule one decode batch ahead so this gets called twice. + if self.has_log_time_stats: + return + + bootstrap_info = ( + f", bootstrap_room={self.bootstrap_room}" + if self.bootstrap_room is not None + else "" + ) + prefix = ( + f"ReqTimeStats(" + f"rid={self.rid}{bootstrap_info}, " + f"input_len={len(self.origin_input_ids)}, " + f"cached_input_len={self.cached_tokens}, " + f"output_len={len(self.output_ids)}, " + f"attempts={self.prefill_attempt_count}, " + f"type={self.time_stats.disagg_mode_str()})" + ) + logger.info(f"{prefix}: {self.time_stats.convert_to_duration()}") + self.has_log_time_stats = True + + def set_finish_with_abort(self, error_msg: str): + if get_parallel().tp_rank == 0: + logger.error(f"{error_msg}, {self.rid=}") + self.multimodal_inputs = None + self.grammar = None + self.origin_input_ids = array( + "q", [0] + ) # set it to one token to skip the long prefill + self.return_logprob = False + self.logprob_start_len = -1 + self.to_finish = FINISH_ABORT( + error_msg, HTTPStatus.BAD_REQUEST, "BadRequestError" + ) + + def update_reasoning_tokens(self, token_id, think_end_ids): + if self._is_reasoning_over: + return + + if not isinstance(token_id, list): + token_id = [token_id] + + if self._think_end_matcher is None: + self._think_end_matcher = TokenSequenceMatcher(think_end_ids) + + matched = self._think_end_match_len + for position, token in enumerate(token_id): + matched = self._think_end_matcher.advance(matched, token) + if matched == len(self._think_end_matcher): + self.reasoning_tokens += position + 1 + self._is_reasoning_over = True + return + + self._think_end_match_len = matched + self.reasoning_tokens += len(token_id) + + def __repr__(self): + return ( + f"Req(rid={self.rid}, " + f"input_ids={self.origin_input_ids}, output_ids={self.output_ids}, " + f"{self.grammar=}, " + f"{self.sampling_params=})" + ) + + +class _MambaRadixCacheV2TrackEntry(NamedTuple): + track_mask: bool + track_index: int + track_seqlen: int + + +def mamba_lazy_spec_in_window( + req, mamba_track_interval: int, max_draft_tokens: int +) -> bool: + """Whether a track-interval crossing is reachable by an in-flight verify. + + kv_committed_len lags device seq_lens by up to one verify under overlap; + the 2x window absorbs it. + """ + seq_len = req.kv_committed_len + window = 2 * max_draft_tokens + return seq_len // mamba_track_interval != (seq_len + window) // mamba_track_interval + + +def set_mamba_track_indices_from_reqs( + batch, track_positions: Optional[List[int]] = None +): + """Build mamba_track_indices from req objects (authoritative source). + + track_positions: optional per-req ping-pong position override (the lazy + spec track plan, see mamba_lazy_spec_prepare). + """ + req_to_token_pool = batch.req_to_token_pool + all_buffers = req_to_token_pool.req_index_to_mamba_ping_pong_track_buffer_mapping[ + batch.req_pool_indices + ] # (bs, ping_pong_size), int64, on device + if track_positions is None: + # Guard: mamba_next_track_idx may be None for requests that haven't + # gone through _alloc_ping_pong_buffer yet (e.g., spec v2 verify path). + # Default to 0 (first ping-pong slot) to avoid TypeError. + track_positions = [ + req.mamba_next_track_idx if req.mamba_next_track_idx is not None else 0 + for req in batch.reqs + ] + batch.mamba_track_buffer_indices = list(track_positions) + idx = ( + torch.tensor( + track_positions, + dtype=torch.int64, + pin_memory=True, + ) + .unsqueeze(1) + .to(device=all_buffers.device, non_blocking=True) + ) + batch.mamba_track_indices = ( + torch.gather(all_buffers, 1, idx).squeeze(1).to(torch.int64) + ) + + +def release_req( + *, + req: Req, + remaing_req_count: int, + server_args: ServerArgs, + req_to_token_pool: ReqToTokenPool, + token_to_kv_pool_allocator: BaseTokenToKVPoolAllocator, + tree_cache: BasePrefixCache, + hisparse_coordinator: Optional[HiSparseCoordinator], + offload_kv: bool = True, +) -> None: + if hisparse_coordinator is not None and not req.finished(): + hisparse_coordinator.retract_req(req) + + # In decode disaggregation the retracted KV is offloaded to host so it can be + # restored later without recompute (see resume_retracted_reqs/load_kv_cache). + # Callers that will recompute the KV instead (PD true-retraction rebootstrap) + # pass offload_kv=False to skip the wasteful device->host copy. + if server_args.disaggregation_mode == "decode" and offload_kv: + req.offload_kv_cache(req_to_token_pool, token_to_kv_pool_allocator) + # TODO (csy): for preempted requests, we may want to insert into the tree + release_kv_cache(req, tree_cache, is_insert=False) + # NOTE(lsyin): we should use the newly evictable memory instantly. + num_tokens = remaing_req_count * envs.SGLANG_RETRACT_DECODE_STEPS.get() + evict_from_tree_cache(tree_cache, num_tokens) + + req.reset_for_retract() + + +def retract_all( + *, + reqs: List[Req], + server_args: ServerArgs, + req_to_token_pool: ReqToTokenPool, + token_to_kv_pool_allocator: BaseTokenToKVPoolAllocator, + tree_cache: BasePrefixCache, + hisparse_coordinator: Optional[HiSparseCoordinator], + offload_kv: bool = True, +) -> None: + for idx in range(len(reqs)): + release_req( + req=reqs[idx], + remaing_req_count=len(reqs) - idx, + server_args=server_args, + req_to_token_pool=req_to_token_pool, + token_to_kv_pool_allocator=token_to_kv_pool_allocator, + tree_cache=tree_cache, + hisparse_coordinator=hisparse_coordinator, + offload_kv=offload_kv, + ) + + +def compute_extend_logprob_start_len( + *, + logprob_start_len: int, + prefix_len: int, + extend_len: int, + full_untruncated_fill_len: int, +) -> int: + # Key variables: + # - logprob_start_len: Absolute position in full sequence where logprob computation begins + # - extend_logprob_start_len: Relative position within current extend batch where logprob computation begins + # - extend_input_len: Number of tokens that need to be processed in this extend batch + if logprob_start_len == -1: + resolved_start = full_untruncated_fill_len + else: + # logprob_start_len should be at least the length of the prefix indices + resolved_start = max(logprob_start_len, prefix_len) + return min(resolved_start - prefix_len, extend_len) + + +def _compute_chunked_req_next_prompt_token( + chunked_req: Optional[Req], + vocab_size: int, +) -> Optional[int]: + """Return the next real prompt token after the fill boundary, skipping + multimodal placeholder (hash) tokens that lie outside the model vocab.""" + if chunked_req is None: + return None + fill_len = chunked_req.extend_range.end + origin_ids = chunked_req.origin_input_ids + if fill_len >= len(origin_ids): + return None + if origin_ids[fill_len] < vocab_size: + return int(origin_ids[fill_len]) + return None + + +@dataclasses.dataclass +class ScheduleBatch(ScheduleBatchDisaggregationDecodeMixin): + """Store all information of a batch on the scheduler.""" + + # === Core: request list (ForwardBatch derives lora_ids / rids / grammars / positions from it) === + reqs: List[Req] + + # === Global config and shared resources (engine-lifetime; identical across batches) === + # Memory pool and cache + req_to_token_pool: ReqToTokenPool = None + token_to_kv_pool_allocator: BaseTokenToKVPoolAllocator = None + tree_cache: BasePrefixCache = None + + # Batch configs + model_config: ModelConfig = None + enable_overlap: bool = False + + # Device + device: str = "cuda" + + # HiSparse (engine-level coordinator ref, same across batches) + hisparse_coordinator: Optional[HiSparseCoordinator] = None + + # === Batch-variant scheduler state (per-batch; not read by ForwardBatch) === + # Tell whether the current running batch is full so that we can skip + # the check of whether to prefill new requests. + # This is an optimization to reduce the overhead of the prefill check. + batch_is_full: bool = False + + # For chunked prefill in PP + chunked_req: Optional[Req] = None + chunked_req_next_prompt_token: Optional[int] = None + contains_last_prefill_chunk: bool = True + + # For DP attention + inner_idle_batch: Optional[ScheduleBatch] = None + # Decode requests carried alongside a chunked-prefill batch + decoding_reqs: List[Req] = None + + # For split prefill + split_index: int = 0 + split_prefill_finished: bool = False + split_forward_count: int = 1 + split_forward_batch: ForwardBatch = None + + # CPU mirror of req_pool_indices; schedule-path only (used in overlap_utils, + # not read by ForwardBatch), stale in spec draft window + req_pool_indices_cpu: torch.Tensor = None # shape: [b], int64 + + # Forward-pass metrics + fpm_start_time: float = 0.0 + + # hicache pointer for synchronizing data loading from CPU to GPU + hicache_consumer_index: int = -1 + + # Metrics + dp_cooperation_info: Optional[DPCooperationInfo] = None + prefill_stats: Optional[PrefillStats] = None + forward_iter: Optional[int] = None + launch_ts: Optional[float] = None + after_idle_gap: bool = False + + # === GPU tensors crossing to ForwardBatch (clone targets for stream isolation) === + # Batched arguments to model runner + input_ids: torch.Tensor = None # shape: [b], int64 + # Staging consumed by resolve_forward_inputs (prefill H2D / mixed gather). + prefill_input_ids_cpu: Optional[torch.Tensor] = None + mix_running_indices: Optional[torch.Tensor] = None + input_embeds: torch.Tensor = None # shape: [b, hidden_size], float32 + + # Token replacement embeddings and absolute positions (optional). + replace_embeds: Optional[torch.Tensor] = None + replace_positions: Optional[torch.Tensor] = None + + # Read by ForwardBatch ngram embedding init + ne_token_table: torch.Tensor = None + # Mask marking chunked (not-yet-finished) prefill requests whose sampled + # pseudo next-token must NOT be written into the ngram token table. + ne_skip_token_table_update: torch.Tensor = None + + req_pool_indices: torch.Tensor = None # shape: [b], int64 + seq_lens: torch.Tensor = None # shape: [b], int64 + + # The original sequence lengths, Qwen-1M related + orig_seq_lens: torch.Tensor = None # shape: [b], int32 + + # The output locations of the KV cache + out_cache_loc: torch.Tensor = None # shape: [b], int64 + # DSV4-NPU: per-pool slot bundle from DSV4NPUTokenToKVPoolAllocator (None + # elsewhere); c4/c128 state lens ride on ``batch.dsv4_state_lens``. + out_cache_loc_dsv4: Optional[Any] = None + + # For hybrid GDN prefix cache + mamba_track_indices: torch.Tensor = None # shape: [b], int64 + # Per-batch snapshot of the logical ping-pong positions selected for this + # forward (normally req.mamba_next_track_idx; spec may override it). Result + # processing uses it to update req.mamba_last_track_idx, since both req-level + # indices may advance under overlap. + mamba_track_buffer_indices: Optional[List[int]] = None # shape: [b], 0 or 1 + mamba_track_mask: torch.Tensor = None # shape: [b], bool + mamba_track_seqlens: torch.Tensor = None # shape: [b], int64 + mamba_track_mask_cpu: Optional[List[bool]] = None # shape: [b] + mamba_track_mask_next_cpu: Optional[List[bool]] = None # shape: [b] + mamba_decode_batch_idx_cpu: Optional[List[int]] = None # shape: [b] + # Lazy + spec: this iteration's per-req scatter positions + # (see mamba_lazy_spec_prepare). + mamba_lazy_spec_track_positions_cpu: Optional[List[int]] = None # shape: [b] + # Deferred mamba init ops: COW pairs and clear indices (performed on forward stream) + mamba_cow_src_indices: torch.Tensor = None + mamba_cow_dst_indices: torch.Tensor = None + mamba_clear_indices: torch.Tensor = None + + # Encoder-decoder device tensors (host fields in the host metadata group) + encoder_lens: Optional[torch.Tensor] = None + encoder_out_cache_loc: Optional[torch.Tensor] = None + + # It comes empty list if logprob is not required. + extend_input_logprob_token_ids: Optional[torch.Tensor] = None + + # === Config / flags crossing to ForwardBatch (by-value) === + forward_mode: ForwardMode = None + global_forward_mode: Optional[ForwardMode] = None + + # For DP attention + is_extend_in_batch: bool = False + can_run_dp_cuda_graph: bool = False + can_run_dp_breakable_cuda_graph: bool = False + tbo_split_seq_index: Optional[int] = None + # Rank-consistent forward mode for the recv skipper, derived from the MLP + # sync all-gather (the TBO-only `global_forward_mode` is None without TBO). + recv_skipper_forward_mode: Optional[ForwardMode] = None + spec_verify_tier_num_tokens: int = -1 + + # For processing logprobs + return_logprob: bool = False + + # Whether this batch is prefill-only (no token generation needed) + is_prefill_only: bool = False + + # Speculative decoding + spec_algorithm: SpeculativeAlgorithm = None + + # Whether to return hidden states + return_hidden_states: bool = False + return_hidden_states_mode: CaptureHiddenMode = CaptureHiddenMode.NULL + + # Has grammar + has_grammar: bool = False + + # The sum of all sequence lengths + seq_lens_sum: int = None + extend_num_tokens: Optional[int] = None + + # Diffusion LLM + dllm_config: Optional[DllmConfig] = None + + # === Host metadata crossing to ForwardBatch (CPU lists / mirrors) === + seq_lens_cpu: torch.Tensor = None # shape: [b], int64 + + # For multimodal inputs + multimodal_inputs: Optional[List] = None + + # For processing logprobs + top_logprobs_nums: Optional[List[int]] = None + token_ids_logprobs: Optional[List[List[int]]] = None + + # For encoder-decoder architectures + encoder_cached: Optional[List[bool]] = None + encoder_lens_cpu: Optional[List[int]] = None + + # For extend and mixed chunekd prefill + prefix_lens: List[int] = None + extend_lens: List[int] = None + extend_logprob_start_lens: List[int] = None + + # For DP attention + global_num_tokens: Optional[List[int]] = None + global_num_tokens_for_logprob: Optional[List[int]] = None + global_spec_verify_tier_num_tokens: Optional[List[int]] = None + + # === Compound crossing to ForwardBatch (carry their own device tensors) === + # Sampling info + sampling_info: SamplingBatchInfo = None + + # Speculative decoding + # spec_info: Optional[SpecInput] = None + spec_info: Optional[SpecInput] = None + + @classmethod + def init_new( + cls, + reqs: List[Req], + req_to_token_pool: ReqToTokenPool, + token_to_kv_pool_allocator: BaseTokenToKVPoolAllocator, + tree_cache: BasePrefixCache, + model_config: ModelConfig, + enable_overlap: bool, + spec_algorithm: SpeculativeAlgorithm, + chunked_req: Optional[Req] = None, + dllm_config: Optional[DllmConfig] = None, + ): + return_logprob = any(req.return_logprob for req in reqs) + + return_hidden_states_mode = get_batch_return_hidden_states_mode(reqs) + + batch = cls( + reqs=reqs, + req_to_token_pool=req_to_token_pool, + token_to_kv_pool_allocator=token_to_kv_pool_allocator, + tree_cache=tree_cache, + model_config=model_config, + enable_overlap=enable_overlap, + return_logprob=return_logprob, + has_grammar=any(req.grammar for req in reqs), + device=req_to_token_pool.device, + spec_algorithm=spec_algorithm, + return_hidden_states=return_hidden_states_mode.need_capture(), + return_hidden_states_mode=return_hidden_states_mode, + is_prefill_only=all(req.is_prefill_only for req in reqs), + chunked_req=chunked_req, + chunked_req_next_prompt_token=_compute_chunked_req_next_prompt_token( + chunked_req, + model_config.vocab_size, + ), + dllm_config=dllm_config, + ) + return batch + + def batch_size(self): + return len(self.reqs) + + def is_empty(self): + return len(self.reqs) == 0 + + def is_dllm(self): + return self.dllm_config is not None + + def grammar_needs_sync(self) -> bool: + """Whether grammar forces this batch onto the synchronous path, i.e. the + previous batch's result is resolved before this forward.""" + return self.has_grammar and not self.spec_algorithm.supports_grammar_overlap() + + def prepare_encoder_info_extend( + self, input_ids: List[array[int]], seq_lens: List[int] + ): + _pin = is_pin_memory_available(self.device) + encoder_lens_cpu = [] + encoder_cached = [] + + for req in self.reqs: + im = req.multimodal_inputs + if im is None or im.num_image_tokens is None: + # No image input + encoder_lens_cpu.append(0) + encoder_cached.append(True) + else: + encoder_lens_cpu.append(im.num_image_tokens) + encoder_cached.append( + self.forward_mode.is_decode() + or len(req.prefix_indices) >= im.num_image_tokens + ) + self.encoder_lens_cpu = encoder_lens_cpu + self.encoder_cached = encoder_cached + + self.encoder_lens = torch.tensor( + self.encoder_lens_cpu, dtype=torch.int64, pin_memory=_pin + ).to(self.device, non_blocking=True) + + # Strip encoder infos + pt = 0 + decoder_out_cache_loc = [] + encoder_out_cache_loc = [] + extend_lens = self.extend_lens[:] + prefix_lens = self.prefix_lens[:] + for i, req in enumerate(self.reqs): + encoder_len = self.encoder_lens_cpu[i] + seq_lens[i] -= encoder_len + + if len(req.prefix_indices) < encoder_len: + # NOTE: the encoder part should be considered as a whole + assert len(req.prefix_indices) == 0 + input_ids[i] = input_ids[i][encoder_len:] + encoder_out_cache_loc.append(self.out_cache_loc[pt : pt + encoder_len]) + decoder_out_cache_loc.append( + self.out_cache_loc[pt + encoder_len : pt + req.extend_range.length] + ) + extend_lens[i] -= encoder_len + self.extend_num_tokens = self.extend_num_tokens - encoder_len + else: + decoder_out_cache_loc.append( + self.out_cache_loc[pt : pt + req.extend_range.length] + ) + prefix_lens[i] -= encoder_len + + pt += req.extend_range.length + self.extend_lens = extend_lens + self.prefix_lens = prefix_lens + + # Reassign: ED stripping rebuilds prefill_input_ids_cpu (CPU pinned); + # resolve_forward_inputs will H2D this on forward stream. self.input_ids + # stays None. + self.prefill_input_ids_cpu = flatten_arrays_to_pinned_cpu(input_ids, _pin) + self.seq_lens = torch.tensor(seq_lens, dtype=torch.int64, pin_memory=_pin).to( + self.device, non_blocking=True + ) + self.seq_lens_cpu = torch.tensor(seq_lens, dtype=torch.int64) + + if not decoder_out_cache_loc: + self.out_cache_loc = torch.zeros(0, dtype=torch.int64).to( + self.device, non_blocking=True + ) + else: + self.out_cache_loc = torch.cat(decoder_out_cache_loc) + + if not encoder_out_cache_loc: + self.encoder_out_cache_loc = torch.zeros(0, dtype=torch.int64).to( + self.device, non_blocking=True + ) + else: + self.encoder_out_cache_loc = torch.cat(encoder_out_cache_loc) + + assert ( + len(self.out_cache_loc) == self.extend_num_tokens + ), f"Expected {len(self.out_cache_loc)}, got {self.extend_num_tokens}" + + if self.extend_input_logprob_token_ids is not None: + new_token_ids_parts = [] + offset = 0 + extend_logprob_start_lens = self.extend_logprob_start_lens[:] + for i, req in enumerate(self.reqs): + encoder_len = self.encoder_lens_cpu[i] + old_start_len = extend_logprob_start_lens[i] + old_contribution = req.extend_range.length - old_start_len + + if len(req.prefix_indices) < encoder_len: + tokens_to_strip = max(0, encoder_len - old_start_len) + new_token_ids_parts.append( + self.extend_input_logprob_token_ids[ + offset + tokens_to_strip : offset + old_contribution + ] + ) + extend_logprob_start_lens[i] = max(0, old_start_len - encoder_len) + else: + new_token_ids_parts.append( + self.extend_input_logprob_token_ids[ + offset : offset + old_contribution + ] + ) + + offset += old_contribution + self.extend_logprob_start_lens = extend_logprob_start_lens + + if new_token_ids_parts: + self.extend_input_logprob_token_ids = torch.cat(new_token_ids_parts) + else: + self.extend_input_logprob_token_ids = None + + for i, req in enumerate(self.reqs): + encoder_len = self.encoder_lens_cpu[i] + if encoder_len == 0: + continue + if len(req.prefix_indices) < encoder_len: + assert len(req.prefix_indices) == 0 + req.extend_range = req.extend_range._replace( + start=req.extend_range.start + encoder_len + ) + req.logprob_start_len = max(req.logprob_start_len, encoder_len) + + def prepare_for_extend(self): + self.forward_mode = ForwardMode.EXTEND + + if self.is_dllm(): + # For DLLM, we use a separate forward mode + self.forward_mode = ForwardMode.DLLM_EXTEND + + # Init tensors + reqs = self.reqs + input_ids = [r.get_fill_ids()[len(r.prefix_indices) :] for r in reqs] + extend_num_tokens = sum(len(ids) for ids in input_ids) + seq_lens = [r.extend_range.end for r in reqs] + orig_seq_lens = [max(r.extend_range.end, len(r.origin_input_ids)) for r in reqs] + prefix_lens = [len(r.prefix_indices) for r in reqs] + extend_lens = [r.extend_range.length for r in reqs] + extend_logprob_start_lens = [ + compute_extend_logprob_start_len( + logprob_start_len=r.logprob_start_len, + prefix_len=prefix_lens[i], + extend_len=extend_lens[i], + full_untruncated_fill_len=len(r.full_untruncated_fill_ids), + ) + for i, r in enumerate(reqs) + ] + + _pin = is_pin_memory_available(self.device) + # Stay on pinned CPU; H2D is deferred to forward stream via + # resolve_forward_inputs. + pinned_input_ids = flatten_arrays_to_pinned_cpu(input_ids, _pin) + seq_lens_tensor = torch.tensor(seq_lens, dtype=torch.int64, pin_memory=_pin).to( + self.device, non_blocking=True + ) + seq_lens_cpu = torch.tensor(seq_lens, dtype=torch.int64) + orig_seq_lens_tensor = torch.tensor( + orig_seq_lens, dtype=torch.int32, pin_memory=_pin + ).to(self.device, non_blocking=True) + + # Set batch fields needed by alloc_for_extend + self.prefix_lens = prefix_lens + self.extend_lens = extend_lens + self.seq_lens = seq_lens_tensor + self.seq_lens_cpu = seq_lens_cpu + self.extend_num_tokens = extend_num_tokens + + # Allocate memory + out_cache_loc, req_pool_indices_tensor, req_pool_indices_cpu = alloc_for_extend( + self + ) + + # Set fields + input_embeds = [] + all_replace_embeds: List[torch.Tensor] = [] + all_replace_positions: List[int] = [] + has_replace_embeds = False + input_id_pointer = 0 + input_id_lens = [len(input_id) for input_id in input_ids] + extend_input_logprob_token_ids = [] + multimodal_inputs = [] + mamba_track_mask_cpu = [] + mamba_track_indices_cpu = [] + mamba_track_seqlens_cpu = [] + + for i, (req, seq_len, pre_len) in enumerate(zip(reqs, seq_lens, prefix_lens)): + assert seq_len - pre_len == req.extend_range.length + + req.extend_batch_idx += 1 + + # update req-level memory management fields + # TODO(th4): co-locate this req.kv bookkeeping with the real KV + # allocation in alloc_for_extend above; they are currently a few + # steps apart and should become one owned-kv allocation step. + req.kv_committed_len = seq_len + + # If input_embeds are available, store them + if req.input_embeds is not None: + # Slice to match extend_input_len — PrefillAdder truncates + # fill_len/extend_input_len on chunk overflow but not input_embeds. + input_embeds.extend( + req.input_embeds[pre_len : pre_len + req.extend_range.length] + ) + + if req.positional_embed_overrides is not None: + # Override positions are absolute in the full sequence. + # Convert to extend-tensor coordinates by subtracting pre_len, + # then skip any that fall within the cached prefix. + embeds_to_add = [] + for embed_idx, pos in enumerate( + req.positional_embed_overrides.positions + ): + extend_pos = pos - pre_len + if extend_pos < 0 or extend_pos >= req.extend_range.length: + continue # Outside current extend chunk, skip + embeds_to_add.append((embed_idx, input_id_pointer + extend_pos)) + if embeds_to_add: + has_replace_embeds = True + indices, positions = zip(*embeds_to_add) + all_replace_embeds.append( + req.positional_embed_overrides.embeds[list(indices)] + ) + all_replace_positions.extend(positions) + input_id_pointer += input_id_lens[i] + + multimodal_inputs.append(req.multimodal_inputs) + + # Only calculate cached_tokens once. Once retracted, the 'retracted_stain' + # flag will always True + if not req.retracted_stain: + new_cached = pre_len - req.already_computed + req.cached_tokens += new_cached + + # Calculate detailed breakdown of cached tokens by source (for HiCache) + # Only compute once on FIRST chunk - subsequent chunks in chunked prefill + # would incorrectly count previously computed tokens as cache hits. + if not req._cache_breakdown_computed: + # storage_hit_length is set by scheduler.pop_prefetch_loaded_tokens() + # after prefetch completes. + ( + req.cached_tokens_device, + req.cached_tokens_host, + req.cached_tokens_storage, + ) = split_cached_prefix_by_tier( + prefix_len=len(req.prefix_indices), + host_hit_len=req.host_hit_length, + storage_hit_len=req.storage_hit_length, + ) + req._cache_breakdown_computed = True + + req.already_computed = seq_len + req.is_retracted = False + + if mamba_extra_buffer_enabled(): + track_entry = self._mamba_radix_cache_v2_req_prepare_for_extend(req) + mamba_track_mask_cpu.append(track_entry.track_mask) + mamba_track_indices_cpu.append(track_entry.track_index) + mamba_track_seqlens_cpu.append(track_entry.track_seqlen) + + if self.return_logprob: + # Find input logprob token ids. + # First, find a global index within origin_input_ids and slide it by 1 + # to compute input logprobs. It is because you need the next token + # to compute input logprobs. E.g., (chunk size 2) + # + # input_logprobs = [1, 2, 3, 4] + # get_fill_ids() = [1, 2] + # extend_input_logprob_token_id = [2, 3] + # + # Note that it can also overflow. In this case, we pad it with 0. + # input_logprobs = [1, 2, 3, 4] + # get_fill_ids() = [3, 4] + # extend_input_logprob_token_id = [4, 0] + global_start_idx, global_end_idx = ( + len(req.prefix_indices), + req.extend_range.end, + ) + if req.logprob_start_len == -1: + logprob_start_len = len(req.origin_input_ids) + else: + logprob_start_len = req.logprob_start_len + # Apply logprob_start_len + if global_start_idx < logprob_start_len: + global_start_idx = logprob_start_len + + logprob_token_ids = req.origin_input_ids[ + global_start_idx + 1 : global_end_idx + 1 + ] + extend_input_logprob_token_ids.extend(logprob_token_ids) + + # We will need req.extend_range.length - extend_logprob_start_lens[i] number of + # tokens, and logprob_token_ids is for input logprob, so pad the rest of them by 0. + extend_input_logprob_token_ids.extend( + [0] + * ( + req.extend_range.length + - extend_logprob_start_lens[i] + - len(logprob_token_ids) + ) + ) + + if self.return_logprob: + extend_input_logprob_token_ids = torch.tensor( + extend_input_logprob_token_ids + ) + # Clamp placeholder or out-of-range token IDs (e.g., multimodal hashes) + # so they stay within the vocab boundary before being sent to GPU. + extend_input_logprob_token_ids.clamp_(0, self.model_config.vocab_size - 1) + else: + extend_input_logprob_token_ids = None + + if has_replace_embeds: + replace_embeds_tensor = torch.cat(all_replace_embeds, dim=0).to( + self.device, non_blocking=True + ) + replace_positions_tensor = torch.tensor( + all_replace_positions, dtype=torch.long, device=self.device + ) + else: + replace_embeds_tensor = None + replace_positions_tensor = None + + self.input_ids = None + self.prefill_input_ids_cpu = pinned_input_ids + self.req_pool_indices = req_pool_indices_tensor + self.req_pool_indices_cpu = req_pool_indices_cpu + self.orig_seq_lens = orig_seq_lens_tensor + self.out_cache_loc = out_cache_loc + self.input_embeds = ( + torch.tensor(input_embeds, pin_memory=_pin).to( + self.device, non_blocking=True + ) + if input_embeds + else None + ) + self.replace_embeds = replace_embeds_tensor + self.replace_positions = replace_positions_tensor + for mm_input in multimodal_inputs: + if mm_input is None: + continue + if isinstance(mm_input.vision_position_ids, torch.Tensor): + mm_input.vision_position_ids = mm_input.vision_position_ids.to( + self.device, non_blocking=True + ) + if isinstance(mm_input.visible_frame_counts, torch.Tensor): + mm_input.visible_frame_counts = mm_input.visible_frame_counts.to( + self.device, non_blocking=True + ) + self.multimodal_inputs = multimodal_inputs + self.seq_lens_sum = sum(seq_lens) + + if self.return_logprob: + self.top_logprobs_nums = [r.logprob.top_logprobs_num for r in reqs] + self.token_ids_logprobs = [r.logprob.token_ids_logprob for r in reqs] + + self.extend_logprob_start_lens = extend_logprob_start_lens + self.extend_input_logprob_token_ids = extend_input_logprob_token_ids + + if mamba_extra_buffer_enabled(): + self.mamba_track_indices = torch.tensor( + mamba_track_indices_cpu, + dtype=torch.int64, + device=self.device, + ) + self.mamba_track_mask = torch.tensor( + mamba_track_mask_cpu, + dtype=torch.bool, + device=self.device, + ) + self.mamba_track_seqlens = torch.tensor( + mamba_track_seqlens_cpu, + dtype=torch.int64, + device=self.device, + ) + + # Collect mamba init info for deferred ops on forward stream + if any(req.mamba_pool_idx is not None for req in reqs): + self._collect_deferred_mamba_cow_and_clear(reqs) + + if self.model_config.is_encoder_decoder: + self.prepare_encoder_info_extend(input_ids, seq_lens) + + # Build sampling info + self.sampling_info = SamplingBatchInfo.from_schedule_batch( + self, + self.model_config.vocab_size, + ) + + def _mamba_radix_cache_v2_req_prepare_for_extend( + self, + req: Req, + ) -> _MambaRadixCacheV2TrackEntry: + chunk_size = mamba_cache_chunk_size() + # The donated depth has to be a radix node boundary. Read the tree's own + # page rather than re-deriving how DCP widens it; the kernel still + # snapshots on the chunk_size grid. + checkpoint_grid = mamba_checkpoint_grid(self.tree_cache.page_size) + + def _force_track_h(i: int) -> int: + assert i % chunk_size == 0 + # There are 3 cases for mamba_track_seqlen passed to mamba_track_seqlens_cpu: + # 1) aligned with chunk_size-> retrieve from last_recurrent_state + # a) is the last position -> retrieve from last_recurrent_state + # b) is NOT the last position -> retrieve from h + # 2) unaligned with chunk_size -> retrieve from h + # Currently, the math calculation only supports case 1a and 2. So for 1b, we need to add 1 + # to force the math calculation to retrieve the correct mamba state from h. + return i + 1 + + mask = req.extend_range.length >= checkpoint_grid + track_index = req.mamba_ping_pong_track_buffer[req.mamba_next_track_idx].item() + mamba_track_seqlen = -1 + if mask: + # mamba_track_seqlen is used to calculate the indices to track in + # hybrid_linear_attn_backend's _init_track_ssm_indices. Due to the + # fact that the ssm state between aligned and non-aligned are retrieved differently, + # if 1) last pos and 2) is aligned, then retrieved from the last_recurrent_state, + # otherwise retrieved from h (i.e. unaligned). + # We need to pass the non-aligned seqlen to the calculation. Even though + # we pass in mamba_track_seqlen, the actual tracked seqlen is mamba_last_track_seqlen. + mamba_track_seqlen = len(req.prefix_indices) + req.extend_range.length + + # mamba_track_seqlen_aligned/mamba_last_track_seqlen is actual tracked seqlen. Used to pass to + # mamba radix cache to track which seqlen this mamba state should store at. + mamba_track_seqlen_aligned = ( + len(req.prefix_indices) + + (req.extend_range.length // checkpoint_grid) * checkpoint_grid + ) + + # mamba_track_fla_chunk_aligned is the aligned seqlen based on chunk_size + # If mamba_track_fla_chunk_aligned != mamba_track_seqlen_aligned, which is true when + # checkpoint_grid is coarser than chunk_size, we need to force the math calculation to + # retrieve the correct mamba state from h by _force_track_h() + mamba_track_fla_chunk_aligned = ( + len(req.prefix_indices) + + (req.extend_range.length // chunk_size) * chunk_size + ) + if mamba_track_fla_chunk_aligned != mamba_track_seqlen_aligned: + # We want to track mamba_track_seqlen_aligned, and it's not the last position, + # so we need to add 1 to the seqlen to retrieve the correct mamba state from h. + mamba_track_seqlen = _force_track_h(mamba_track_seqlen_aligned) + + # In lazy mode, skip the swap — the second ping-pong slot is not + # allocated yet; it will be allocated on demand at the track boundary + # in mamba_lazy_prealloc_at_boundary during prepare_for_decode. + req.mamba_last_track_idx = req.mamba_next_track_idx + if not mamba_extra_buffer_lazy_enabled(): + req.mamba_next_track_idx = ( + self.req_to_token_pool.get_mamba_ping_pong_other_idx( + req.mamba_next_track_idx + ) + ) + if req.mamba_branching_seqlen is not None: + # track branching point in this forward if the branching point + # is within the current extend batch. + branching_seqlen_aligned_mask = ( + req.mamba_branching_seqlen - len(req.prefix_indices) + ) % chunk_size == 0 + if ( + req.mamba_branching_seqlen > len(req.prefix_indices) + and req.mamba_branching_seqlen < mamba_track_seqlen + and branching_seqlen_aligned_mask + ): + # We want to track mamba_track_seqlen_aligned, and it's not the last position, + # so we need to add 1 to the seqlen to retrieve the correct mamba state from h. + # See _force_track_h() for more details. + mamba_track_seqlen = _force_track_h(req.mamba_branching_seqlen) + mamba_track_seqlen_aligned = req.mamba_branching_seqlen + req.mamba_last_track_seqlen = mamba_track_seqlen_aligned + + return _MambaRadixCacheV2TrackEntry( + track_mask=mask, + track_index=track_index, + track_seqlen=mamba_track_seqlen, + ) + + def _collect_deferred_mamba_cow_and_clear(self, reqs): + """Collect deferred COW/clear info from requests.""" + cow_src_tensors = [] + cow_dst_tensors = [] + clear_tensors = [] + for req in reqs: + if req.mamba_cow_src_index is not None: + cow_src_tensors.append(req.mamba_cow_src_index) + cow_dst_tensors.append(req.mamba_pool_idx.unsqueeze(0)) + req.mamba_cow_src_index = None + req.mamba_needs_clear = False + elif req.mamba_needs_clear: + clear_tensors.append(req.mamba_pool_idx.unsqueeze(0)) + req.mamba_needs_clear = False + self.mamba_cow_src_indices = ( + torch.cat(cow_src_tensors) if cow_src_tensors else None + ) + self.mamba_cow_dst_indices = ( + torch.cat(cow_dst_tensors) if cow_dst_tensors else None + ) + self.mamba_clear_indices = torch.cat(clear_tensors) if clear_tensors else None + + def prepare_for_split_prefill(self): + self.prepare_for_extend() + # For split prefill, we need to set the forward mode to SPLIT_PREFILL + self.forward_mode = ForwardMode.SPLIT_PREFILL + + def mix_with_running(self, running_batch: ScheduleBatch): + self.forward_mode = ForwardMode.MIXED + running_bs = running_batch.batch_size() + + for req in running_batch.reqs: + req._refresh_fill_ids() + full_len = len(req.full_untruncated_fill_ids) + req.set_extend_range(full_len - 1, full_len) + + # Decode tokens of the running portion live in future_map.output_tokens_buf. + self.input_ids = None + self.mix_running_indices = running_batch.req_pool_indices + out_cache_loc = torch.cat([self.out_cache_loc, running_batch.out_cache_loc]) + + self.merge_batch(running_batch) + self.out_cache_loc = out_cache_loc + + # For overlap scheduler, the output_ids has one step delay + delta = 0 if self.enable_overlap else -1 + + # NOTE: prefix_indices is what has been cached, but we don't cache each decode step + self.prefix_lens = self.prefix_lens + [ + len(r.origin_input_ids) + len(r.output_ids) + delta + for r in running_batch.reqs + ] + self.extend_lens = self.extend_lens + [1] * running_bs + self.extend_num_tokens = self.extend_num_tokens + running_bs + # TODO (lianmin): Revisit this. It should be seq_len - 1 + self.extend_logprob_start_lens = ( + self.extend_logprob_start_lens + [0] * running_bs + ) + self.is_prefill_only = False + + def new_tokens_required_next_decode( + self, selected_indices: Optional[List[int]] = None + ): + page_size = self.token_to_kv_pool_allocator.page_size + requests = ( + self.reqs + if selected_indices is None + else [self.reqs[i] for i in selected_indices] + ) + + if self.spec_algorithm.is_none(): + new_pages = sum(1 for r in requests if r.kv_committed_len % page_size == 0) + return new_pages * page_size + + return self._new_tokens_required_next_decode_spec_v2(requests, page_size) + + def _new_tokens_required_next_decode_spec_v2(self, requests, page_size): + """Tight estimate matching eagle_utils.eagle_prepare_for_decode allocation.""" + reserve = get_alloc_reserve_per_decode() + total = 0 + for r in requests: + x = max(0, r.kv_committed_len + reserve - r.kv.kv_allocated_len) + cur = r.kv.kv_allocated_len + nxt = cur + x + total += ceil_align(nxt, page_size) - ceil_align(cur, page_size) + return total + + def check_decode_mem(self, selected_indices: Optional[List[int]] = None): + """Reclaim evictable tree-cache entries (shortfall only), then report + whether the next decode step fits in the KV pool.""" + num_tokens = self.new_tokens_required_next_decode(selected_indices) + evict_from_tree_cache(self.tree_cache, num_tokens) + return self.token_to_kv_pool_allocator.available_size() >= num_tokens + + def retract_decode( + self, server_args: ServerArgs + ) -> Tuple[List[Req], float, List[Req]]: + """Retract the decoding requests when there is not enough memory.""" + sorted_indices = self._get_decode_retraction_order(self.reqs, server_args) + + retracted_reqs = [] + first_iter = True + while first_iter or ( + not self.check_decode_mem(selected_indices=sorted_indices) + ): + if len(sorted_indices) == 1: + # Always keep at least one request + break + + first_iter = False + idx = sorted_indices.pop() + req = self.reqs[idx] + retracted_reqs.append(req) + # release memory and don't insert into the tree because we need the space instantly + self.release_req(idx, len(sorted_indices), server_args) + + reqs_to_abort: List[Req] = [] + if len(sorted_indices) <= 1 and not self.check_decode_mem( + selected_indices=sorted_indices + ): + # Even the last remaining request cannot fit in memory. + # Instead of crashing the scheduler, gracefully abort it. + last_idx = sorted_indices.pop() + last_req = self.reqs[last_idx] + last_req.to_finish = FINISH_ABORT( + "Out of memory even after retracting all other requests " + "in the decode batch. Aborting the last request.", + status_code=HTTPStatus.INTERNAL_SERVER_ERROR, + ) + reqs_to_abort.append(last_req) + self.release_req(last_idx, 0, server_args) + logger.warning( + "retract_decode: aborted last request %s due to OOM", last_req.rid + ) + + self.filter_batch(keep_indices=sorted_indices) + + # Reqs in batch are filtered + new_estimate_ratio = ( + NewTokenRatioTracker.estimate_new_token_ratio_after_retract(self.reqs) + ) + + return retracted_reqs, new_estimate_ratio, reqs_to_abort + + @staticmethod + def _get_decode_retraction_order( + reqs: List[Req], server_args: ServerArgs + ) -> List[int]: + """Return indices ordered from most-preferred to least-preferred to keep. + + The retraction loop pops from the end of this list, so the least-preferred + request is retracted first. + """ + sorted_indices = list(range(len(reqs))) + + # TODO(lsyin): improve retraction policy for radix cache + + def length_key(req: Req) -> Tuple[int, int]: + return (len(req.output_ids), -len(req.origin_input_ids)) + + if server_args.retraction_policy == "priority": + priority_sign = 1 if server_args.schedule_low_priority_values_first else -1 + + def retraction_key(req: Req) -> Tuple[int, int, int]: + priority = req.priority + if priority is None: + priority = ( + sys.maxsize + if server_args.schedule_low_priority_values_first + else -sys.maxsize - 1 + ) + return (priority * (-priority_sign), *length_key(req)) + + sorted_indices.sort( + key=lambda i: retraction_key(reqs[i]), + reverse=True, + ) + return sorted_indices + + sorted_indices.sort( + key=lambda i: length_key(reqs[i]), + reverse=True, + ) + return sorted_indices + + def release_req(self, idx: int, remaing_req_count: int, server_args: ServerArgs): + release_req( + req=self.reqs[idx], + remaing_req_count=remaing_req_count, + server_args=server_args, + req_to_token_pool=self.req_to_token_pool, + token_to_kv_pool_allocator=self.token_to_kv_pool_allocator, + tree_cache=self.tree_cache, + hisparse_coordinator=self.hisparse_coordinator, + ) + + def prepare_encoder_info_decode(self): + # Reset the encoder cached status + self.encoder_cached = [True] * len(self.reqs) + + def prepare_for_idle(self): + self.forward_mode = ForwardMode.IDLE + self.input_ids = torch.empty(0, dtype=torch.int64, device=self.device) + self.seq_lens = torch.empty(0, dtype=torch.int64, device=self.device) + self.seq_lens_cpu = torch.empty(0, dtype=torch.int64) + self.orig_seq_lens = torch.empty(0, dtype=torch.int32, device=self.device) + self.out_cache_loc = torch.empty(0, dtype=torch.int64, device=self.device) + self.req_pool_indices = torch.empty(0, dtype=torch.int64, device=self.device) + self.req_pool_indices_cpu = torch.empty(0, dtype=torch.int64) + self.seq_lens_sum = 0 + self.extend_num_tokens = 0 + self.sampling_info = SamplingBatchInfo.from_schedule_batch( + self, + self.model_config.vocab_size, + ) + + def mamba_lazy_prealloc_at_boundary(self, mamba_track_interval: int): + """Allocate a temporary second ping-pong slot for reqs at a track boundary. + + In lazy mode each request normally holds only 1 ping-pong slot. + When seq_len hits a track interval boundary, we allocate the + second slot so the forward pass can write the new tracked state + there. The old slot is freed after the forward in + mamba_lazy_post_decode_at_boundary. + """ + pool = self.req_to_token_pool + for i, req in enumerate(self.reqs): + buf = req.mamba_ping_pong_track_buffer + assert buf is not None + # Skip reqs not at a track boundary + if self.seq_lens_cpu[i].item() % mamba_track_interval != 0: + continue + other_idx = 1 - req.mamba_next_track_idx + if buf[other_idx].item() != -1: + # With overlap the previous forward's post-processing + # (which frees this slot) hasn't run yet. Skip. + continue + if envs.SGLANG_TEST_MAMBA_LAZY_ALLOC_FAIL.get(): + new_slot = None + else: + # No evict-retry: a transient slot is not worth evicting a + # cached checkpoint for; on failure tracking degrades in place. + new_slot = pool.mamba_allocator.alloc(1) + if new_slot is not None: + pool.set_mamba_ping_pong_slot(req, other_idx, new_slot[0]) + req.mamba_next_track_idx = other_idx + + def mamba_lazy_spec_prepare(self, mamba_track_interval: int, max_draft_tokens: int): + """Lazy-mode spec counterpart of mamba_lazy_prealloc_at_boundary. + + A crossing is only *possible* at prepare time (accept length is + unknown), so ensure the pending slot exists for reqs whose next + boundary is reachable, WITHOUT swapping mamba_next_track_idx; the + mask-gated commit writes it only on a real crossing, and + _mamba_lazy_spec_confirm_crossing promotes it afterwards. The per-req + scatter position is recorded on the batch and rides the result-queue + copy (forward isolation restores batch fields). + """ + pool = self.req_to_token_pool + track_positions: List[int] = [] + for req in self.reqs: + buf = req.mamba_ping_pong_track_buffer + assert buf is not None + if not mamba_lazy_spec_in_window( + req, mamba_track_interval, max_draft_tokens + ): + # No crossing reachable: the scatter mask stays -1, the + # position is never written. + track_positions.append(req.mamba_next_track_idx) + continue + other_idx = 1 - req.mamba_next_track_idx + has_pending = buf[other_idx].item() != -1 + if not has_pending: + if envs.SGLANG_TEST_MAMBA_LAZY_ALLOC_FAIL.get(): + new_slot = None + else: + # No evict-retry: a transient slot is not worth + # evicting a cached checkpoint for. + new_slot = pool.mamba_allocator.alloc(1) + if new_slot is not None: + pool.set_mamba_ping_pong_slot(req, other_idx, new_slot[0]) + has_pending = True + # On failure the verify scatters in place into the keep slot. + track_positions.append( + other_idx if has_pending else req.mamba_next_track_idx + ) + self.mamba_lazy_spec_track_positions_cpu = track_positions + + def cumulate_penalty_output_tokens(self): + # Under overlap batch.input_ids is just a placeholder here -- the + # real token is relayed via future_map and resolved at forward + # entry. So take the last output token from Req directly + # (origin_input_ids[-1] on the first decode, before any output). + last_tokens = [ + req.output_ids[-1] if len(req.output_ids) else req.origin_input_ids[-1] + for req in self.reqs + ] + # Non-blocking H2D so this per-step copy doesn't sync behind the forward. + # pin_memory (matching the prefill-path tensors) keeps the copy async; + # is_pin_memory_available falls back to pageable on unsupported devices. + latest_output_ids = torch.tensor( + last_tokens, + dtype=torch.int64, + pin_memory=is_pin_memory_available(self.device), + ).to(self.device, non_blocking=True) + self.sampling_info.penalizer_orchestrator.cumulate_output_tokens( + latest_output_ids + ) + + def prepare_for_decode(self): + self.forward_mode = ForwardMode.DECODE + # Decode embeds the last output token via embed_tokens; clear the stale + # prefill-time tensor so it doesn't leak into ForwardBatch. + self.input_embeds = None + + # Clear context parallel metadata - CP is only for prefill, not decode + if hasattr(self, "attn_cp_metadata") and self.attn_cp_metadata is not None: + self.attn_cp_metadata = None + + if not self.spec_algorithm.is_none(): + # Spec decoding owns decode preparation (allocation, seq-lens bookkeeping). + from sglang.srt.speculative.spec_utils import spec_prepare_for_decode + + self.mamba_track_mask_cpu = None + self.mamba_track_mask_next_cpu = None + self.mamba_decode_batch_idx_cpu = None + spec_prepare_for_decode(self) + return + + if self.sampling_info.penalizer_orchestrator.is_required: + self.cumulate_penalty_output_tokens() + + # input_ids is set at end of previous run_batch (placeholder for + # overlap; next_token_ids cast for non-overlap). + + if self.model_config.is_encoder_decoder: + self.prepare_encoder_info_decode() + + # Allocate memory (DSV4-NPU c{4,128}_state alloc lens are computed inside + # the allocator, triggered from mem_cache/common.py.) + self.out_cache_loc = alloc_for_decode(self, token_per_req=1) + + # Update req-level memory management fields + for req in self.reqs: + req.decode_batch_idx += 1 + req.kv_committed_len += 1 + + # New-tensor avoids racing model_worker_batch refs queued for + # overlap forward. + self.seq_lens = self.seq_lens + 1 + self.seq_lens_cpu = self.seq_lens_cpu + 1 + self.orig_seq_lens = self.orig_seq_lens + 1 + # Sum is recomputed lazily by ForwardBatch.init_new. + self.seq_lens_sum = None + + if self.hisparse_coordinator is not None: + self.hisparse_coordinator.map_last_loc_to_buffer( + self.seq_lens, + self.out_cache_loc, + self.req_pool_indices, + self.seq_lens_cpu, + self.req_pool_indices_cpu, + ) + + if mamba_extra_buffer_enabled(): + mamba_track_interval = get_exec().mamba.mamba_track_interval + + if len(self.reqs) == 0: + self.mamba_track_indices = torch.empty( + (0,), dtype=torch.int64, device=self.device + ) + self.mamba_track_buffer_indices = [] + else: + if mamba_extra_buffer_lazy_enabled(): + self.mamba_lazy_prealloc_at_boundary(mamba_track_interval) + set_mamba_track_indices_from_reqs(self) + + track_remainders_cpu = self.seq_lens_cpu % mamba_track_interval + track_mask_cpu = track_remainders_cpu == 0 + self.mamba_track_mask_cpu = track_mask_cpu.tolist() + self.mamba_track_mask_next_cpu = ( + (track_remainders_cpu == mamba_track_interval - 1).tolist() + if self.enable_overlap + else None + ) + # ScheduleBatch.copy() snapshots the list of requests, but the Req + # objects remain shared. The next overlapped decode can therefore + # advance their counters before this batch's result is processed. + self.mamba_decode_batch_idx_cpu = [ + req.decode_batch_idx for req in self.reqs + ] + # async H2D + self.mamba_track_mask = track_mask_cpu.pin_memory().to( + device=self.device, non_blocking=True + ) + + def filter_batch( + self, + chunked_req_to_exclude: Optional[Union[Req, List[Req]]] = None, + keep_indices: Optional[List[int]] = None, + ): + if keep_indices is None: + if isinstance(chunked_req_to_exclude, Req): + chunked_req_to_exclude = [chunked_req_to_exclude] + elif chunked_req_to_exclude is None: + chunked_req_to_exclude = [] + keep_indices = [ + i + for i in range(len(self.reqs)) + if not self.reqs[i].finished() + and self.reqs[i] not in chunked_req_to_exclude + ] + + if keep_indices is None or len(keep_indices) == 0: + # Filter out all requests. Stale tensors are left as-is: is_empty() + # keys off reqs, so callers drop the batch before a forward reads them. + self.reqs = [] + self.return_hidden_states = False + self.return_hidden_states_mode = CaptureHiddenMode.NULL + return + + if len(keep_indices) == len(self.reqs): + # No need to filter + return + + keep_indices_device = torch.tensor( + keep_indices, + dtype=torch.int64, + pin_memory=is_pin_memory_available(self.device), + ).to(self.device, non_blocking=True) + + if self.model_config.is_encoder_decoder: + self.encoder_lens = self.encoder_lens[keep_indices_device] + self.encoder_lens_cpu = [self.encoder_lens_cpu[i] for i in keep_indices] + + self.reqs = [self.reqs[i] for i in keep_indices] + if self.multimodal_inputs is not None: + self.multimodal_inputs = [self.multimodal_inputs[i] for i in keep_indices] + self.req_pool_indices = self.req_pool_indices[keep_indices_device] + self.req_pool_indices_cpu = self.req_pool_indices_cpu[keep_indices] + self.seq_lens = self.seq_lens[keep_indices_device] + self.orig_seq_lens = self.orig_seq_lens[keep_indices_device] + self.out_cache_loc = None + # Sum is recomputed lazily by ForwardBatch.init_new. + self.seq_lens_sum = None + + if self.input_ids is not None: + self.input_ids = self.input_ids[keep_indices_device] + # Optional under no-verify-sync; resolve_seq_lens repopulates before forward. + if self.seq_lens_cpu is not None: + self.seq_lens_cpu = self.seq_lens_cpu[keep_indices] + + self.mamba_track_indices = None + self.mamba_track_buffer_indices = None + self.mamba_track_mask = None + self.mamba_track_seqlens = None + self.mamba_track_mask_cpu = None + self.mamba_track_mask_next_cpu = None + self.mamba_decode_batch_idx_cpu = None + self.mamba_lazy_spec_track_positions_cpu = None + self.mamba_cow_src_indices = None + self.mamba_cow_dst_indices = None + self.mamba_clear_indices = None + self.return_logprob = any(req.return_logprob for req in self.reqs) + if self.return_logprob: + self.top_logprobs_nums = [self.top_logprobs_nums[i] for i in keep_indices] + self.token_ids_logprobs = [self.token_ids_logprobs[i] for i in keep_indices] + else: + self.top_logprobs_nums = None + self.token_ids_logprobs = None + + self.has_grammar = any(req.grammar for req in self.reqs) + self.return_hidden_states_mode = get_batch_return_hidden_states_mode(self.reqs) + self.return_hidden_states = self.return_hidden_states_mode.need_capture() + + self.sampling_info.filter_batch(keep_indices, keep_indices_device) + if self.spec_info: + self.spec_info.filter_batch( + new_indices=keep_indices_device, + new_indices_cpu=keep_indices, + ) + + def merge_batch(self, other: ScheduleBatch): + # Penalizer orchestrator must be merged before Batch.reqs is merged. This is because + # orchestrator.merge() depends on Batch.reqs during preparation of each penalizers, so it + # needs to be called with pre-merged Batch.reqs. + self.sampling_info.merge_batch(other.sampling_info) + + # Encoder-decoder infos + if self.model_config.is_encoder_decoder: + self.encoder_lens = torch.cat([self.encoder_lens, other.encoder_lens]) + self.encoder_lens_cpu = self.encoder_lens_cpu + other.encoder_lens_cpu + self.req_pool_indices = torch.cat( + [self.req_pool_indices, other.req_pool_indices] + ) + self.req_pool_indices_cpu = torch.cat( + [self.req_pool_indices_cpu, other.req_pool_indices_cpu] + ) + self.seq_lens = torch.cat([self.seq_lens, other.seq_lens]) + self.orig_seq_lens = torch.cat([self.orig_seq_lens, other.orig_seq_lens]) + self.out_cache_loc = None + # Sum is recomputed lazily by ForwardBatch.init_new. + self.seq_lens_sum = None + # Cat only when both sides hold a real token tensor; otherwise drop to + # None and let resolve_forward_inputs rebuild from the merged + # req_pool_indices. Mismatch arises e.g. with spec_v1, which keeps its + # tensor while a relay-staged side is None -- there the worker rebuilds. + if self.input_ids is not None and other.input_ids is not None: + self.input_ids = torch.cat([self.input_ids, other.input_ids]) + else: + self.input_ids = None + # Optional under no-verify-sync; drop the mirror if either side absent. + if self.seq_lens_cpu is None or other.seq_lens_cpu is None: + self.seq_lens_cpu = None + else: + self.seq_lens_cpu = torch.cat([self.seq_lens_cpu, other.seq_lens_cpu]) + self.mamba_track_indices = None + self.mamba_track_buffer_indices = None + self.mamba_track_mask = None + self.mamba_track_seqlens = None + self.mamba_track_mask_cpu = None + self.mamba_track_mask_next_cpu = None + self.mamba_decode_batch_idx_cpu = None + self.mamba_lazy_spec_track_positions_cpu = None + if self.return_logprob and other.return_logprob: + self.top_logprobs_nums = self.top_logprobs_nums + other.top_logprobs_nums + self.token_ids_logprobs = self.token_ids_logprobs + other.token_ids_logprobs + elif self.return_logprob: + self.top_logprobs_nums = self.top_logprobs_nums + [0] * len(other.reqs) + self.token_ids_logprobs = self.token_ids_logprobs + [None] * len(other.reqs) + elif other.return_logprob: + self.top_logprobs_nums = [0] * len(self.reqs) + other.top_logprobs_nums + self.token_ids_logprobs = [None] * len(self.reqs) + other.token_ids_logprobs + self.reqs = self.reqs + other.reqs + if self.multimodal_inputs is not None: + self.multimodal_inputs = self.multimodal_inputs + other.multimodal_inputs + + self.return_logprob = self.return_logprob or other.return_logprob + self.has_grammar = self.has_grammar or other.has_grammar + self.return_hidden_states_mode = max( + self.return_hidden_states_mode, other.return_hidden_states_mode + ) + self.return_hidden_states = self.return_hidden_states_mode.need_capture() + self.is_prefill_only = self.is_prefill_only and other.is_prefill_only + + if self.spec_info: + self.spec_info.merge_batch(other.spec_info) + + def copy(self): + # Only contain fields that will be used by process_batch_result. + # Shallow-copy the reqs list as a defensive snapshot. filter_batch and + # merge_batch historically mutated the list in place; they now rebind + # new lists, but the slice stays so this snapshot never aliases the + # original. + return ScheduleBatch( + reqs=self.reqs[:], + extend_lens=self.extend_lens, + prefix_lens=self.prefix_lens, + req_to_token_pool=self.req_to_token_pool, + req_pool_indices=self.req_pool_indices, + model_config=self.model_config, + forward_mode=self.forward_mode, + out_cache_loc=self.out_cache_loc, + return_logprob=self.return_logprob, + has_grammar=self.has_grammar, + return_hidden_states=self.return_hidden_states, + return_hidden_states_mode=self.return_hidden_states_mode, + decoding_reqs=self.decoding_reqs, + spec_algorithm=self.spec_algorithm, + spec_info=self.spec_info, + global_num_tokens=self.global_num_tokens, + global_num_tokens_for_logprob=self.global_num_tokens_for_logprob, + can_run_dp_cuda_graph=self.can_run_dp_cuda_graph, + can_run_dp_breakable_cuda_graph=self.can_run_dp_breakable_cuda_graph, + is_extend_in_batch=self.is_extend_in_batch, + is_prefill_only=self.is_prefill_only, + seq_lens_cpu=self.seq_lens_cpu, + enable_overlap=self.enable_overlap, + mamba_track_indices=self.mamba_track_indices, + mamba_track_buffer_indices=self.mamba_track_buffer_indices, + mamba_track_mask=self.mamba_track_mask, + mamba_track_seqlens=self.mamba_track_seqlens, + mamba_track_mask_cpu=self.mamba_track_mask_cpu, + mamba_track_mask_next_cpu=self.mamba_track_mask_next_cpu, + mamba_decode_batch_idx_cpu=self.mamba_decode_batch_idx_cpu, + mamba_lazy_spec_track_positions_cpu=self.mamba_lazy_spec_track_positions_cpu, + dp_cooperation_info=self.dp_cooperation_info, + prefill_stats=self.prefill_stats, + fpm_start_time=self.fpm_start_time, + forward_iter=self.forward_iter, + launch_ts=self.launch_ts, + after_idle_gap=self.after_idle_gap, + extend_num_tokens=self.extend_num_tokens, + ) + + def maybe_evict_swa(self): + if self.tree_cache.supports_swa(): + sliding_window_size = self.tree_cache.sliding_window_size + + release_leaf_lock = ( + envs.SGLANG_OPT_SWA_RELEASE_LEAF_LOCK_AFTER_WINDOW.get() + and hasattr(self.tree_cache, "dec_swa_lock_only") + ) + + eviction_interval = max(1, envs.SGLANG_SWA_EVICTION_INTERVAL.get()) + self.token_to_kv_pool_allocator.free_group_begin() + for idx, req in enumerate(self.reqs): + if self.forward_mode.is_decode(): + # We set evict_swa condition here with two reasons: + # 1. In overlap scheduler, we cannot evict swa when req.decode_batch_idx == 0 since the prev extend batch is still running. + # 2. Evict only once >= eviction_interval tokens have slid + # out of the window, amortizing eviction work while keeping + # each request's overshoot within the interval the pool + # budget reserves. Gating on accumulated tokens (rather + # than an iteration-counter phase) cannot starve because + # seqlen progress is monotonic per KV handle. + if ( + req.decode_batch_idx >= 1 + and req.kv is not None + and req.seqlen - 1 - sliding_window_size + >= req.kv.swa_evicted_seqlen + eviction_interval + ): + self._evict_swa(req, req.seqlen - 1) + + # DSV4-NPU only (no-op elsewhere): the small paged compress-state + # pool must drain every decode step, independent of SWA cadence. + maybe_evict_dsv4_state(self, req, req.seqlen - 1) + + # Once the decode position has moved past the sliding window, + # the SWA portion of the prefill-time tree lock is no longer + # needed by this request. Convert it from protected to + # evictable so SWA LRU can reclaim it under pressure. + if ( + release_leaf_lock + and not req.swa_prefix_lock_released + and req.swa_uuid_for_lock is not None + and req.last_node is not None + and req.decode_batch_idx >= sliding_window_size + ): + self.tree_cache.dec_swa_lock_only( + req.last_node, + req.swa_uuid_for_lock, + skip_lock_node_ids=req.skip_lock_node_ids, + ) + req.swa_prefix_lock_released = True + elif self.forward_mode.is_extend() and self.tree_cache.is_chunk_cache(): + pre_len = self.prefix_lens[idx] + if self.enable_overlap: + # In chunked prefill case, when the second extend batch is scheduling, the first extend batch is still running, so we cannot evict swa tokens + if req.extend_batch_idx < 2: + continue + else: + pre_len = ( + pre_len - get_schedule().chunked_prefill_size + if get_schedule().chunked_prefill_size > 0 + else pre_len + ) + self._evict_swa(req, pre_len) + else: + self._evict_swa(req, pre_len) + self.token_to_kv_pool_allocator.free_group_end() + + def _evict_swa(self, req: Req, pre_len: int): + assert self.tree_cache.supports_swa(), "prefix cache must support swa" + free_swa_out_of_window_slots( + req, + pre_len, + sliding_window_size=self.tree_cache.sliding_window_size, + page_size=self.tree_cache.page_size, + req_to_token_pool=self.req_to_token_pool, + token_to_kv_pool_allocator=self.token_to_kv_pool_allocator, + is_chunk_cache=self.tree_cache.is_chunk_cache(), + retain_floor=self.tree_cache.swa_retain_floor(req), + ) + + def __str__(self): + return ( + f"ScheduleBatch(forward_mode={self.forward_mode.name if self.forward_mode else 'None'}, " + f"#req={(len(self.reqs))})" + ) + + +class NextBatchPlan(msgspec.Struct): + batch_to_run: Optional[ScheduleBatch] + running_batch: ScheduleBatch diff --git a/scripts/test_invalid_token_failure.sh b/scripts/test_invalid_token_failure.sh new file mode 100755 index 0000000..88e326a --- /dev/null +++ b/scripts/test_invalid_token_failure.sh @@ -0,0 +1,55 @@ +#!/usr/bin/env bash +# CPU-only local validation; no build, GPU devices, network, or publication. +set -euo pipefail + +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +GRAY='\033[0;90m' +NC='\033[0m' + +run() { + printf >&2 "${GRAY}%s >${NC} ${YELLOW}" "$(pwd)" + printf >&2 "%q " "$@" + printf >&2 "${NC}\n" + if "$@"; then + printf >&2 "${GREEN}[OK]${NC}\n" + else + local exit_code=$? + printf >&2 "${RED}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}\n" + printf >&2 "${RED}[ERROR]${NC} Command failed with exit code %d: ${YELLOW}%s${NC}\n" "$exit_code" "$1" + printf >&2 "${RED} Working dir:${NC} %s\n" "$(pwd)" + printf >&2 "${RED}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}\n" + return "$exit_code" + fi +} + +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +: "${QWEN_TOKENIZER_PATH:?Set the pinned tokenizer directory documented in docs/invalid-token-failure.md}" +QWEN_TOKENIZER_PATH="$(realpath "$QWEN_TOKENIZER_PATH")" +run test -f "$QWEN_TOKENIZER_PATH/tokenizer.json" + +TOKENIZER_ROOT="$QWEN_TOKENIZER_PATH" +if [[ -L "$QWEN_TOKENIZER_PATH/tokenizer.json" ]]; then + TOKENIZER_ROOT="$(realpath "$QWEN_TOKENIZER_PATH/../..")" +fi + +IMAGE='kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404' +run python3 "$ROOT/scripts/verify_responses_compat.py" --tokenizer "$QWEN_TOKENIZER_PATH" +run python3 "$ROOT/scripts/verify_invalid_token_failure.py" +run docker image inspect --format '{{.Id}}' "$IMAGE" +run docker run --rm --pull never --network none --read-only --cap-drop all \ + --security-opt no-new-privileges --cpus 4 --memory 12g --pids-limit 512 \ + --user "$(id -u):$(id -g)" \ + --tmpfs /tmp:rw,exec,size=2g,mode=1777,uid="$(id -u)",gid="$(id -g)" \ + -e CUDA_VISIBLE_DEVICES= -e OMP_NUM_THREADS=1 -e MKL_NUM_THREADS=1 \ + -e HOME=/tmp -e XDG_CACHE_HOME=/tmp/cache -e PYTHONDONTWRITEBYTECODE=1 \ + -e QWEN_TOKENIZER_PATH="$QWEN_TOKENIZER_PATH" \ + -v "$TOKENIZER_ROOT:$TOKENIZER_ROOT:ro" -v "$ROOT:/repo:ro" \ + -v "$ROOT/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py:ro" \ + -v "$ROOT/runtime/python/sglang/srt/entrypoints/openai/protocol.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:ro" \ + -v "$ROOT/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:ro" \ + -v "$ROOT/runtime/python/sglang/srt/entrypoints/openai/responses_compat.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py:ro" \ + -v "$ROOT/runtime/python/sglang/srt/function_call/qwen3_coder_detector.py:/sgl-workspace/sglang/python/sglang/srt/function_call/qwen3_coder_detector.py:ro" \ + -v "$ROOT/runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py:/sgl-workspace/sglang/python/sglang/srt/managers/schedule_batch.py:ro" \ + --entrypoint python3 "$IMAGE" /repo/tests/runtime_invalid_token_failure.py -v diff --git a/scripts/verify_invalid_token_failure.py b/scripts/verify_invalid_token_failure.py new file mode 100755 index 0000000..15fa9db --- /dev/null +++ b/scripts/verify_invalid_token_failure.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 +"""Verify the invalid generated-token failure profile.""" +import argparse +import hashlib +import json +from pathlib import Path +import subprocess + +from verify_chat_effort import verify as verify_chat_effort + +ROOT = Path(__file__).resolve().parents[1] + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def verify_tree_inventory(tree, inventory): + actual = { + str(path.relative_to(tree)) + for path in (tree / "python/sglang").rglob("*") + if path.is_file() and "__pycache__" not in path.parts and path.suffix != ".pyc" + } + if actual != set(inventory): + raise ValueError("Full source inventory differs") + for name, expected in inventory.items(): + if digest(tree / name) != expected: + raise ValueError("Source hash mismatch: " + name) + + +def apply_patch(tree, patch): + subprocess.run(["git", "apply", "--check", str(patch)], cwd=tree, check=True) + subprocess.run(["git", "apply", str(patch)], cwd=tree, check=True) + + +def package_records(): + manifest = json.loads((ROOT / "provenance/invalid-token-failure.json").read_text()) + base_inventory = ROOT / "provenance/responses-compat-runtime-files.json" + if digest(base_inventory) != manifest["base_inventory_sha256"]: + raise ValueError("Base inventory digest mismatch") + inventory = json.loads(base_inventory.read_text()) + responses = json.loads((ROOT / "provenance/responses-compat.json").read_text()) + alias = json.loads((ROOT / "provenance/qwen-effort-alias.json").read_text()) + if responses["inventory_sha256"] != manifest["base_inventory_sha256"]: + raise ValueError("Responses inventory identity mismatch") + for predecessor in (alias, responses): + predecessor_patch = ROOT / "patches" / predecessor["patch"] + if digest(predecessor_patch) != predecessor["patch_sha256"]: + raise ValueError("Predecessor patch hash mismatch") + predecessor_series = (ROOT / "patches/series.responses-compat").read_text().splitlines() + if predecessor_series != [alias["patch"], responses["patch"]]: + raise ValueError("Predecessor patch order differs") + for name in ( + "python/sglang/srt/entrypoints/openai/protocol.py", + "python/sglang/srt/entrypoints/openai/responses_compat.py", + "python/sglang/srt/function_call/qwen3_coder_detector.py", + ): + if digest(ROOT / "runtime" / name) != inventory[name]: + raise ValueError("Packaged predecessor runtime mismatch: " + name) + for name, hashes in manifest["files"].items(): + if inventory.get(name) != hashes["before"]: + raise ValueError("Invalid-token preimage mismatch: " + name) + if digest(ROOT / "runtime.invalid-token-failure" / name) != hashes["after"]: + raise ValueError("Packaged runtime mismatch: " + name) + inventory[name] = hashes["after"] + patch = ROOT / "patches" / manifest["patch"] + if digest(patch) != manifest["patch_sha256"]: + raise ValueError("Invalid-token patch hash mismatch") + series = (ROOT / "patches/series.invalid-token-failure").read_text().splitlines() + if series != [ + "0015-qwen-flash-next-effort-alias.patch", + "0016-responses-namespace-custom-boundary.patch", + manifest["patch"], + ]: + raise ValueError("Invalid-token patch order differs") + encoded = (json.dumps(dict(sorted(inventory.items())), indent=2) + "\n").encode() + if hashlib.sha256(encoded).hexdigest() != manifest["result_inventory_sha256"]: + raise ValueError("Result inventory digest mismatch") + return manifest, inventory + + +def verify(tree, apply=False, from_image=False): + manifest, inventory = package_records() + base_inventory = json.loads( + (ROOT / "provenance/responses-compat-runtime-files.json").read_text() + ) + if from_image: + verify_chat_effort(tree) + for name in ( + "0015-qwen-flash-next-effort-alias.patch", + "0016-responses-namespace-custom-boundary.patch", + ): + apply_patch(tree, ROOT / "patches" / name) + verify_tree_inventory(tree, base_inventory) + elif apply: + verify_tree_inventory(tree, base_inventory) + if apply or from_image: + apply_patch(tree, ROOT / "patches" / manifest["patch"]) + verify_tree_inventory(tree, inventory) + return len(inventory) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--tree", type=Path) + actions = parser.add_mutually_exclusive_group() + actions.add_argument("--apply", action="store_true") + actions.add_argument("--from-image", action="store_true") + args = parser.parse_args() + if (args.apply or args.from_image) and args.tree is None: + parser.error("Application requires --tree") + count = ( + verify(args.tree.resolve(), args.apply, args.from_image) + if args.tree + else len(package_records()[1]) + ) + print( + json.dumps( + { + "profile": "invalid-token-failure", + "source_files": count, + "full_tree_verified": args.tree is not None, + } + ) + ) diff --git a/tests/runtime_invalid_token_failure.py b/tests/runtime_invalid_token_failure.py new file mode 100644 index 0000000..5ce5492 --- /dev/null +++ b/tests/runtime_invalid_token_failure.py @@ -0,0 +1,271 @@ +"""CPU regressions for out-of-vocabulary generated token failures.""" +import asyncio +from array import array +from http import HTTPStatus +import json +from types import SimpleNamespace +import unittest + +from fastapi import HTTPException + +from runtime_chat_effort import ChatEffortTest +from sglang.srt.entrypoints.anthropic.protocol import AnthropicMessagesRequest +from sglang.srt.entrypoints.anthropic.serving import AnthropicServing +from sglang.srt.entrypoints.context import SimpleContext +from sglang.srt.entrypoints.openai.protocol import ( + ChatCompletionRequest, + RequestResponseMetadata, + ResponsesRequest, +) +from sglang.srt.entrypoints.openai.serving_responses import OpenAIServingResponses +from sglang.srt.managers.schedule_batch import Req +from sglang.srt.managers.tokenizer_manager import TokenizerManager + + +def scheduled(ids, cap=20, eos=True, accepted=None): + req = Req.__new__(Req) + req.output_ids = array("q", ids) + req.vocab_size = 100 + req.sampling_params = SimpleNamespace( + stop_token_ids={2} if eos else set(), + max_new_tokens=cap, + stop_strs=[], + stop_regex_strs=[], + ignore_eos=False, + ) + req.eos_token_ids = {2} if eos else set() + req.finished_reason = None + req.finished_len = None + req.to_finish = None + req.grammar = None + req.tokenizer = None + req.update_finish_state(new_accepted_len=accepted or len(ids)) + return req + + +def invalid_finish(serialized=False): + finish = { + "type": "abort", + "message": "Generation produced an invalid token ID.", + "status_code": HTTPStatus.INTERNAL_SERVER_ERROR, + "err_type": "InvalidTokenError", + } + if serialized: + finish["status_code"] = int(finish["status_code"]) + return finish + + +def engine_chunk(finish): + return { + "text": "Planning only.", + "output_ids": [5], + "meta_info": { + "id": "fixture-rid", + "prompt_tokens": 3, + "completion_tokens": 1, + "cached_tokens": 0, + "reasoning_tokens": 1, + "finish_reason": finish, + }, + } + + +def data_payloads(frames): + return [ + json.loads(line[6:]) + for frame in frames + for line in frame.splitlines() + if line.startswith("data: ") and line != "data: [DONE]" + ] + + +class InvalidTokenFailureTest(unittest.TestCase): + setUpClass = classmethod(ChatEffortTest.setUpClass.__func__) + + def setUp(self): + ChatEffortTest.setUp(self) + manager = self.chat.tokenizer_manager + manager.model_config.hf_config.model_type = "qwen3_8_flash_next" + manager.model_config.context_len = 32768 + manager.num_reserved_tokens = 0 + manager.server_args.incremental_streaming_output = False + self.responses = OpenAIServingResponses(manager, self.chat.template_manager) + self.responses.reasoning_parser = None + self.responses.tool_call_parser = None + + def test_invalid_token_is_failure_even_past_length_cap(self): + for bad_id in (-1, 100, 123456): + for cap in (1, 2, 20): + for eos in (False, True): + with self.subTest(bad_id=bad_id, cap=cap, eos=eos): + req = scheduled([5, 6, bad_id, 9], cap, eos) + finish = req.finished_reason.to_json() + self.assertEqual(finish["type"], "abort") + self.assertEqual( + finish["status_code"], HTTPStatus.INTERNAL_SERVER_ERROR + ) + self.assertEqual(finish["err_type"], "InvalidTokenError") + self.assertEqual(list(req.output_ids_through_stop), [5, 6][:cap]) + + def test_invalid_first_token_never_reaches_decode(self): + req = scheduled([-1], eos=False) + self.assertEqual(list(req.output_ids_through_stop), []) + self.assertEqual(req.finished_reason.to_json()["type"], "abort") + + def test_ordinary_scheduler_finishes_are_unchanged(self): + for ids, cap, expected in ( + ([5, 2], 20, "stop"), + ([5, 6, 2], 1, "length"), + ([5, 6], 2, "length"), + ([5, 6], 20, None), + ): + with self.subTest(ids=ids, cap=cap): + req = scheduled(ids, cap) + actual = ( + req.finished_reason.to_json()["type"] + if req.finished_reason + else None + ) + self.assertEqual(actual, expected) + + def test_abort_cleanup_handles_serialized_status(self): + for is_stream in (False, True): + with self.subTest(is_stream=is_stream): + item = engine_chunk(invalid_finish(serialized=True)) + manager = SimpleNamespace( + rid_to_state={"fixture-rid": object()}, enable_lora=False + ) + state = SimpleNamespace(obj=SimpleNamespace(rid="fixture-rid")) + + async def run(): + return await TokenizerManager._handle_abort_finish_reason( + manager, item, state, is_stream + ) + + if is_stream: + self.assertIs(asyncio.run(run()), item) + else: + with self.assertRaises(HTTPException) as raised: + asyncio.run(run()) + self.assertEqual(raised.exception.status_code, 500) + self.assertNotIn("fixture-rid", manager.rid_to_state) + + def test_chat_and_messages_stream_serialized_failure(self): + finish = invalid_finish(serialized=True) + + async def generate(*args, **kwargs): + yield engine_chunk(finish) + + self.chat.tokenizer_manager.generate_request = generate + adapted = SimpleNamespace(rid="fixture-rid") + chat_request = ChatCompletionRequest( + model="fixture-qwen", + messages=[{"role": "user", "content": "Hi"}], + stream=True, + ) + + async def collect_chat(): + return [ + frame + async for frame in self.chat._generate_chat_stream( + adapted, chat_request, None + ) + ] + + chat_frames = asyncio.run(collect_chat()) + self.assertEqual(chat_frames[-1], "data: [DONE]\n\n") + chat_payloads = data_payloads(chat_frames) + self.assertEqual(chat_payloads[-1]["error"]["code"], 500) + + anthropic_request = AnthropicMessagesRequest( + model="fixture-qwen", + messages=[{"role": "user", "content": "Hi"}], + max_tokens=64, + stream=True, + ) + anthropic = AnthropicServing(self.chat) + + async def collect_messages(): + return [ + frame + async for frame in anthropic._generate_anthropic_stream( + adapted, chat_request, anthropic_request, None + ) + ] + + message_payloads = data_payloads(asyncio.run(collect_messages())) + self.assertTrue( + any( + payload.get("type") == "error" + and payload["error"]["type"] == "api_error" + for payload in message_payloads + ) + ) + + def test_responses_full_and_stream_expose_failure(self): + finish = invalid_finish(serialized=True) + chunk = engine_chunk(finish) + request = ResponsesRequest( + model="fixture-qwen", input="Hi", stream=False, store=True + ) + metadata = RequestResponseMetadata(request_id=request.request_id) + context = SimpleContext() + + async def full_result(): + context.append_output(chunk) + yield context + + response = asyncio.run( + self.responses.responses_full_generator( + request, + {}, + full_result(), + context, + "fixture-qwen", + self.chat.tokenizer_manager.tokenizer, + metadata, + require_reasoning=False, + ) + ) + self.assertEqual(response.status, "failed") + self.assertEqual(response.error["code"], "server_error") + self.assertIn("invalid token ID", response.error["message"]) + + stream_request = ResponsesRequest( + model="fixture-qwen", input="Hi", stream=True, store=True + ) + stream_metadata = RequestResponseMetadata(request_id=stream_request.request_id) + + async def stream_result(): + yield chunk + + async def collect_responses(): + return [ + frame + async for frame in self.responses.responses_stream_generator_non_harmony( + stream_request, + {}, + stream_result(), + "fixture-qwen", + self.chat.tokenizer_manager.tokenizer, + stream_metadata, + require_reasoning=False, + ) + ] + + events = data_payloads(asyncio.run(collect_responses())) + self.assertEqual(events[-1]["type"], "response.failed") + self.assertEqual(events[-1]["response"]["status"], "failed") + self.assertIn( + "invalid token ID", events[-1]["response"]["error"]["message"] + ) + self.assertFalse(any(event["type"] == "response.completed" for event in events)) + + def test_graceful_abort_remains_cancelled(self): + finish = {"type": "abort", "message": "Request cancelled."} + self.assertEqual(self.responses._status_from_finish_reason(finish), "cancelled") + self.assertIsNone(self.responses._error_from_finish_reason(finish)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_invalid_token_packaging.py b/tests/test_invalid_token_packaging.py new file mode 100644 index 0000000..ccc6ee0 --- /dev/null +++ b/tests/test_invalid_token_packaging.py @@ -0,0 +1,58 @@ +"""Fail-closed packaging tests for invalid generated-token failures.""" +import importlib.util +from pathlib import Path +import sys +import unittest +from unittest.mock import patch + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "scripts")) +spec = importlib.util.spec_from_file_location( + "invalid_token_verifier", ROOT / "scripts/verify_invalid_token_failure.py" +) +verifier = importlib.util.module_from_spec(spec) +spec.loader.exec_module(verifier) + + +class InvalidTokenPackagingTest(unittest.TestCase): + def test_manifest_chain_and_runtime_compile(self): + manifest, inventory = verifier.package_records() + self.assertEqual(len(inventory), 4392) + self.assertEqual( + list(manifest["files"]), + [ + "python/sglang/srt/entrypoints/openai/serving_chat.py", + "python/sglang/srt/entrypoints/openai/serving_responses.py", + "python/sglang/srt/managers/schedule_batch.py", + ], + ) + for name in manifest["files"]: + compile( + (ROOT / "runtime.invalid-token-failure" / name).read_bytes(), + name, + "exec", + ) + + def test_runtime_drift_fails_closed(self): + original = verifier.digest + + def changed(path): + if path.name == "schedule_batch.py": + return "0" * 64 + return original(path) + + with patch.object(verifier, "digest", side_effect=changed): + with self.assertRaisesRegex(ValueError, "Packaged runtime mismatch"): + verifier.package_records() + + def test_patch_drift_fails_closed(self): + original = verifier.digest + + def changed(path): + if path.name.startswith("0019-"): + return "0" * 64 + return original(path) + + with patch.object(verifier, "digest", side_effect=changed): + with self.assertRaisesRegex(ValueError, "patch hash mismatch"): + verifier.package_records() From eebf6b59faed889791e0992873b109ff28bd91c8 Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 12:13:07 +0100 Subject: [PATCH 16/20] fix(runtime): complete invalid token failure propagation --- Dockerfile.invalid-token-failure | 3 +- .../srt/entrypoints/openai/serving_chat.py | 11 +- .../entrypoints/openai/serving_completions.py | 648 ++++++++++++++++++ .../entrypoints/openai/serving_responses.py | 16 + scripts/test_invalid_token_failure.sh | 1 + tests/runtime_invalid_token_failure.py | 120 ++++ 6 files changed, 792 insertions(+), 7 deletions(-) create mode 100644 runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py diff --git a/Dockerfile.invalid-token-failure b/Dockerfile.invalid-token-failure index 9021fab..fcc1da9 100644 --- a/Dockerfile.invalid-token-failure +++ b/Dockerfile.invalid-token-failure @@ -8,8 +8,9 @@ COPY runtime/python/sglang/srt/entrypoints/openai/protocol.py /sgl-workspace/sgl COPY runtime/python/sglang/srt/entrypoints/openai/responses_compat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py COPY runtime/python/sglang/srt/function_call/qwen3_coder_detector.py /sgl-workspace/sglang/python/sglang/srt/function_call/qwen3_coder_detector.py COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py +COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_completions.py COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py COPY runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py /sgl-workspace/sglang/python/sglang/srt/managers/schedule_batch.py -RUN python3 -B -c 'import pathlib; p=pathlib.Path("/sgl-workspace/sglang/python/sglang/srt"); files=[p/"entrypoints/openai"/n for n in ("serving_chat.py", "protocol.py", "serving_responses.py", "responses_compat.py")]+[p/"function_call/qwen3_coder_detector.py", p/"managers/schedule_batch.py"]; [compile(f.read_bytes(), str(f), "exec") for f in files]' +RUN python3 -B -c 'import pathlib; p=pathlib.Path("/sgl-workspace/sglang/python/sglang/srt"); files=[p/"entrypoints/openai"/n for n in ("serving_chat.py", "serving_completions.py", "protocol.py", "serving_responses.py", "responses_compat.py")]+[p/"function_call/qwen3_coder_detector.py", p/"managers/schedule_batch.py"]; [compile(f.read_bytes(), str(f), "exec") for f in files]' ENTRYPOINT ["python3", "-m", "sglang.launch_server"] CMD ["--help"] diff --git a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py index b36e796..74415ba 100644 --- a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py +++ b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py @@ -1617,14 +1617,13 @@ async def _generate_chat_stream( # /abort_request or session lifecycle cleanup) falls through # to the normal chunk path, matching the non-stream behavior # in tokenizer_manager._handle_abort_finish_reason. - if finish_reason_type == "abort" and isinstance( - finish_reason.get("status_code"), int - ): - code = HTTPStatus(finish_reason["status_code"]) + status_code = finish_reason.get("status_code") + if finish_reason_type == "abort" and isinstance(status_code, int): error = self.create_streaming_error_response( finish_reason.get("message", "Generation aborted."), - code.name, - code.value, + finish_reason.get("err_type") + or HTTPStatus(status_code).name, + status_code, ) yield f"data: {error}\n\n" yield "data: [DONE]\n\n" diff --git a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py new file mode 100644 index 0000000..1f70108 --- /dev/null +++ b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py @@ -0,0 +1,648 @@ +from __future__ import annotations + +import logging +import time +from http import HTTPStatus +from typing import TYPE_CHECKING, Any, AsyncGenerator, Dict, List, Optional, Union + +from fastapi import Request +from fastapi.responses import ORJSONResponse, StreamingResponse + +from sglang.srt.entrypoints.openai.protocol import ( + CompletionRequest, + CompletionResponse, + CompletionResponseChoice, + CompletionResponseStreamChoice, + CompletionStreamResponse, + ErrorResponse, + SglExt, +) +from sglang.srt.entrypoints.openai.serving_base import OpenAIServingBase +from sglang.srt.entrypoints.openai.usage_processor import UsageProcessor +from sglang.srt.entrypoints.openai.utils import ( + cached_tokens_details_from_dict, + process_cached_tokens_details_from_ret, + process_hidden_states_for_response, + process_hidden_states_from_ret, + process_routed_experts_from_ret, + should_include_usage, + to_openai_style_logprobs, +) +from sglang.srt.managers.io_struct import GenerateReqInput +from sglang.srt.parser.code_completion_parser import ( + generate_completion_prompt_from_request, +) +from sglang.utils import convert_json_schema_to_str + +if TYPE_CHECKING: + from sglang.srt.managers.tokenizer_manager import TokenizerManager + from sglang.srt.parser.template_manager import TemplateManager + +logger = logging.getLogger(__name__) + + +class OpenAIServingCompletion(OpenAIServingBase): + """Handler for /v1/completion requests""" + + def __init__( + self, + tokenizer_manager: TokenizerManager, + template_manager: TemplateManager, + ): + super().__init__(tokenizer_manager) + self.template_manager = template_manager + + def _request_id_prefix(self) -> str: + return "cmpl-" + + def _validate_request(self, request: CompletionRequest) -> Optional[str]: + """Validate that the input is valid.""" + prompt = request.prompt + if not prompt or (isinstance(prompt, list) and all(not p for p in prompt)): + return "Prompt cannot be empty" + + return None + + def _convert_to_internal_request( + self, + request: CompletionRequest, + raw_request: Request = None, + ) -> tuple[GenerateReqInput, CompletionRequest]: + """Convert OpenAI completion request to internal format""" + # NOTE: with openai API, the prompt's logprobs are always not computed + if request.echo and request.logprobs: + logger.warning( + "Echo is not compatible with logprobs. " + "To compute logprobs of input prompt, please use the native /generate API." + ) + # Process prompt + prompt = request.prompt + if self.template_manager.completion_template_name is not None: + prompt = generate_completion_prompt_from_request(request) + + # Set logprob start length based on echo and logprobs + if request.echo and request.logprobs: + logprob_start_len = 0 + else: + logprob_start_len = -1 + + # Build sampling parameters + sampling_params = self._build_sampling_params(request) + + # Determine prompt format + if isinstance(prompt, str) or ( + isinstance(prompt, list) and isinstance(prompt[0], str) + ): + prompt_kwargs = {"text": prompt} + else: + prompt_kwargs = {"input_ids": prompt} + + # Extract custom labels from raw request headers + custom_labels = self.extract_custom_labels(raw_request) + + # Extract routed_dp_rank from header (has higher priority than body) + effective_routed_dp_rank = self.extract_routed_dp_rank_from_header( + raw_request, request.routed_dp_rank + ) + + # Resolve LoRA adapter from model parameter or explicit lora_path + lora_path = self._resolve_lora_path(request.model, request.lora_path) + + adapted_request = GenerateReqInput( + **prompt_kwargs, + sampling_params=sampling_params, + return_logprob=request.logprobs is not None, + top_logprobs_num=request.logprobs if request.logprobs is not None else 0, + logprob_start_len=logprob_start_len, + return_text_in_logprobs=True, + stream=request.stream, + lora_path=lora_path, + bootstrap_host=request.bootstrap_host, + bootstrap_port=request.bootstrap_port, + bootstrap_room=request.bootstrap_room, + routed_dp_rank=effective_routed_dp_rank, + disagg_prefill_dp_rank=request.disagg_prefill_dp_rank, + return_hidden_states=request.return_hidden_states, + return_routed_experts=request.return_routed_experts, + routed_experts_start_len=request.routed_experts_start_len, + return_prompt_token_ids=request.return_token_ids, + rid=request.rid, + session_id=request.session_id, + extra_key=request.extra_key, + cache_salt=request.cache_salt, + priority=request.priority, + routing_key=self.extract_routing_key(raw_request), + custom_labels=custom_labels, + custom_logit_processor=request.custom_logit_processor, + images_config=getattr(request, "images_config", None), + ) + + return adapted_request, request + + def _build_sampling_params(self, request: CompletionRequest) -> Dict[str, Any]: + """Build sampling parameters for the request""" + # Start with common parameters + sampling_params = { + "temperature": request.temperature, + "max_new_tokens": request.max_tokens, + "min_new_tokens": request.min_tokens, + "stop": request.stop, + "stop_token_ids": request.stop_token_ids, + "stop_regex": request.stop_regex, + "top_p": request.top_p, + "top_k": request.top_k, + "min_p": request.min_p, + "presence_penalty": request.presence_penalty, + "frequency_penalty": request.frequency_penalty, + "repetition_penalty": request.repetition_penalty, + "regex": request.regex, + "json_schema": request.json_schema, + "ebnf": request.ebnf, + "n": request.n, + "no_stop_trim": request.no_stop_trim, + "ignore_eos": request.ignore_eos, + "skip_special_tokens": request.skip_special_tokens, + "logit_bias": request.logit_bias, + "custom_params": request.custom_params, + "sampling_seed": request.seed, + } + + # Handle response_format constraints + if request.response_format and request.response_format.type == "json_schema": + json_schema = request.response_format.json_schema + schema = getattr(json_schema, "schema_", None) + if schema is None: + raise ValueError( + "schema_ is required for json_schema response format request." + ) + sampling_params["json_schema"] = convert_json_schema_to_str(schema) + elif request.response_format and request.response_format.type == "json_object": + sampling_params["json_schema"] = '{"type": "object"}' + elif ( + request.response_format and request.response_format.type == "structural_tag" + ): + sampling_params["structural_tag"] = convert_json_schema_to_str( + request.response_format.model_dump(by_alias=True) + ) + + return sampling_params + + async def _handle_streaming_request( + self, + adapted_request: GenerateReqInput, + request: CompletionRequest, + raw_request: Request, + ) -> Union[StreamingResponse, ErrorResponse]: + """Handle streaming completion request""" + generator = self._generate_completion_stream( + adapted_request, request, raw_request + ) + + # Kick-start the generator to trigger validation before HTTP 200 is sent. + try: + first_chunk = await generator.__anext__() + except ValueError as e: + return self.create_error_response(str(e)) + + async def prepend_first_chunk(): + yield first_chunk + async for chunk in generator: + yield chunk + + return StreamingResponse( + prepend_first_chunk(), + media_type="text/event-stream", + background=self.tokenizer_manager.create_abort_task(adapted_request), + ) + + async def _generate_completion_stream( + self, + adapted_request: GenerateReqInput, + request: CompletionRequest, + raw_request: Request, + ) -> AsyncGenerator[str, None]: + """Generate streaming completion response""" + created = int(time.time()) + + # State tracking for streaming + stream_offsets = {} + n_prev_tokens = {} + n_prev_token_ids = {} + + # Usage tracking + prompt_tokens = {} + completion_tokens = {} + reasoning_tokens = {} + cached_tokens = {} + hidden_states = {} + routed_experts = {} + cached_tokens_details = {} + + stream_started = False + try: + include_usage, continuous_usage_stats = should_include_usage( + request.stream_options, + self.tokenizer_manager.server_args.stream_response_default_include_usage, + ) + + async for content in self.tokenizer_manager.generate_request( + adapted_request, raw_request + ): + index = content.get("index", 0) + + text = content["text"] + prompt_tokens[index] = content["meta_info"].get("prompt_tokens", 0) + completion_tokens[index] = content["meta_info"].get( + "completion_tokens", 0 + ) + reasoning_tokens[index] = content["meta_info"].get( + "reasoning_tokens", 0 + ) + cached_tokens[index] = content["meta_info"].get("cached_tokens", 0) + hidden_states[index] = content["meta_info"].get("hidden_states", None) + routed_experts[index] = content["meta_info"].get("routed_experts", None) + cached_tokens_details[index] = content["meta_info"].get( + "cached_tokens_details", None + ) + + is_first_chunk = index not in stream_offsets + offset = stream_offsets.get(index, 0) + # Handle echo for first chunk + if is_first_chunk: # The first chunk + if request.echo: + echo_text = self._get_echo_text(request, index) + text = echo_text + text + + # Handle logprobs + logprobs = None + if request.logprobs is not None: + # The first chunk and echo is enabled. + if is_first_chunk and request.echo: + input_token_logprobs = content["meta_info"][ + "input_token_logprobs" + ] + input_top_logprobs = content["meta_info"]["input_top_logprobs"] + else: + input_token_logprobs = None + input_top_logprobs = None + + n_prev_token = n_prev_tokens.get(index, 0) + total_output_logprobs = content["meta_info"][ + "output_token_logprobs_length" + ] + if ( + n_prev_token < total_output_logprobs + or input_token_logprobs is not None + ): + output_token_logprobs = content["meta_info"][ + "output_token_logprobs" + ] + output_top_logprobs = content["meta_info"].get( + "output_top_logprobs", [] + ) + if ( + not self.tokenizer_manager.server_args.incremental_streaming_output + ): + output_token_logprobs = output_token_logprobs[ + n_prev_token:total_output_logprobs + ] + output_top_logprobs = output_top_logprobs[ + n_prev_token:total_output_logprobs + ] + logprobs = to_openai_style_logprobs( + input_token_logprobs=input_token_logprobs, + input_top_logprobs=input_top_logprobs, + output_token_logprobs=output_token_logprobs, + output_top_logprobs=output_top_logprobs, + ) + n_prev_tokens[index] = total_output_logprobs + + chunk_token_ids = None + chunk_prompt_token_ids = None + if request.return_token_ids: + output_ids = content["output_ids"] + if ( + not self.tokenizer_manager.server_args.incremental_streaming_output + ): + n_prev_token_id = n_prev_token_ids.get(index, 0) + chunk_token_ids = output_ids[n_prev_token_id:] + n_prev_token_ids[index] = len(output_ids) + else: + chunk_token_ids = output_ids + if is_first_chunk: + chunk_prompt_token_ids = content.get("prompt_token_ids") + + # Generate delta + if self.tokenizer_manager.server_args.incremental_streaming_output: + delta = text + else: + delta = text[offset:] + stream_offsets[index] = len(content["text"]) + finish_reason = content["meta_info"].get("finish_reason", None) + finish_reason_type = finish_reason["type"] if finish_reason else None + + # Abort with an explicit error status_code is a system error + # (timeout, OOM, validation): emit a streaming error chunk. + # A graceful abort (no status_code, e.g. user-initiated via + # /abort_request or session lifecycle cleanup) falls through + # to the normal chunk path, matching the non-stream behavior + # in tokenizer_manager._handle_abort_finish_reason. + status_code = ( + finish_reason.get("status_code") if finish_reason else None + ) + if finish_reason_type == "abort" and isinstance(status_code, int): + error = self.create_streaming_error_response( + finish_reason.get("message", "Generation aborted."), + finish_reason.get("err_type") + or HTTPStatus(status_code).name, + status_code, + ) + yield f"data: {error}\n\n" + yield "data: [DONE]\n\n" + return + + choice_data = CompletionResponseStreamChoice( + index=index, + text=delta, + logprobs=logprobs, + finish_reason=finish_reason_type, + matched_stop=( + finish_reason["matched"] + if finish_reason and "matched" in finish_reason + else None + ), + token_ids=chunk_token_ids, + prompt_token_ids=chunk_prompt_token_ids, + ) + chunk = CompletionStreamResponse( + id=content["meta_info"]["id"], + created=created, + object="text_completion", + choices=[choice_data], + model=request.model, + ) + + # Add usage stats if continuous_usage_stats is enabled + if continuous_usage_stats: + chunk.usage = UsageProcessor.calculate_token_usage( + prompt_tokens=prompt_tokens.get(index, 0), + completion_tokens=completion_tokens.get(index, 0), + reasoning_tokens=reasoning_tokens.get(index, 0), + ) + + yield f"data: {chunk.model_dump_json()}\n\n" + stream_started = True + + if request.return_hidden_states and hidden_states: + for index, choice_hidden_states in hidden_states.items(): + if choice_hidden_states: + response_hidden_states = process_hidden_states_for_response( + choice_hidden_states, request.return_hidden_states + ) + hidden_states_chunk = CompletionStreamResponse( + id=content["meta_info"]["id"], + created=created, + object="text_completion", + choices=[ + CompletionResponseStreamChoice( + index=index, + text="", + hidden_states=response_hidden_states, + finish_reason=None, + ) + ], + model=request.model, + ) + yield f"data: {hidden_states_chunk.model_dump_json()}\n\n" + + sglext_routed = None + if request.return_routed_experts and routed_experts: + sglext_routed = next( + (v for v in routed_experts.values() if v is not None), None + ) + + sglext_details = None + if request.return_cached_tokens_details and cached_tokens_details: + first_details = next( + (v for v in cached_tokens_details.values() if v is not None), None + ) + if first_details is not None: + sglext_details = cached_tokens_details_from_dict(first_details) + + if sglext_routed is not None or sglext_details is not None: + sglext_chunk = CompletionStreamResponse( + id=content["meta_info"]["id"], + created=created, + object="text_completion", + choices=[], # sglext is at response level + model=request.model, + sglext=SglExt( + routed_experts=sglext_routed, + cached_tokens_details=sglext_details, + ), + ) + yield f"data: {sglext_chunk.model_dump_json()}\n\n" + + # Handle final usage chunk + if include_usage: + usage = UsageProcessor.calculate_streaming_usage( + prompt_tokens, + reasoning_tokens, + completion_tokens, + cached_tokens=cached_tokens, + n_choices=request.n, + enable_cache_report=self.tokenizer_manager.server_args.enable_cache_report, + ) + final_usage_chunk = CompletionStreamResponse( + id=content["meta_info"]["id"], + created=created, + choices=[], + model=request.model, + usage=usage, + ) + final_usage_data = final_usage_chunk.model_dump_json(exclude_none=True) + yield f"data: {final_usage_data}\n\n" + + except Exception as e: + if not stream_started: + raise + error = self.create_streaming_error_response(str(e)) + yield f"data: {error}\n\n" + + yield "data: [DONE]\n\n" + + async def _handle_non_streaming_request( + self, + adapted_request: GenerateReqInput, + request: CompletionRequest, + raw_request: Request, + ) -> Union[CompletionResponse, ErrorResponse, ORJSONResponse]: + """Handle non-streaming completion request""" + try: + generator = self.tokenizer_manager.generate_request( + adapted_request, raw_request + ) + ret = await generator.__anext__() + except ValueError as e: + return self.create_error_response(str(e)) + + if not isinstance(ret, list): + ret = [ret] + + response = self._build_completion_response( + request, + ret, + int(time.time()), + ) + + return response + + def _build_completion_response( + self, + request: CompletionRequest, + ret: List[Dict[str, Any]], + created: int, + ) -> CompletionResponse: + """Build completion response from generation results""" + choices = [] + echo = False + + # Prepare echo prompts if needed + echo_prompts = [] + if request.echo: + echo_prompts = self._prepare_echo_prompts(request) + echo = True + + # Build sglext at response level (from first ret_item, as these are per-request) + first_ret = ret[0] + routed_experts = process_routed_experts_from_ret(first_ret, request) + cached_tokens_details = process_cached_tokens_details_from_ret( + first_ret, request + ) + response_sglext = None + if routed_experts or cached_tokens_details: + response_sglext = SglExt( + routed_experts=routed_experts, + cached_tokens_details=cached_tokens_details, + ) + + for idx, ret_item in enumerate(ret): + text = ret_item["text"] + + # Handle echo + if echo: + prompt_index = idx // request.n + text = echo_prompts[prompt_index] + text + + # Handle logprobs + logprobs = None + if request.logprobs is not None: + if echo: + input_token_logprobs = ret_item["meta_info"]["input_token_logprobs"] + input_top_logprobs = ret_item["meta_info"]["input_top_logprobs"] + else: + input_token_logprobs = None + input_top_logprobs = None + + logprobs = to_openai_style_logprobs( + input_token_logprobs=input_token_logprobs, + input_top_logprobs=input_top_logprobs, + output_token_logprobs=ret_item["meta_info"].get( + "output_token_logprobs", [] + ), + output_top_logprobs=ret_item["meta_info"].get( + "output_top_logprobs", [] + ), + ) + + # Handle hidden states + hidden_states = process_hidden_states_from_ret(ret_item, request) + + finish_reason = ret_item["meta_info"]["finish_reason"] + + choice_data = CompletionResponseChoice( + index=idx, + text=text, + logprobs=logprobs, + finish_reason=finish_reason["type"] if finish_reason else None, + matched_stop=( + finish_reason["matched"] + if finish_reason and "matched" in finish_reason + else None + ), + hidden_states=hidden_states, + token_ids=( + ret_item["output_ids"] if request.return_token_ids else None + ), + prompt_token_ids=( + ret_item.get("prompt_token_ids") + if request.return_token_ids + else None + ), + ) + choices.append(choice_data) + + # Calculate usage + cache_report = self.tokenizer_manager.server_args.enable_cache_report + usage = UsageProcessor.calculate_response_usage( + ret, n_choices=request.n, enable_cache_report=cache_report + ) + + return CompletionResponse( + id=ret[0]["meta_info"]["id"], + model=request.model, + created=created, + choices=choices, + usage=usage, + metadata={"weight_version": ret[0]["meta_info"]["weight_version"]}, + sglext=response_sglext, + ) + + def _get_echo_text(self, request: CompletionRequest, index: int) -> str: + """Get echo text for streaming response""" + if isinstance(request.prompt, str): + # for the case of single str prompts + return request.prompt + elif isinstance(request.prompt, list): + if isinstance(request.prompt[0], str): + # for the case of multiple str prompts + return request.prompt[index // request.n] + elif isinstance(request.prompt[0], int): + # for the case of single token ids prompt + return self.tokenizer_manager.tokenizer.decode( + request.prompt, skip_special_tokens=True + ) + elif isinstance(request.prompt[0], list) and isinstance( + request.prompt[0][0], int + ): + # for the case of multiple token ids prompts + return self.tokenizer_manager.tokenizer.decode( + request.prompt[index // request.n], + skip_special_tokens=True, + ) + return "" + + def _prepare_echo_prompts(self, request: CompletionRequest) -> List[str]: + """Prepare echo prompts for non-streaming response""" + # TODO: handle the case prompt is token ids + if isinstance(request.prompt, list) and isinstance(request.prompt[0], str): + # for the case of multiple str prompts + return request.prompt + elif isinstance(request.prompt, list) and isinstance(request.prompt[0], list): + # for the case of multiple token ids prompts + return [ + self.tokenizer_manager.tokenizer.decode( + prompt, skip_special_tokens=True + ) + for prompt in request.prompt + ] + elif isinstance(request.prompt, list) and isinstance(request.prompt[0], int): + # for the case of single token ids prompt + return [ + self.tokenizer_manager.tokenizer.decode( + request.prompt, skip_special_tokens=True + ) + ] + else: + # for the case of single str prompt + return [request.prompt] diff --git a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py index 13d46cb..05742d5 100644 --- a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -251,6 +251,10 @@ async def create_responses( async with self.response_store_lock: previous = self.response_store.get(request.previous_response_id) previous_registry = self._compat_registries.get(request.previous_response_id) + if previous is not None and previous.status == "failed": + return self._make_failed_previous_response_error( + request.previous_response_id + ) if previous is not None and previous_registry is not None: registry.inherit_history(previous_registry, previous.output) internal = request.model_dump(by_alias=True) @@ -353,6 +357,8 @@ async def _create_responses_internal( prev_response = self.response_store.get(prev_response_id) if prev_response is None: return self._make_not_found_error(prev_response_id) + if prev_response.status == "failed": + return self._make_failed_previous_response_error(prev_response_id) else: prev_response = None @@ -1578,6 +1584,16 @@ def _make_not_found_error(self, response_id: str): param="response_id", ) + def _make_failed_previous_response_error(self, response_id: str): + return self.create_error_response( + message=( + f"Response with id '{response_id}' cannot be used as a previous " + "response because its status is 'failed'." + ), + err_type="invalid_request_error", + param="previous_response_id", + ) + async def responses_stream_generator( self, request: ResponsesRequest, diff --git a/scripts/test_invalid_token_failure.sh b/scripts/test_invalid_token_failure.sh index 88e326a..38b5d2a 100755 --- a/scripts/test_invalid_token_failure.sh +++ b/scripts/test_invalid_token_failure.sh @@ -46,6 +46,7 @@ run docker run --rm --pull never --network none --read-only --cap-drop all \ -e HOME=/tmp -e XDG_CACHE_HOME=/tmp/cache -e PYTHONDONTWRITEBYTECODE=1 \ -e QWEN_TOKENIZER_PATH="$QWEN_TOKENIZER_PATH" \ -v "$TOKENIZER_ROOT:$TOKENIZER_ROOT:ro" -v "$ROOT:/repo:ro" \ + -v "$ROOT/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_completions.py:ro" \ -v "$ROOT/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py:ro" \ -v "$ROOT/runtime/python/sglang/srt/entrypoints/openai/protocol.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:ro" \ -v "$ROOT/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:ro" \ diff --git a/tests/runtime_invalid_token_failure.py b/tests/runtime_invalid_token_failure.py index 5ce5492..f7e73ba 100644 --- a/tests/runtime_invalid_token_failure.py +++ b/tests/runtime_invalid_token_failure.py @@ -14,9 +14,11 @@ from sglang.srt.entrypoints.context import SimpleContext from sglang.srt.entrypoints.openai.protocol import ( ChatCompletionRequest, + CompletionRequest, RequestResponseMetadata, ResponsesRequest, ) +from sglang.srt.entrypoints.openai.serving_completions import OpenAIServingCompletion from sglang.srt.entrypoints.openai.serving_responses import OpenAIServingResponses from sglang.srt.managers.schedule_batch import Req from sglang.srt.managers.tokenizer_manager import TokenizerManager @@ -89,10 +91,24 @@ def setUp(self): manager.model_config.context_len = 32768 manager.num_reserved_tokens = 0 manager.server_args.incremental_streaming_output = False + self.completions = OpenAIServingCompletion(manager, self.chat.template_manager) self.responses = OpenAIServingResponses(manager, self.chat.template_manager) self.responses.reasoning_parser = None self.responses.tool_call_parser = None + def _store_failed_response(self): + request = ResponsesRequest( + model="fixture-qwen", input="Hi", stream=False, store=True + ) + + async def generate(*args, **kwargs): + yield engine_chunk(invalid_finish(serialized=True)) + + self.responses.tokenizer_manager.generate_request = generate + failed = asyncio.run(self.responses.create_responses(request)) + self.assertEqual(failed.status, "failed") + return failed + def test_invalid_token_is_failure_even_past_length_cap(self): for bad_id in (-1, 100, 123456): for cap in (1, 2, 20): @@ -150,6 +166,72 @@ async def run(): self.assertEqual(raised.exception.status_code, 500) self.assertNotIn("fixture-rid", manager.rid_to_state) + def test_completions_stream_serialized_failure_is_sse_error(self): + async def generate(*args, **kwargs): + yield engine_chunk(invalid_finish(serialized=True)) + + self.completions.tokenizer_manager.generate_request = generate + request = CompletionRequest( + model="fixture-qwen", + prompt="Hi", + stream=True, + stream_options={"include_usage": True}, + ) + + async def collect(): + return [ + frame + async for frame in self.completions._generate_completion_stream( + SimpleNamespace(rid="fixture-rid"), request, None + ) + ] + + frames = asyncio.run(collect()) + self.assertEqual(frames[-1], "data: [DONE]\n\n") + payloads = data_payloads(frames) + self.assertEqual(len(payloads), 1) + self.assertEqual(payloads[-1]["error"]["type"], "InvalidTokenError") + self.assertEqual(payloads[-1]["error"]["code"], 500) + self.assertFalse( + any( + choice.get("finish_reason") == "abort" + for payload in payloads + for choice in payload.get("choices", []) + ) + ) + + def test_completions_stream_graceful_abort_remains_choice(self): + async def generate(*args, **kwargs): + yield engine_chunk({"type": "abort", "message": "Request cancelled."}) + + self.completions.tokenizer_manager.generate_request = generate + request = CompletionRequest(model="fixture-qwen", prompt="Hi", stream=True) + + async def collect(): + return [ + frame + async for frame in self.completions._generate_completion_stream( + SimpleNamespace(rid="fixture-rid"), request, None + ) + ] + + frames = asyncio.run(collect()) + self.assertEqual(frames[-1], "data: [DONE]\n\n") + payloads = data_payloads(frames) + self.assertFalse(any("error" in payload for payload in payloads)) + choice_payloads = [payload for payload in payloads if payload.get("choices")] + self.assertEqual(len(choice_payloads), 1) + self.assertEqual( + choice_payloads[0]["choices"][0]["finish_reason"], "abort" + ) + self.assertEqual(payloads[0], choice_payloads[0]) + usage_payloads = [payload for payload in payloads if not payload.get("choices")] + self.assertLessEqual(len(usage_payloads), 1) + if usage_payloads: + self.assertEqual(usage_payloads[0]["choices"], []) + self.assertIn("usage", usage_payloads[0]) + self.assertEqual(payloads[-1], usage_payloads[0]) + def test_chat_and_messages_stream_serialized_failure(self): finish = invalid_finish(serialized=True) @@ -176,6 +258,9 @@ async def collect_chat(): self.assertEqual(chat_frames[-1], "data: [DONE]\n\n") chat_payloads = data_payloads(chat_frames) self.assertEqual(chat_payloads[-1]["error"]["code"], 500) + self.assertEqual( + chat_payloads[-1]["error"]["type"], "InvalidTokenError" + ) anthropic_request = AnthropicMessagesRequest( model="fixture-qwen", @@ -261,6 +346,41 @@ async def collect_responses(): ) self.assertFalse(any(event["type"] == "response.completed" for event in events)) + def test_failed_response_retrieval_preserves_failure_and_partial_output(self): + failed = self._store_failed_response() + + retrieved = asyncio.run(self.responses.retrieve_responses(failed.id)) + + self.assertEqual(retrieved.status, "failed") + self.assertEqual(retrieved.error["code"], "server_error") + self.assertIn("invalid token ID", retrieved.error["message"]) + self.assertTrue(retrieved.output) + self.assertIn( + "Planning only.", + json.dumps([item.model_dump() for item in retrieved.output]), + ) + + def test_failed_response_cannot_be_replayed_as_predecessor(self): + failed = self._store_failed_response() + + async def preprocessing_must_not_run(*args, **kwargs): + self.fail("failed predecessor reached preprocessing") + + self.responses._make_request = preprocessing_must_not_run + replay = ResponsesRequest( + model="fixture-qwen", + input="Continue", + previous_response_id=failed.id, + store=True, + ) + + rejected = asyncio.run(self.responses.create_responses(replay)) + + self.assertEqual(rejected.status_code, 400) + error = json.loads(rejected.body)["error"] + self.assertEqual(error["param"], "previous_response_id") + self.assertIn("status is 'failed'", error["message"]) + def test_graceful_abort_remains_cancelled(self): finish = {"type": "abort", "message": "Request cancelled."} self.assertEqual(self.responses._status_from_finish_reason(finish), "cancelled") From cb8a491af7ad664e207fe2fb7d7bded4fd8a4dbb Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 15:14:31 +0100 Subject: [PATCH 17/20] [verified] fix(packaging): finalize cumulative invalid-token profile --- Dockerfile.invalid-token-failure | 13 +- README.md | 7 +- docs/invalid-token-failure.md | 121 +- ...0019-invalid-generated-token-failure.patch | 116 +- patches/series.invalid-token-failure | 2 + .../invalid-token-failure-runtime-files.json | 4394 +++++++++++++++++ provenance/invalid-token-failure.json | 73 +- .../pr8-final-compile-diff-security.log | 20 + .../pr8-final-docker-build-readback.log | 77 + provenance/pr8-final-effort-14.log | 28 + ...final-exact-image-reconstruction-twice.log | 6 + provenance/pr8-final-full-package.log | 96 + provenance/pr8-final-invalid-token-green.log | 57 + provenance/pr8-final-multimodal-4.log | 23 + provenance/pr8-final-packaging-17.log | 22 + provenance/pr8-final-responses-75.log | 162 + .../srt/entrypoints/openai/serving_chat.py | 6 +- .../entrypoints/openai/serving_responses.py | 954 +++- scripts/test_invalid_token_failure.sh | 5 +- scripts/verify_invalid_token_failure.py | 124 +- tests/test_invalid_token_packaging.py | 52 +- 21 files changed, 5986 insertions(+), 372 deletions(-) create mode 100644 provenance/invalid-token-failure-runtime-files.json create mode 100644 provenance/pr8-final-compile-diff-security.log create mode 100644 provenance/pr8-final-docker-build-readback.log create mode 100644 provenance/pr8-final-effort-14.log create mode 100644 provenance/pr8-final-exact-image-reconstruction-twice.log create mode 100644 provenance/pr8-final-full-package.log create mode 100644 provenance/pr8-final-invalid-token-green.log create mode 100644 provenance/pr8-final-multimodal-4.log create mode 100644 provenance/pr8-final-packaging-17.log create mode 100644 provenance/pr8-final-responses-75.log diff --git a/Dockerfile.invalid-token-failure b/Dockerfile.invalid-token-failure index fcc1da9..21abc71 100644 --- a/Dockerfile.invalid-token-failure +++ b/Dockerfile.invalid-token-failure @@ -1,16 +1,19 @@ -# Qwen Flash-Next API compatibility plus invalid generated-token failures. +# Cumulative CPU-only overlay: patches 0015 through 0019. # All model paths, serving arguments, and runtime settings remain external. FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 ARG SOURCE_REVISION LABEL org.opencontainers.image.source="https://github.com/kanadaj/sglang" \ org.opencontainers.image.revision="${SOURCE_REVISION}" -COPY runtime/python/sglang/srt/entrypoints/openai/protocol.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py -COPY runtime/python/sglang/srt/entrypoints/openai/responses_compat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py -COPY runtime/python/sglang/srt/function_call/qwen3_coder_detector.py /sgl-workspace/sglang/python/sglang/srt/function_call/qwen3_coder_detector.py COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_completions.py +COPY runtime/python/sglang/srt/entrypoints/openai/protocol.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py +COPY runtime/python/sglang/srt/entrypoints/openai/responses_compat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py +COPY runtime/python/sglang/srt/function_call/qwen3_coder_detector.py /sgl-workspace/sglang/python/sglang/srt/function_call/qwen3_coder_detector.py +COPY runtime/python/sglang/srt/multimodal/processors/qwen_vl.py /sgl-workspace/sglang/python/sglang/srt/multimodal/processors/qwen_vl.py COPY runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py /sgl-workspace/sglang/python/sglang/srt/managers/schedule_batch.py -RUN python3 -B -c 'import pathlib; p=pathlib.Path("/sgl-workspace/sglang/python/sglang/srt"); files=[p/"entrypoints/openai"/n for n in ("serving_chat.py", "serving_completions.py", "protocol.py", "serving_responses.py", "responses_compat.py")]+[p/"function_call/qwen3_coder_detector.py", p/"managers/schedule_batch.py"]; [compile(f.read_bytes(), str(f), "exec") for f in files]' +COPY provenance/invalid-token-failure-runtime-files.json /tmp/invalid-token-failure-runtime-files.json +RUN python3 -B -c 'import hashlib,json,pathlib; root=pathlib.Path("/sgl-workspace/sglang"); expected=json.loads(pathlib.Path("/tmp/invalid-token-failure-runtime-files.json").read_text()); actual={str(p.relative_to(root)) for p in (root/"python/sglang").rglob("*") if p.is_file() and "__pycache__" not in p.parts and p.suffix != ".pyc"}; assert actual == set(expected), (len(actual), len(expected)); bad=[n for n,h in expected.items() if hashlib.sha256((root/n).read_bytes()).hexdigest()!=h]; assert not bad, bad; files=[root/"python/sglang/srt/entrypoints/openai"/n for n in ("serving_chat.py", "serving_completions.py", "protocol.py", "serving_responses.py", "responses_compat.py")]+[root/"python/sglang/srt/function_call/qwen3_coder_detector.py", root/"python/sglang/srt/multimodal/processors/qwen_vl.py", root/"python/sglang/srt/managers/schedule_batch.py"]; [compile(f.read_bytes(), str(f), "exec") for f in files]' \ + && rm /tmp/invalid-token-failure-runtime-files.json ENTRYPOINT ["python3", "-m", "sglang.launch_server"] CMD ["--help"] diff --git a/README.md b/README.md index 3f33f6b..a6d6a7d 100644 --- a/README.md +++ b/README.md @@ -8,8 +8,11 @@ logprobs; structural splitting is limited to recognized Qwen markers and the loa `qwen3_8_flash_next` / `_text` model types. The cumulative [Qwen Flash-Next multimodal alias profile](docs/qwen-multimodal-alias.md) additionally restores four existing Qwen VL processor paths under the release model type. The -[invalid generated-token failure profile](docs/invalid-token-failure.md) surfaces -scheduler token-ID faults through Chat, Completions, Messages, and Responses clients. +[invalid generated-token failure profile](docs/invalid-token-failure.md) completes +the cumulative `0015` → `0016` → `0017` → `0018` → `0019` stack: scheduler +faults retain `InvalidTokenError` through Chat and Completions SSE, Responses +failures remain retrievable but cannot be replayed as `previous_response_id`, and +graceful cancellations are unchanged. Historical production profiles below are unchanged; no deployment is implied. Publishable source and deployment package for the locally accepted Qwen3.8 diff --git a/docs/invalid-token-failure.md b/docs/invalid-token-failure.md index e1c71cc..b84f6f4 100644 --- a/docs/invalid-token-failure.md +++ b/docs/invalid-token-failure.md @@ -1,58 +1,101 @@ -# Invalid generated-token failures — CPU candidate only +# Invalid generated-token failures — cumulative local candidate -The scheduler currently replaces an out-of-vocabulary generated token with an -EOS token and reports an ordinary stop. A speculative step at the output limit -can further replace that result with a length finish. Clients therefore receive -a successful response even though the engine produced an invalid token ID. +This profile is rebased onto main +`e5d93387e03c110de6f6f483a0ff5ed44d3a1a1e`. It transplants original PR #8 +head `4059ace2b2faa2d7972f7704c8fdca0985a35b1a` and the reviewed functional +corrections from `63f43b7ad68b40831f3b1a47e880a56a2db66a42`. Nothing was pushed, +merged, published, deployed, or applied to a running service. -This profile reports that condition as an HTTP 500 `InvalidTokenError`, excludes -the faulty token from output, and prevents the length cap from hiding the -failure. Chat and Anthropic-compatible streams emit the serialized error and -terminate. Responses requests finish with `status=failed`, a `server_error` -payload, and `response.failed`; graceful aborts without an error status remain -cancelled. +## Behavior -## Composition +An out-of-vocabulary generated token is a fatal engine error, not an ordinary +stop. The scheduler replaces the token only to keep downstream decoding safe, +excludes it from emitted output, records `FINISH_ABORT` with HTTP 500 and +`err_type=InvalidTokenError`, and does not allow a speculative output-length cap +to overwrite that error. -Patch `0019-invalid-generated-token-failure.patch` applies after the existing -effort and Responses compatibility patches. The patch changes the scheduler and -the Chat and Responses adapters because all three layers are required to carry -the failure to clients. Their post-patch bytes live under -`runtime.invalid-token-failure/`, leaving the predecessor profile's `runtime/` -snapshot unchanged. `Dockerfile.invalid-token-failure` combines those files with -the three unchanged API compatibility files. Model paths, serving arguments, and -runtime settings remain external. +- **Chat:** a serialized integer status emits one `InvalidTokenError` SSE error, + then `[DONE]`; it does not continue through the ordinary choice/usage path. +- **Completions:** uses the same integer-status and error-type behavior, emits + `[DONE]`, and returns before any ordinary abort choice or usage event. +- **Responses:** non-stream and stream terminals use `status=failed`, attach a + `server_error`, retain partial output, and emit `response.failed`. Stored failed + responses remain retrievable. A failed response used as + `previous_response_id` is rejected with HTTP 400 and + `param=previous_response_id` before registry replay, preprocessing, or + generation. +- **Cancellations:** an abort without an error status remains the existing + graceful Chat/Completions abort or Responses `cancelled` terminal. -## CPU validation +## Composition and source identity -The runner requires the exact base image to be present locally and a pinned -Qwen tokenizer directory: +`patches/series.invalid-token-failure` is the exact cumulative order: + +1. `0015-qwen-flash-next-effort-alias.patch` +2. `0016-responses-namespace-custom-boundary.patch` +3. `0017-responses-phase-order.patch` +4. `0018-qwen-flash-next-multimodal-alias.patch` +5. `0019-invalid-generated-token-failure.patch` + +Patch 0019 is regenerated against the post-0018 tree. Its +`serving_responses.py` retains the complete PR #5 phase/order parser behavior and +adds only PR #8 failure behavior. Its `serving_chat.py` retains the cumulative +effort behavior. The PR #7 `qwen_vl.py` bytes remain unchanged at SHA-256 +`b47003e1f0840a057519adff46fc72a9318a61e2eb3ef8cedfa9eab19e98b7f7`. + +The four post-0019 runtime files, including `serving_completions.py`, are under +`runtime.invalid-token-failure/`. The full 4,392-file result inventory is +`provenance/invalid-token-failure-runtime-files.json`; its SHA-256 is +`414b43dec378538ca1e5785f4855115947d824c2b42fe6fa4bcb2943815c05f3`. +`provenance/invalid-token-failure.json` binds base/head identities, patch and +inventory hashes, every changed-file preimage/result, test counts, and evidence +log hashes. The verifier fails closed on chain, series, runtime, patch, +inventory, PR #7 byte, count, or evidence drift. + +## Verification + +Pinned tokenizer/config metadata came from the recorded local release snapshot. +CPU/GPU-disabled checks completed against the exact base image: + +- 15 focused runtime tests for scheduler/API error behavior; +- 4 invalid-token packaging contract tests; +- 75 cumulative Responses tests; +- 14 effort tests; +- 4 multimodal tests; +- 90 full-package tests; +- 17 dedicated packaging tests; +- two independent exact-image reconstructions, each checking all 4,392 source + files and producing tree digest + `f98edc6b100d20bfd993b0f02183e53ac8f5b7bf41c849779877ee2090878482`; +- local Docker build plus image readback: 4,392 expected, 4,392 present, zero + missing, extra, or mismatched source files. The recorded candidate build digest + is `sha256:a4627d598748483bad601e53b7500940374d12b1226016d99a79a18569deec60`. + +Run the focused gate: ```bash -QWEN_TOKENIZER_PATH=/absolute/release/config-directory \ +QWEN_TOKENIZER_PATH=/absolute/pinned/release/config-directory \ bash scripts/test_invalid_token_failure.sh -python3 scripts/verify_invalid_token_failure.py ``` -The runtime test covers negative, vocabulary-boundary, and very large token IDs; -speculative overruns at several output caps; invalid first tokens; unchanged -ordinary stop and length finishes; tokenizer-state cleanup; serialized HTTP -status values; Chat, Anthropic Messages, and Responses streaming; and Responses -non-streaming terminals. It runs in a read-only, network-disabled, GPU-disabled -container. - -For a complete source reconstruction, export `python/sglang` from the exact base -image into `TREE`, then run: +Reconstruct from an extracted exact base image source tree: ```bash python3 scripts/verify_invalid_token_failure.py --tree TREE --from-image python3 scripts/verify_invalid_token_failure.py --tree TREE ``` +Build the local cumulative image with a source-revision label: + +```bash +docker build --pull=false \ + --build-arg SOURCE_REVISION="$(git rev-parse HEAD)" \ + -f Dockerfile.invalid-token-failure \ + -t sglang-pr8-final:local . +``` + ## Limits -The candidate has CPU regression and full-source reconstruction coverage. It -has not been built, published, deployed, or exercised by deliberately forcing -an invalid token on a live GPU engine. The change does not attempt to recover -generation after an invalid token; it makes the existing fatal condition -visible to clients. +No GPU generation was forced to produce an invalid token. The change makes the +existing fatal condition visible and replay-safe; it does not attempt generation +recovery. The image is local only and has not been published or deployed. diff --git a/patches/0019-invalid-generated-token-failure.patch b/patches/0019-invalid-generated-token-failure.patch index d6d2cfe..13c6c59 100644 --- a/patches/0019-invalid-generated-token-failure.patch +++ b/patches/0019-invalid-generated-token-failure.patch @@ -1,18 +1,24 @@ +diff --git a/python/sglang/srt/entrypoints/openai/serving_chat.py b/python/sglang/srt/entrypoints/openai/serving_chat.py +index 148f80abd1531132ec240ae76a5246de6a9ac3e5..9234892547d079df3bd9650314139d8c141eab66 100644 --- a/python/sglang/srt/entrypoints/openai/serving_chat.py +++ b/python/sglang/srt/entrypoints/openai/serving_chat.py -@@ -1618,16 +1618,17 @@ +@@ -1619,17 +1619,17 @@ class OpenAIServingChat(OpenAIServingBase): + # /abort_request or session lifecycle cleanup) falls through # to the normal chunk path, matching the non-stream behavior # in tokenizer_manager._handle_abort_finish_reason. - if finish_reason_type == "abort" and isinstance( +- if finish_reason_type == "abort" and isinstance( - finish_reason.get("status_code"), HTTPStatus -+ finish_reason.get("status_code"), int - ): +- ): - code = finish_reason["status_code"] -+ code = HTTPStatus(finish_reason["status_code"]) ++ status_code = finish_reason.get("status_code") ++ if finish_reason_type == "abort" and isinstance(status_code, int): error = self.create_streaming_error_response( finish_reason.get("message", "Generation aborted."), - code.name, - code.value, +- code.name, +- code.value, ++ finish_reason.get("err_type") ++ or HTTPStatus(status_code).name, ++ status_code, ) yield f"data: {error}\n\n" - break @@ -21,9 +27,62 @@ finish_reasons[index] = finish_reason # First chunk with role +diff --git a/python/sglang/srt/entrypoints/openai/serving_completions.py b/python/sglang/srt/entrypoints/openai/serving_completions.py +index d5587765bd73ab98afa51643ae0382aa22ec31f8..1f701086f196ddc593e02809a63ba74408d126bd 100644 +--- a/python/sglang/srt/entrypoints/openai/serving_completions.py ++++ b/python/sglang/srt/entrypoints/openai/serving_completions.py +@@ -347,17 +347,19 @@ class OpenAIServingCompletion(OpenAIServingBase): + # /abort_request or session lifecycle cleanup) falls through + # to the normal chunk path, matching the non-stream behavior + # in tokenizer_manager._handle_abort_finish_reason. +- if finish_reason_type == "abort" and isinstance( +- finish_reason.get("status_code"), HTTPStatus +- ): +- code = finish_reason["status_code"] ++ status_code = ( ++ finish_reason.get("status_code") if finish_reason else None ++ ) ++ if finish_reason_type == "abort" and isinstance(status_code, int): + error = self.create_streaming_error_response( + finish_reason.get("message", "Generation aborted."), +- code.name, +- code.value, ++ finish_reason.get("err_type") ++ or HTTPStatus(status_code).name, ++ status_code, + ) + yield f"data: {error}\n\n" +- break ++ yield "data: [DONE]\n\n" ++ return + + choice_data = CompletionResponseStreamChoice( + index=index, +diff --git a/python/sglang/srt/entrypoints/openai/serving_responses.py b/python/sglang/srt/entrypoints/openai/serving_responses.py +index 844e0114bf269a864666c98a0e39c57127834580..2a242a3640181ae753d6b884a47f9a00c8ac64fb 100644 --- a/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/python/sglang/srt/entrypoints/openai/serving_responses.py -@@ -710,6 +710,7 @@ +@@ -315,6 +315,10 @@ class OpenAIServingResponses(OpenAIServingChat): + async with self.response_store_lock: + previous = self.response_store.get(request.previous_response_id) + previous_registry = self._compat_registries.get(request.previous_response_id) ++ if previous is not None and previous.status == "failed": ++ return self._make_failed_previous_response_error( ++ request.previous_response_id ++ ) + if previous is not None and previous_registry is not None: + registry.inherit_history(previous_registry, previous.output) + internal = request.model_dump(by_alias=True) +@@ -417,6 +421,8 @@ class OpenAIServingResponses(OpenAIServingChat): + prev_response = self.response_store.get(prev_response_id) + if prev_response is None: + return self._make_not_found_error(prev_response_id) ++ if prev_response.status == "failed": ++ return self._make_failed_previous_response_error(prev_response_id) + else: + prev_response = None + +@@ -774,6 +780,7 @@ class OpenAIServingResponses(OpenAIServingChat): return self.create_error_response(str(e)) status = "completed" @@ -31,7 +90,7 @@ if self.use_harmony: assert isinstance(context, HarmonyContext) output = self._make_response_output_items_with_harmony(context) -@@ -718,7 +719,8 @@ +@@ -782,7 +789,8 @@ class OpenAIServingResponses(OpenAIServingChat): num_generated_tokens = context.num_output_tokens num_cached_tokens = context.num_cached_tokens num_reasoning_tokens = context.num_reasoning_tokens @@ -41,7 +100,7 @@ else: assert isinstance(context, SimpleContext) final_res = context.last_output -@@ -733,9 +735,10 @@ +@@ -797,9 +805,10 @@ class OpenAIServingResponses(OpenAIServingChat): elif hasattr(final_res, "meta_info"): meta_info = final_res.meta_info @@ -51,9 +110,9 @@ ) + status = self._status_from_finish_reason(finish_reason) - output_logprobs = ( - _build_output_text_logprobs(meta_info) -@@ -756,7 +759,8 @@ + final_text = final_res["text"] + model_type = self.tokenizer_manager.model_config.hf_config.model_type +@@ -857,7 +866,8 @@ class OpenAIServingResponses(OpenAIServingChat): num_generated_tokens = meta_info.get("completion_tokens", 0) num_cached_tokens = meta_info.get("cached_tokens", 0) num_reasoning_tokens = meta_info.get("reasoning_tokens", 0) @@ -63,7 +122,7 @@ elif isinstance(final_res, dict) and ( final_res.get("prompt_token_ids") is not None or final_res.get("output_ids") is not None -@@ -812,6 +816,7 @@ +@@ -913,6 +923,7 @@ class OpenAIServingResponses(OpenAIServingChat): status=status, usage=usage, ) @@ -71,7 +130,7 @@ if request.store: async with self.response_store_lock: -@@ -835,9 +840,27 @@ +@@ -936,9 +947,27 @@ class OpenAIServingResponses(OpenAIServingChat): reason = finish_reason.get("type") elif isinstance(finish_reason, str): reason = finish_reason @@ -100,7 +159,24 @@ def _is_thinking_enabled_for_request(self, request: ResponsesRequest) -> bool: if not self.reasoning_parser: -@@ -2627,6 +2650,7 @@ +@@ -1949,6 +1978,16 @@ class OpenAIServingResponses(OpenAIServingChat): + param="response_id", + ) + ++ def _make_failed_previous_response_error(self, response_id: str): ++ return self.create_error_response( ++ message=( ++ f"Response with id '{response_id}' cannot be used as a previous " ++ "response because its status is 'failed'." ++ ), ++ err_type="invalid_request_error", ++ param="previous_response_id", ++ ) ++ + async def responses_stream_generator( + self, + request: ResponsesRequest, +@@ -3125,6 +3164,7 @@ class OpenAIServingResponses(OpenAIServingChat): status=status, usage=usage, ) @@ -108,7 +184,7 @@ if request.store: async with self.response_store_lock: stored = self.response_store.get(final_response.id) -@@ -2638,12 +2662,19 @@ +@@ -3136,12 +3176,19 @@ class OpenAIServingResponses(OpenAIServingChat): terminal_event = ( openai_responses_types.ResponseIncompleteEvent if status == "incomplete" @@ -131,9 +207,11 @@ ) yield _send_event( terminal_event( +diff --git a/python/sglang/srt/managers/schedule_batch.py b/python/sglang/srt/managers/schedule_batch.py +index ee5445d5ee855acbc3da66bdb9a0b877984782f8..2c993ecce431744d9d9880abef1d567c0b06b3a5 100755 --- a/python/sglang/srt/managers/schedule_batch.py +++ b/python/sglang/srt/managers/schedule_batch.py -@@ -1603,8 +1603,14 @@ +@@ -1603,8 +1603,14 @@ class Req(ReqDllmMixin): ) if self.eos_token_ids: self.output_ids[offset] = next(iter(self.eos_token_ids)) @@ -150,7 +228,7 @@ return True return False -@@ -1632,9 +1638,8 @@ +@@ -1632,9 +1638,8 @@ class Req(ReqDllmMixin): new_accepted_tokens = self.output_ids[-new_accepted_len:] diff --git a/patches/series.invalid-token-failure b/patches/series.invalid-token-failure index 5d04ed8..980e2a9 100644 --- a/patches/series.invalid-token-failure +++ b/patches/series.invalid-token-failure @@ -1,3 +1,5 @@ 0015-qwen-flash-next-effort-alias.patch 0016-responses-namespace-custom-boundary.patch +0017-responses-phase-order.patch +0018-qwen-flash-next-multimodal-alias.patch 0019-invalid-generated-token-failure.patch diff --git a/provenance/invalid-token-failure-runtime-files.json b/provenance/invalid-token-failure-runtime-files.json new file mode 100644 index 0000000..5d221f2 --- /dev/null +++ b/provenance/invalid-token-failure-runtime-files.json @@ -0,0 +1,4394 @@ +{ + "python/sglang/README.md": "becae5c300803f59e9b231a02b8a3bf93d71cc3b3456116fcd956da03721331b", + "python/sglang/__init__.py": "e54e5073b3d139f84b594bb23f7651a41a7c3d0148df980568928a070192ad5b", + "python/sglang/_mps_stub.py": "1cef5f18d926d6df10797de336d9548baca4278d2d0fba2f3a65280f45e11abe", + "python/sglang/_triton_stub.py": "2b6068eb75ee7e9a04fbf5539b6c05bedd24d8b54875c5e4576ba4661d628eae", + "python/sglang/_version.py": "ad6aabfc8c01600e574ad0d329b3740a975bf256d2cc9716d7145cb6843fb1a2", + "python/sglang/bench_offline_throughput.py": "fd5c5a9cdd91a19894916b85e2664c3fbdcdc32c3ec044bfd0cd9b0908cf167f", + "python/sglang/bench_one_batch.py": "2b062012b43493632ca6dbbb46aa783e235905c9da9cde94c23b6f6b3828ab55", + "python/sglang/bench_one_batch_server.py": "477b8710a3eb5d89d137344c6a45f839a6b3f2d73623f14b6aa9d8e44d9a03cb", + "python/sglang/bench_serving.py": "e2ed21f918212615d7aea997b858f8e7655c23923b968fa57a6b56559607bec7", + "python/sglang/benchmark/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/benchmark/bench_utils.py": "762496fd3514db0a5d73b48f16a5f981312355de0a04c5c4480cdbc0c8d8d0ec", + "python/sglang/benchmark/datasets/__init__.py": "2a3f8f837d621eea2e943d3b741777d15249b8dffa8af4e427492b75632eb8b6", + "python/sglang/benchmark/datasets/agentic_trace.py": "575d2580ca81f3cc267ad8f029efe0fb3a9ad3ca4db1a7e75db44402738f2a95", + "python/sglang/benchmark/datasets/common.py": "544b1b66c8be9cae6e870f3da337b8e3f356ec93ee9ea6c1ce700e1f55b3b442", + "python/sglang/benchmark/datasets/custom.py": "7f8460b6bfae2341d11270067620904f541315943ee94879d99cc227b4e2fc8e", + "python/sglang/benchmark/datasets/generated_shared_prefix.py": "80a581fdd819a159e1518fbfdabf1b62e3ecf6c6c65d4e8328276495f7e2e307", + "python/sglang/benchmark/datasets/image.py": "9ce6564aee48f9edc3b3aabf124e6ee55982891bcabef4700f774f8e254788c7", + "python/sglang/benchmark/datasets/longbench_v2.py": "44dc153dc559c3b968459e9b072b01113e7513720a11323f68754af9dbfbfec3", + "python/sglang/benchmark/datasets/mmmu.py": "a2c6ef7d4b77b884e3ca04e64fd01449985ea4a60544f437905734e20d924fa1", + "python/sglang/benchmark/datasets/mooncake.py": "dcdf06f19b0c06fde742f1bd36dadf0b69aafc07f5361ed84c447a47741db1ab", + "python/sglang/benchmark/datasets/openai_dataset.py": "ecee9f2971e916201c88657aca08e9d28efc0fefc3e10bb8f493c6d191cfed8c", + "python/sglang/benchmark/datasets/random.py": "a1242f133dfc3d4c5d30a396cedb5351e6d6b447a632091eaf6e6c403beada7c", + "python/sglang/benchmark/datasets/sharegpt.py": "1803646354f3a54f9ae87db0ad6235e7689038ff00303601aa84657075d929f4", + "python/sglang/benchmark/datasets/speed_bench.py": "b3d6962624838e7c4f3547414c84cb6e253e76b7d1be6dfa037e1b14d5b40c1b", + "python/sglang/benchmark/dspark_sps_profiler.py": "f8820ba461c7c0956a1e1a787e45de8c09f025e46ac2ae9d4d1d22f4076a1911", + "python/sglang/benchmark/dspark_sts_fit.py": "0c368ce43608db0134fabc8a75a16e86529df28b8c06aaec1d6ac146fcad5f1f", + "python/sglang/benchmark/endpoint.py": "23dc79ce3b56e3544e1b4efe535fd3ecb7fe9aa2bc2bb3ac77b741ea8f3ad843", + "python/sglang/benchmark/offline_throughput.py": "deb4dc80a68b92490775e27fc5913dfbe15e287c601b29ef082204f14f5ae252", + "python/sglang/benchmark/one_batch.py": "9e1fa97baaada1c02ba1bc03e61815146487dc5c611aa0a4f67712f69305cef5", + "python/sglang/benchmark/one_batch_server.py": "eec8240f8b34f973ced70734d9ce2b061ef8d875c87a032d871a7dab0df1b631", + "python/sglang/benchmark/serving.py": "0d65ec5e4490eaf5bc999cd11f045688b05ff6a040b6fabc4e5e60faf134e574", + "python/sglang/benchmark/utils.py": "c9a04dc801f0c0fd0497a0d1e358af2eaa9ae182c6ff6c829f01e8ced281a4a3", + "python/sglang/check_env.py": "afa60d7ea0f828469f861e8bfbc75fa07b373f6afaf7b7a9ece0793f07b9cc8b", + "python/sglang/cli/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/cli/generate.py": "655cdb99f497106f44f2b2bb17d094ecab91675d580a5b1180dcd167ca82e9ff", + "python/sglang/cli/killall.py": "c5cecb6ee74a649a472395ed8788e466ed26b0cdb2e06be49749788be327b561", + "python/sglang/cli/main.py": "0c371f7878d50444540d191aba82674322ebce2b61ad9f0da74cbbc3a84f4210", + "python/sglang/cli/serve.py": "75f8a6166bc38cd28c3085ea1d72cad4cd5aacd0ebd0b515ac39d1d817114f84", + "python/sglang/cli/serve_backends.py": "94c2793bfa5b3d3d509c1be48142630334771c4f10605d943aba97faa031113c", + "python/sglang/cli/utils.py": "cfab1d29aba4202d56d868959a5309fc51192e39b8f40b7aa882c2c87e3c0ce3", + "python/sglang/compile_deep_gemm.py": "b3553a22fe846987c4a2193b6c1186cd27849b8473fcf61696a789bfd816af9a", + "python/sglang/eval/llama3_eval.py": "c11ee8dea86b1f1a02fb520246e88072f38e22e2b847e484e1403d8510d25039", + "python/sglang/eval/loogle_eval.py": "f820b6b36921e6a5280eb1d19105640bf8cdbc180da235db7f8e7a9f2e6cefcb", + "python/sglang/global_config.py": "6d5a542ff80c480d05c0997ccbcb4fe4221aeddd3cde8e8371a93ec91cadcc6c", + "python/sglang/kernel_api_logging.py": "d3cfbaa939422f47b84b96a8878a98b178a7182a79656440c08938804517c4f7", + "python/sglang/kernels/README.md": "500616add2ba819eecbbcfdb8a4044b7d8eaf470d3461a921e9465aed52952a6", + "python/sglang/kernels/__init__.py": "8699543ca891f901b829d318d14314ce516a03a5814e27db02ecf09b49250faa", + "python/sglang/kernels/aot/.clang-format": "dc2a6c4be9a0951daedae7d3ba0955f2062b4f05ae165d812d1e8d3706ef6c15", + "python/sglang/kernels/aot/CMakeLists.txt": "273212caf91c528959e906df6750f004909bff0ed0d0214ef72d35918acab455", + "python/sglang/kernels/aot/Dockerfile": "fd49e7c9f12b9d3f7f96326ceb0c0b9eb1ad61163baa776b187918f99e6da535", + "python/sglang/kernels/aot/LICENSE": "1495e1e757ef4d0925a2350563cf5754bb23c51701a8ec4fb3c5cdcbedae6747", + "python/sglang/kernels/aot/Makefile": "b14809f758c33ee5814ed43da37a43e1b7135237a5251eb16fff0ca35cae7c4e", + "python/sglang/kernels/aot/README.md": "af8c7784ed9197eb548433af7587d37b180e708f0a17e13ce7c8bf10522faae2", + "python/sglang/kernels/aot/THIRDPARTYNOTICES.txt": "2e44e480eb9e4e9e1b98ea2c442a5fa5186ffaec9f9d8b178ec8e6617a05cfa8", + "python/sglang/kernels/aot/analyze_whl_kernel_sizes.py": "75aab9c50021e74f1827487831f1813bcd25c7126f032dc1e29874fdbb5ce125", + "python/sglang/kernels/aot/benchmark/bench_activation.py": "c421f2c2166e467069022af4bee9a7cccbb05e023363100099e4b277022a9388", + "python/sglang/kernels/aot/benchmark/bench_amd_deterministic_allreduce.py": "7e51006df02e58c9427f1009ed617374570efde5dcb596023bcce12785417be9", + "python/sglang/kernels/aot/benchmark/bench_awq_dequant.py": "6e0e965ddc33288cc801446c70e396421d0b6596f92f518e73af9bfb54b42ae3", + "python/sglang/kernels/aot/benchmark/bench_cutlass_mla.py": "cc5d29c56a25a40de5d95d3060e49ccf147b60c48df091ef1381249bc0d42479", + "python/sglang/kernels/aot/benchmark/bench_dsv4_norm_rope.py": "eca51f60e7caec0c32c429522b601ac56badee4e345bc7d85183775a5b62e744", + "python/sglang/kernels/aot/benchmark/bench_es_fp8_blockwise_grouped_gemm.py": "97383c2a26b99b4446aa099b69cd875e44d97ae8dba37ea8e2393a438515f737", + "python/sglang/kernels/aot/benchmark/bench_fp4_gemm.py": "8bf0ac09f60477662dae78313ed271c3dcce0a6c3a3b387554363de2e020284b", + "python/sglang/kernels/aot/benchmark/bench_fp8_blockwise_group_gemm.py": "03d043f711116afbf9247b0b02ec2fc9c6059f3786cbb8746fab55d030dbca25", + "python/sglang/kernels/aot/benchmark/bench_fp8_gemm.py": "73e7fbdd165efef169a2fe326ec16442f689976b444868c88ae27918d37f1317", + "python/sglang/kernels/aot/benchmark/bench_fp8_gemm_swap_ab.py": "5ee968be1921ce842ca624c0c58f0a65cf65d5ff4a9291f9f39e077d8afb84e7", + "python/sglang/kernels/aot/benchmark/bench_int8_gemm.py": "3c4f10853558afa793da791d1ee8691c62d5954fcd0f8cc3bcaeb33d8abc8f16", + "python/sglang/kernels/aot/benchmark/bench_moe_align_block_size.py": "8386b345ef536ee203566658249e82f4293fbe35e71b0ca58ad3e4623452a236", + "python/sglang/kernels/aot/benchmark/bench_moe_ep_post_reorder.py": "5d4f2896563650f3bb05a735d6101940856d3339de00812a9d1da66be02fcaca", + "python/sglang/kernels/aot/benchmark/bench_moe_topk_sigmoid.py": "73305c4e56d22fcd4a5debf1ce4c3f5a17aaecd24251a406243574a2babe9a91", + "python/sglang/kernels/aot/benchmark/bench_moe_topk_softmax.py": "254dc1895ba409fa1ff86f1381ebdb4001a488b441f0b3faf810a435268d50c4", + "python/sglang/kernels/aot/benchmark/bench_mrope.py": "a0774041acb66396d3e188cd8cf358c31ab2cdb19f5bec4554b581b5e3f2a472", + "python/sglang/kernels/aot/benchmark/bench_per_tensor_quant_fp8.py": "839732b35aeeaa36048b381295dfd5b06fa0f636407156fce33a43e270fac9ee", + "python/sglang/kernels/aot/benchmark/bench_per_token_group_quant_8bit.py": "5e655449992ce2975a5405c02ebafffadde9e7a32bbd80f17860df4e10f91d84", + "python/sglang/kernels/aot/benchmark/bench_rmsnorm.py": "4cb3c391b21d2780d9f9599092f276d3eeeb404a8b80ebe32f529f43e6dd2b0d", + "python/sglang/kernels/aot/benchmark/bench_rotary_embedding.py": "c31671792065aa7c4ff2fb8bffb48aec3bfbed58fb4a3cf210736899942ebf71", + "python/sglang/kernels/aot/benchmark/bench_sum_scale.py": "7c88fb44db929f77f507d5d27bd3b03ec27e6c5381528c7c376fe6f70fb7dca8", + "python/sglang/kernels/aot/benchmark/bench_top_k_top_p_sampling.py": "6c2015fbb141f89ba069cfe414c15355b8cbb8a68ed0f83f8de9aca8263befee", + "python/sglang/kernels/aot/build.sh": "b7019fba7e02354680e198c5f314442f61a3f8a77a5bc783e72403c5b5dac63b", + "python/sglang/kernels/aot/cmake/flashmla.cmake": "f8a31f77098c2e2e0dd6c478a3e4cc426825d3f51f8e8615b93266cd81d6c15d", + "python/sglang/kernels/aot/cmake/utils.cmake": "a4edb2f627936c18683b336ac8459f767c2abfabf84eda3e5d2a1dbf7e4edc25", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce.cu": "12b0101f40b045085a039e3ac4185e3d83547da8007c2a2a09d4d0b59c6785a1", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce.cuh": "1b9bbffb6592b5092caf83152d7277f8f8b935ea68ad3f73c4e88646503a2fb7", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce.hip": "bb461ec96c6a7e2b5dc26cdcd19e4a28452d100faae0be93653ff4cb501f8e62", + "python/sglang/kernels/aot/csrc/allreduce/custom_all_reduce_hip.cuh": "36a162c91ee3b302905936b337f195766c47bfc57365d0d9d264301758c6eb97", + "python/sglang/kernels/aot/csrc/allreduce/deterministic_all_reduce.hip": "5653edd5d3aa9e561ed64494ce6fb082164f62ae8652f681060dbf734b7fe66a", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce.cu": "3ad95ce83a50c546688b82fcb24038afbca9cfbedc62485e71eea2ee044d93f3", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce.cuh": "7dece95138d7d4494459ae346a3df7bcba33def4af3186ad34c6056f98331769", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce.h": "9a522ee8118418abaa414e637ad7d8913b89a8cd10c172096696bb8a24c49faf", + "python/sglang/kernels/aot/csrc/allreduce/quick_all_reduce_base.h": "f2f8b90c1bf6c2a02deb68c0b87899ef552252fa27d173b590b863b1102966d2", + "python/sglang/kernels/aot/csrc/attention/cutlass_mla_kernel.cu": "d22ff738ffd4e814fd0215f928385aaa959b121595ace21e55d22d2884694606", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/device/sm100_mla.hpp": "f411088638eab8ee0d22d7160779fe0c0830006c0184e09d3298d140df0bdbd2", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/kernel/sm100_fmha_mla_reduction.hpp": "01b0d650bbbf16b0d150ea634e5a4e92dbfd37d0a442a9b88701f15c1a32b929", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/kernel/sm100_fmha_mla_tma_warpspecialized.hpp": "644c75a7cb55eed77ee85b8b05cd784dd8aa9e80b9944e640e40a231a7f42231", + "python/sglang/kernels/aot/csrc/attention/cutlass_sm100_mla/kernel/sm100_mla_tile_scheduler.hpp": "e664316462e86130992aa56675efece67fc0b10504550d686f2257a29f392d60", + "python/sglang/kernels/aot/csrc/attention/merge_attn_states.cu": "9616eeea04989a033d4c26cc37887ecba926841d59965f2d443bcfe53038c5a8", + "python/sglang/kernels/aot/csrc/attention/vertical_slash_index.cu": "eb0e6cf3b48ead871cd662de53ae240c4a3da4bf07e9fe1db0e141ec08bffbed", + "python/sglang/kernels/aot/csrc/common_extension.cc": "7952111e8d8ffa20ca51e625f6e713eb93ff3b08f4a6f9bfcd482954b19c0520", + "python/sglang/kernels/aot/csrc/common_extension_musa.cc": "7048ae3e73d91f7fb8aaf83ba4fc26ce498ce555396bef8afe748fc224378d95", + "python/sglang/kernels/aot/csrc/common_extension_rocm.cc": "f0eb606c3d889206790c9debe54e8610f87cdeaa5dd618fca89a55e66e792eb4", + "python/sglang/kernels/aot/csrc/cpu/CMakeLists.txt": "606b7db5e872f2672cd1f156c89cd1514b21602c2c8073dbe6a14d8a3197fe1f", + "python/sglang/kernels/aot/csrc/cpu/aarch64/gemm_int8.cpp": "dbefb9838d6f10525de74e7c00b2d8b9cf94a95129352bdd636258128414418d", + "python/sglang/kernels/aot/csrc/cpu/aarch64/moe.cpp": "dc131c60f62c90d708fcf54bdb3b1a920c63697b16290ca508a8e3d58510e931", + "python/sglang/kernels/aot/csrc/cpu/aarch64/op.h": "f027911f459726a2d141c242b9fd15193928dbf81aa04c3259e80ac5092aa007", + "python/sglang/kernels/aot/csrc/cpu/aarch64/shm.h": "ebc2f3b2901168505609a51a9a95e76849546169e9a8dfd31eeaf6c9961e58ec", + "python/sglang/kernels/aot/csrc/cpu/activation.cpp": "85814e5f2cdc8396e958f8dbffa274b46db63d1e86c551f52b2db62b5b30cf1b", + "python/sglang/kernels/aot/csrc/cpu/bmm.cpp": "41d34a5b54926cc2ca769af4b4297b67ecdd25c7bcf51ac5720dc09297672b31", + "python/sglang/kernels/aot/csrc/cpu/common.h": "65384338e96d0c596a92ee17fc28ea51ee0e8c3b8832742327a7c2f0362b0783", + "python/sglang/kernels/aot/csrc/cpu/conv3d.cpp": "a167ebb92a6eef845dab2959f2304bca6b5fea62f6579b4f3df2b328537537a9", + "python/sglang/kernels/aot/csrc/cpu/decode.cpp": "c723317aaaf49b1c689c86313a85d1cd37caf7824e4f498429701cfb4c573dd0", + "python/sglang/kernels/aot/csrc/cpu/extend.cpp": "413e617fb3fe74ebe114730b4ef2aa560bceec5037f29dd740fc4cdc1fed663d", + "python/sglang/kernels/aot/csrc/cpu/flash_attn.cpp": "8f43a9cb15e3b9b9ec290c6ecb060f2f2aea16cb2bc46748b096702bd6904932", + "python/sglang/kernels/aot/csrc/cpu/flash_attn.h": "b4fe6bfab2545db10e104989d2f9b5686d5648fbc8740e3ff8aeffe4e3807aa6", + "python/sglang/kernels/aot/csrc/cpu/gemm.cpp": "82f2fb0b47e7d70247f83d4eb461dc804530706e2b6f629160b04cb6df175dca", + "python/sglang/kernels/aot/csrc/cpu/gemm.h": "b5b24090f2c17bce33250902942212008fa8ec5e69a163693b6aa8d990c7c7f0", + "python/sglang/kernels/aot/csrc/cpu/gemm_fp8.cpp": "db88e0528acada85b4c2c76e051e857663559a54d24a1b2bb4ee4165ed1faeb1", + "python/sglang/kernels/aot/csrc/cpu/gemm_int4.cpp": "ccabaffb60f3e70c66c98dfaa13109d241d207c528e7fce79570bd42d9626e0d", + "python/sglang/kernels/aot/csrc/cpu/gemm_int8.cpp": "bb57e5ce69c6bcf0e22d6fb934168c4dd680dfd666307c19f8911673ca6b4311", + "python/sglang/kernels/aot/csrc/cpu/interface.cpp": "0098034a6959b3c25db5896d32c16d8c605fe6e73ae91316498e2d3093428c40", + "python/sglang/kernels/aot/csrc/cpu/kvcache.cpp": "e08fd253f6c61989c714e01420fcf80b322714e958d7dee6d239b20891b9f310", + "python/sglang/kernels/aot/csrc/cpu/mamba/conv.cpp": "8a2a6eee0c6d83e3622ec5f74019b24cdd48f16dca9ccacc89d94ce4a6862efe", + "python/sglang/kernels/aot/csrc/cpu/mamba/fla.cpp": "415c55a0f61bc87073b7ea414e5315e20f8df9fa5542670ef2ad9894847b34d5", + "python/sglang/kernels/aot/csrc/cpu/model/qwen3.cpp": "a232f51d423ff7d88d5624777f3f6567b25c8458faf17a465a8a42a614c687b7", + "python/sglang/kernels/aot/csrc/cpu/moe.cpp": "afaed65c3b6c31855a5cc4800a4bfa240c525d73ebbe6e1fad430bb4594c15ae", + "python/sglang/kernels/aot/csrc/cpu/moe.h": "7b4f9244b5eb2d8d103fea74df8d15929073664aa87eddf25bcfbf276cd5d3b3", + "python/sglang/kernels/aot/csrc/cpu/moe_fp8.cpp": "bb37c7f2771f99202e2e72397d822e9caaaa598d8d53a84cd7ef158275c8b1bb", + "python/sglang/kernels/aot/csrc/cpu/moe_int4.cpp": "5401578cb03b5da19c713def8aa7a747e611093493c37a76e5c521dee9f6b624", + "python/sglang/kernels/aot/csrc/cpu/moe_int8.cpp": "6a3f61e38f1863381cfd9f3a2bda123945f9a062398fc1cf462bebc6be94239e", + "python/sglang/kernels/aot/csrc/cpu/norm.cpp": "6a75bcc1e1b5e94f75cbd8496a743f4abe808a5d09eb4108265e10329bc13a50", + "python/sglang/kernels/aot/csrc/cpu/numa_utils.cpp": "32bdc91aa9cbf9fd00777adb19954a0a10952e8d46314234c718ed75699c765d", + "python/sglang/kernels/aot/csrc/cpu/preprocessor.cpp": "410442288042cd40bca0dc19918cf587d2572d3dcb4e70d796d9b126dfb9b81c", + "python/sglang/kernels/aot/csrc/cpu/qkv_proj.cpp": "1c5a16226a392583d5666e73e96f29472efb5c885b4033b703d373e5ffdb836d", + "python/sglang/kernels/aot/csrc/cpu/rope.cpp": "6bc1264bcfcfd25663db5e6135d30fdecaff10382286655588d7c7f5dc5d2406", + "python/sglang/kernels/aot/csrc/cpu/shm.cpp": "f5249b7279391a710178e3fdd8192b5e9c9a07f68535fa66fc5af5a9926f1b4b", + "python/sglang/kernels/aot/csrc/cpu/shm.h": "c034540e6a55470a679177ca4d53425d7de821e1342e10e97762008e75cae379", + "python/sglang/kernels/aot/csrc/cpu/spec.cpp": "7459e239ce4a2f35d58c962b36adafa5884f4259ee99f74b4065eee36d51dc73", + "python/sglang/kernels/aot/csrc/cpu/topk.cpp": "a67c7b12b57d8e1631976d2a167acd1609ffeeace4f3fd336263ac8bf1ac085f", + "python/sglang/kernels/aot/csrc/cpu/torch_extension_cpu.cpp": "5976e8571ce8bc074431e4230d85f7defd46bf1f6bc725404b19853980849a0e", + "python/sglang/kernels/aot/csrc/cpu/vec.h": "72d9318916091d8372c7e6d0a6e69bd71817440edc98eef80f463a5449a1cf04", + "python/sglang/kernels/aot/csrc/cpu/vec_pack.h": "9487659e2354abf11ab2d989f6028fc977c356949eca27e315ba28a97c2df227", + "python/sglang/kernels/aot/csrc/cpu/x86_64/shm.h": "5d52546edfdf191ee10f84d2f87bf44f4684f7fef4f8929a280772fe20d19c94", + "python/sglang/kernels/aot/csrc/cutlass_extensions/common.hpp": "5de164ba11f88ce97abf986b0a856a72b95564ff6079d0541b75c5d38c545ec1", + "python/sglang/kernels/aot/csrc/cutlass_extensions/detail/collective/mixed_input_utils.hpp": "5e6c0d9a009a87677cb6958c41f8d9f371714beb0978d172ce59519bb38f8697", + "python/sglang/kernels/aot/csrc/cutlass_extensions/epilogue/broadcast_load_epilogue_c3x.hpp": "4f342e9ab7305df18424d859c4aa25a6811d3c6516dcaa79a15079621b6c6913", + "python/sglang/kernels/aot/csrc/cutlass_extensions/epilogue/epilogue_per_row_per_col_scale.h": "e28464d5dbd99c91a815b3dce5c12ac43000487fc8c87ea350253caa383c6b7a", + "python/sglang/kernels/aot/csrc/cutlass_extensions/epilogue/scaled_mm_epilogues_c3x.hpp": "128ccc10afb20f0b4493cb0f7d076fb647e3396ebeae8524b167d87bdf65032d", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/builders/sm90_gmma_builder_mixed_input.inl": "a55bf4d13931215540082d2b3e9d31f5260e284eb7246e83d5a4549095161ca0", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/collective_builder_mixed_input.hpp": "0a88dd2755576dba7ab85c9c175efbd2e5e41735443786c9c1f50b660e511f94", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/collective_mma_array_mixed_input.hpp": "c177521617b5626ab1c1ac05312d284f815db68eac2fb348fbae08fee18c7690", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/collective/sm90_mma_array_tma_gmma_rs_warpspecialized_mixed_input_.hpp": "3646b448374d4e2bb35c29b64b00cb4a2ed11ec2086f01fe8a8ef78e13f1bfb3", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/cutlass_gemm_caller.cuh": "cfcb02916adbeb21878a5dacdd20b6b06bd24f9a6ada3f95254bf0e667e2b89d", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/fp8_gemm_sm90_dispatch.cuh": "549d3c1c5c13d67e7309cf50610a51c9485eb181b3a17423247287abd1a0b038", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/gemm_universal_base_compat.h": "468650577a2d861baa3fe2e20540003fcfc362742c1c53836a7cce44f32c3b4d", + "python/sglang/kernels/aot/csrc/cutlass_extensions/gemm/gemm_with_epilogue_visitor.h": "28fe0ba488957b5091fe43dcec6a4379ed95afd449b63437a61dd683d76e6cd4", + "python/sglang/kernels/aot/csrc/elementwise/activation.cu": "dffb5a9cbbb4d26a75e7e8aea0c0acfa2e68c64158466854fd6d54262103a7d6", + "python/sglang/kernels/aot/csrc/elementwise/concat_mla.cu": "f41395045b483ac3528e46a1d80ea9cfbf40d744123db9dfbfc011189a37addf", + "python/sglang/kernels/aot/csrc/elementwise/copy.cu": "a194cd8cd7756453781f9b719794e73ceec3434b794fbc6528e1be548d6f76c0", + "python/sglang/kernels/aot/csrc/elementwise/deepseek_v4_topk.cu": "c9cb9025efaee27c88c257fef446d9d17b40fd9588f5a1d928d62d8a1d4a3067", + "python/sglang/kernels/aot/csrc/elementwise/dsv4_norm_rope.cu": "b7ce890d1edf72b627088f8de94912ca6f63f82bfe3df752530ca58df0a7c538", + "python/sglang/kernels/aot/csrc/elementwise/fused_add_rms_norm_kernel.cu": "91173e4c7d1139209dbe60ada9f6c160cc579e64d6e2bc6093b19489f194d893", + "python/sglang/kernels/aot/csrc/elementwise/fused_add_rms_norm_kernel.mu": "14f903ee5446cc4ed670a928b2050cac50cd9a2b125ff37fea1aaf942e6fd5f0", + "python/sglang/kernels/aot/csrc/elementwise/pos_enc.cu": "bcb566f16d4b280ad970929cf588b887670cf9412cb44c45ca6ec6487c123017", + "python/sglang/kernels/aot/csrc/elementwise/topk.cu": "f899cb9d2db331f2315e84f89c48716863870082f76ae65428ae4d865b0205d7", + "python/sglang/kernels/aot/csrc/elementwise/utils.cuh": "e1f8762cebe626fd0a4014db77af2dc3a03a754fb086344bd8df35c5e9d34987", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise.cu": "1588e12f0577d71c8d0444ee93bea01d66aef4af1985ee41dd7e0d343437114b", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise_functor.cuh": "20a9ff701eb620020b543571c4a308b73aabae0adeb6b02ed4eb6795fda8279c", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise_launcher.cuh": "1e74f78bdcdde807ffb4a31a96d9439360f1fb709812e157a2c0e5feea81cdae", + "python/sglang/kernels/aot/csrc/expert_specialization/es_fp8_blockwise_traits.cuh": "2b4dc917c37799228adf58881815ca2307e527b8211df5c52b698ab297a29131", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled.cu": "62351cae829471d4e2f1140c284ef71fdd9b2f2ac9739e08657d3feaea73cc43", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_functor.cuh": "7b04f268f0a05a931f0c666d139cbdc3b54a427b556357514162821839cf7bd8", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_group_quant.cu": "7a682171f357b4eaefcaf94aca7c827598e97c6eadeaa3120068c82d61495379", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_group_quant.cuh": "8a386c3336f37540b8e0b91c87f0f21eb7f7de3e48b02c3b8d19456691aaea23", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_launcher.cuh": "aca30ab23b21cb1c3805f3b33a00f9b4517d7307e47f38d534c44e7cadbb0008", + "python/sglang/kernels/aot/csrc/expert_specialization/es_sm100_mxfp8_blockscaled_traits.cuh": "1c4fbbc2d1e5c8d605cce7b46d59c56675f7e0172fc35fbe5cd3582db7dab9ff", + "python/sglang/kernels/aot/csrc/flash_extension.cc": "9c237be7a8fe53b3785472c6ee1fdb0636023d8006cab281bc565389e7dfe78a", + "python/sglang/kernels/aot/csrc/flashmla_extension.cc": "aa4b35b211026318df6a5481f57ff32741bb90d9cfb955b8e83eaf8dde93dd77", + "python/sglang/kernels/aot/csrc/gemm/awq_kernel.cu": "06bf26e1fce3ab5a70fb2f66a95d51b6461a2fdae11df5f423a3353eeda397ad", + "python/sglang/kernels/aot/csrc/gemm/fp8_gemm_kernel.cu": "681c8afd21ddd78fb656ce9643b4988743faa64f178f48d55b87dfb8be9217ad", + "python/sglang/kernels/aot/csrc/gemm/gptq/compat.cuh": "4a2d33e68e4930293d32475a6f57edd5e42d343dd642cbf1f5a492558e505374", + "python/sglang/kernels/aot/csrc/gemm/gptq/gptq_kernel.cu": "6f726c7687d5721d645759dae892b70ccf18cccc929cca31f5f0b1fae986de64", + "python/sglang/kernels/aot/csrc/gemm/gptq/matrix_view.cuh": "efb127be9bbeded2111ecefd4df9d2b5eb625c0ffefab904cef21ef1b1657aa3", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_2.cuh": "1a706e6266736241be7f851697c4c4ecd685c9f0b0894436530eebd81761000d", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_3.cuh": "f7fae2447ef01c66d3b62758a860e041ae3b6477714846a8be5834215aa23a51", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_4.cuh": "7fb89f88bc54d7df14293c272694bd984e987f62d569ab7408c484d403058494", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_8.cuh": "a65c9207b4dd8815680cf525155ead154b3ce098251073adb6138b876ff56f7f", + "python/sglang/kernels/aot/csrc/gemm/gptq/qdq_util.cuh": "3a0712467f6daae5e3ab86027091048aeb5aae39a0213b0b44e361d3393398c7", + "python/sglang/kernels/aot/csrc/gemm/int8_gemm_kernel.cu": "e328045120e3c884e33bb905ab646df6cc0a1544ffb7ba838c945136fea0c2f3", + "python/sglang/kernels/aot/csrc/gemm/math.hpp": "b80a3ffbbe5944c865331da95261696e430981b623d447adf24f272241104f59", + "python/sglang/kernels/aot/csrc/gemm/per_token_group_quant_8bit.cu": "fbc0d20e0bb890b0c84b665c92069399e2fd9ae6d9ab6fed4487ddd9ae43fc54", + "python/sglang/kernels/aot/csrc/gemm/per_token_group_quant_8bit_v2.cu": "66c638e069dae59e6c1f9a618299199d86f0963eca57cd26517a71d4596bca62", + "python/sglang/kernels/aot/csrc/gemm/per_token_quant_fp8.cu": "c8a3e755dc165cecfa09232bed58e8b36010061f050acf2f82722b75c3c1edb8", + "python/sglang/kernels/aot/csrc/grammar/apply_token_bitmask_inplace_cuda.cu": "72610dc5e2effa6b8e46518dc398cd9320f251a444b1a03026f44d80d70ce194", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/flash_api.cpp": "cb99aa9ae74fe2514e4103d76b549a57a1b3b0805ee8823792bc63c547d74f59", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/block_info.h": "338f8246268db78724cbd7720c553247b302ee6002db1ba8b643ed4586309608", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/dropout.h": "02efa0d8584b2ab0793a9e40c69d13d49ee07b66f91f573f56ab42786af9e4ec", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash.h": "72c173aba8ffa52627ce9ed74c82deb03dc3f53c61a380825fec277e4f07de59", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_blockmask.h": "e0fb10597a7e22170d3e6e4e20b7aabc24543f3f24bd8a2f4369cd6236478a9e", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_kernel.h": "768fc27a85ac26c311def3e5c3c7f49cf0df3e4e0fe60ee00347f93bb3b97371", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_launch_template.h": "f8ba739ac0af00da53a7737aa954b4ab693690cfe23ff28ae8e5770985eb6c51", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim128_bf16_causal_sm80.cu": "206684211db2830b101122c741da0d0a7cf96a1219ae1a79012fe9fd0e04cd4f", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim128_bf16_sm80.cu": "ce345f08360f2112b4e1cc3646bf1efaa4afaccb4a12db6cd661ea84ea8868c8", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim64_bf16_causal_sm80.cu": "bb1d25fffadb5393500e2502a5cf3650720187ecbe227f9a174934364356e2c0", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/flash_fwd_split_hdim64_bf16_sm80.cu": "bf75ee560818988da58a2cbdef13e60185dbcee9577f14e0e042ab3f4f4cf385", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/hardware_info.h": "3adb689a79f653b97b19ad0cd5a25d8b44d71dda43c55cf774ca9f698d61fe74", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/kernel_traits.h": "440f8322a0e9b2b07c165fd0b62360bfbc28e1640944b1b5c54dfe31b6fee367", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/mask.h": "50637532c664222e24d0e42d916c3bdd9382e05ee8241d0bb30cdee85c929493", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/philox.cuh": "131c4da3f06a3122242878bed3574e2e2353ae6d4eb228aba5028204a5232a4b", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/philox_unpack.cuh": "14d35e2e51b5f248d7007d4f783c46c29f5803444ba7d4e30204a50fd6811ac5", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/rotary.h": "f616830da4716124b6962eb200a3fb5c26e22bf4b13c0aa7ada6f17f73adae49", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/softmax.h": "8d61de3d1cdd8dbffd506c63f9231626b133b2db54cae93a71f3607d3753d691", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/static_switch.h": "b873eca73e4826d2da525405a80a16fcb23cd6a416c2b94b99c35646ac4f8ffc", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_attn/src/utils.h": "c7d40d5605abb766478d1f2cbb2691eabcf376a4dd03d609732eb8b6671583ba", + "python/sglang/kernels/aot/csrc/infllm_v2/flash_extension.cc": "968bdf8e0b951ca19a97c2ae9c36e9c938dc7df1fc6ff92e7e6a2d03e11fce92", + "python/sglang/kernels/aot/csrc/infllm_v2/max_pooling.cu": "3376def6b26d2f527e51adfad1a8dd8f5f8fa22f29dd3d6352e765d0f043cad4", + "python/sglang/kernels/aot/csrc/kvcacheio/transfer.cu": "9e45665fcb3652683948754449f4d31e91117f53874bedd1285d67f7127b285f", + "python/sglang/kernels/aot/csrc/mamba/causal_conv1d.cu": "93421646032517ce921319ea86a78086de164de5dd7c7fc95ddaa075d2c1c8c5", + "python/sglang/kernels/aot/csrc/mamba/causal_conv1d.h": "2e4bfde82f89142647170a7812270b42f487627c6032fc735da52ecb43e006f7", + "python/sglang/kernels/aot/csrc/memory/weak_ref_tensor.cpp": "f8aed1facc79cd1e7f15cec7e8b5ece97cc12d0569a4183a0a69925ed5b24d80", + "python/sglang/kernels/aot/csrc/metal/README.md": "fe9699f735ffbb368fefb831a7a64b27ee5049b21cd9656493a8de53e696e697", + "python/sglang/kernels/aot/csrc/metal/rope_pool_fused.cpp": "2df146a113b9590d1cf575b65af28a0c454ac2e59365b90abcadccd50075e116", + "python/sglang/kernels/aot/csrc/metal/rope_pool_fused.metal": "b35b95a18d956288360b571a9d08cb3765dff377df7c202d39385ba9bf8f50d6", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/scaled_mm_entry.cu": "96c8953053bd1206bbe90f57e43ca6ae5f5467e561dceba7c3bdf9cbaa08a93e", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_get_group_starts.cuh": "f254d94fdd77acbc221a587f9e82589c3c9cb85ab45d6cb4ff339a0e783e749a", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_grouped_mm_c3x.cu": "5569ab6a80fc6d9fefbc986edbb61ca67bd9c44b0c7be453916aaf163aaf78ec", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_grouped_mm_c3x.cuh": "e8dae3c98e24e4285b22efd97524ba612b1706e089707792ca0c2d9c1a5c1d41", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe/w4a8/w4a8_moe_data.cu": "3198cea71295f8dc474e9ea0bfb837bb76ecb4fa2988e6c6e4593c4ca53af6a7", + "python/sglang/kernels/aot/csrc/moe/cutlass_moe_helper.cu": "44a65aea73b94d50d7ae15aadecb27df8907139f83ffba0c2726f50f2929773e", + "python/sglang/kernels/aot/csrc/moe/fp8_blockwise_moe_kernel.cu": "b812c2972bff64e1571d22d7313efbe330c3322d06cfd25e50b098f418a3fdfb", + "python/sglang/kernels/aot/csrc/moe/fused_qknorm_rope_kernel.cu": "bedd99015a68a39175c20b07c917046d7ee25b268aed9a998fab01a3423455b2", + "python/sglang/kernels/aot/csrc/moe/moe_align_kernel.cu": "4f1afca3ec9687272213e4dcae2570fbb0ff98e418a0d73e542850d245969feb", + "python/sglang/kernels/aot/csrc/moe/moe_sum.cu": "d34f734c50db73d52100a03ff0c958f7216301f376f8aa4625fe810ea002993c", + "python/sglang/kernels/aot/csrc/moe/moe_sum_reduce.cu": "03717a4617562fb7704854dc276568c587e998f248b6addcf25e12d9fe2ffef8", + "python/sglang/kernels/aot/csrc/moe/moe_topk_sigmoid_kernels.cu": "4b8eadf84561c8b71c31893508caacc2c132a15510c725385616775a59e16ce3", + "python/sglang/kernels/aot/csrc/moe/moe_topk_softmax_kernels.cu": "e1ba39d23e79b5a209f8ea6adddb283170055f1d5523e63298a8aa1e70ba0e9c", + "python/sglang/kernels/aot/csrc/moe/prepare_moe_input.cu": "811aa0a3bb94ceb65cd2d156a79d8355e1477c35177ef0b60fe3a74e90b26be5", + "python/sglang/kernels/aot/csrc/musa/common.muh": "23faabc0b5750254f7e36666677aa5c7d13dffde67444939f8af4b4dfe38d7c5", + "python/sglang/kernels/aot/csrc/musa/dtype.muh": "49646e157e5b9d1adc5123c90d51bf72f5b0e21e9cddf0204b6389d865149e39", + "python/sglang/kernels/aot/csrc/musa/moe_gemv_swiglu.mu": "35d8a2e327fd4a27f77e9043a3e29c29efd21a792d64b30887c1a0826b9e6268", + "python/sglang/kernels/aot/csrc/musa/pos_encoding_contiguous.mu": "a29f93eecbe8364f7553ec33957d597b03caaf068095b7806c94bc1a26a97dcb", + "python/sglang/kernels/aot/csrc/musa/ternary.mu": "fa932c991708954f91be0f1027ea0908d801f5d001262234084bd7f4cb28cd85", + "python/sglang/kernels/aot/csrc/musa/top_k_top_p_sampling.mu": "789b4a6c5cb4db331d3dab2b27f27a0e6d45a948e84674bb4a01ca20b4f6219c", + "python/sglang/kernels/aot/csrc/quantization/gguf/dequantize.cuh": "e43f4899fecbb4a3f0f9bc1cf4ba9d5febed22c109caf8ed4174b1c3f2d17aba", + "python/sglang/kernels/aot/csrc/quantization/gguf/ggml-common.h": "9bd236e5116402243ff4b243fb8a8e42056ff1ae825be12a7b6da2fb108e8698", + "python/sglang/kernels/aot/csrc/quantization/gguf/gguf_kernel.cu": "9905943cd6987a139bf75753b0d2480bcfc5396f8cc9f0fe08d224451f098f32", + "python/sglang/kernels/aot/csrc/quantization/gguf/mmq.cuh": "442bb32c4becd009c0925811d800d52378a5c41188ab2b3958b82033ccd02a17", + "python/sglang/kernels/aot/csrc/quantization/gguf/mmvq.cuh": "ba9b2f97e6ba383f0650b3833311e28a7906f2de1fb98635c09f3e268abf253d", + "python/sglang/kernels/aot/csrc/quantization/gguf/moe.cuh": "6f96c93d0d35989037422e4ae5cf88ed7d3a01da8ce6449649d2ee109700c1ca", + "python/sglang/kernels/aot/csrc/quantization/gguf/moe_vec.cuh": "99573567e402824b589a10362ec9e820b6072e1ad453e739de8fc2f4557d60c1", + "python/sglang/kernels/aot/csrc/quantization/gguf/vecdotq.cuh": "7c544d85fbcd3cb6ddc1c67ff6ef1315e390d62cc92a4af0021f9690129adf67", + "python/sglang/kernels/aot/csrc/spatial/cuda_utils.h": "b2373c5172585e7ed3f289d6b95e5c5176db48bf0a5c9f155b1aa9fc7b76e0c6", + "python/sglang/kernels/aot/csrc/spatial/greenctx_stream.cu": "de20703fc8a6f359ecbcfa2d91f6556b61fa94cc605e2d606a3e075d0d898305", + "python/sglang/kernels/aot/csrc/spatial/greenctx_stream.h": "35982dff2acf36ef001c05fe220ede5984e1ad3606f0733d520f5ba4b4bd4cd5", + "python/sglang/kernels/aot/csrc/spatial_extension.cc": "5f4f6abcf0f2f47a49bd17c9f238f6cafe1824cf1b9eca4d098c4b971499fb7b", + "python/sglang/kernels/aot/csrc/speculative/eagle_utils.cu": "734d7bac46bad97d8c6446234c4875f4e8d7bc2816358eed56847d926b8ddaa2", + "python/sglang/kernels/aot/csrc/speculative/ngram_utils.cu": "d5afce91de182f915cb9ed3fe6d02c0e3c31ca3409ed87202fbb0e9783f8edf4", + "python/sglang/kernels/aot/csrc/speculative/packbit.cu": "9484696972ed750f8737a0512eb9246090383f7b0793b38b06fdfb85ecaf44d7", + "python/sglang/kernels/aot/csrc/speculative/speculative_sampling.cu": "a572115a4467989a78a3833c2b47b4097886d2d2a7c31391b714b8adcc394413", + "python/sglang/kernels/aot/csrc/speculative/speculative_sampling.cuh": "2ba289074e83f1df6cefa219b674b08c3c20061d0b5b328bf2681be7b88cbe2e", + "python/sglang/kernels/aot/include/hip/hip_act_and_mul.cuh": "854254686226b67592f6eb8562fdd8af48f8be8f09bc703ec08228cb09c73003", + "python/sglang/kernels/aot/include/hip/hip_math_def.h": "c8f8e302aebb1b187355f39d3dfd63703618c7946b66a2e5dee252881e36a69c", + "python/sglang/kernels/aot/include/hip/hip_vec_dtypes.h": "a1267963adc88ef49bfa017b4bf24fde8f4848c93e0ab7da5c5a3a4d55155aee", + "python/sglang/kernels/aot/include/hip/impl/hip_vec_bf16_impl.h": "f02542bee4e9551b17c94fa37a25cfeb94ab221ba29aaaab12e72312f5c26667", + "python/sglang/kernels/aot/include/hip/impl/hip_vec_fp32_impl.h": "d53b84a3aadc4c5789beb3a8bb1bf65a3b77f09d0659a0bc3eec451bf559a17e", + "python/sglang/kernels/aot/include/hip/impl/hip_vec_half_impl.h": "4c0ad29942f1dc2026bd838d7eba9e243d8bceef8449e5d32cd8c7e6e175d6a9", + "python/sglang/kernels/aot/include/musa/dispatch_utils.h": "ecaccdd4d957e209e9ecb09f5bc062f81d89954464ccf57ce5a78a9d66452b1f", + "python/sglang/kernels/aot/include/musa/integer_subbyte.h": "c025fa298197df52096c40141d6ee448bae96d3e1648b75225c7826e46eae0ee", + "python/sglang/kernels/aot/include/pytorch_extension_utils_rocm.h": "e23b3520c211db5334bf9cb3977f6d6d617766e63a89eeb708474c4cdd58d5b4", + "python/sglang/kernels/aot/include/scalar_type.hpp": "16333e83eb1a6a46bcbc14fca3c49249db80083b7c0bf7afee96114f94c5443c", + "python/sglang/kernels/aot/include/sgl_flash_kernel_ops.h": "895e3d6ba3ebfbe70c49a70cc96bb3745d9c2a8a35f3b64d19c7c9e54c961664", + "python/sglang/kernels/aot/include/sgl_kernel_musa_ops.h": "f68a29838d3f39ca0db23fdc3439039f374ccef429f8252d99cbc58deca417f1", + "python/sglang/kernels/aot/include/sgl_kernel_ops.h": "c26e4df2fdb420856f18c3b28276deda346fbc0f4195b7f2066960abfae078dc", + "python/sglang/kernels/aot/include/sgl_kernel_torch_shim.h": "af561b9c374499cf463f2302f7a52d0e7af0d4039e2b1db6c73292ede3a62700", + "python/sglang/kernels/aot/include/utils.h": "442a8e60bed72f78886ad23ea478b00bd0e0a21421c845bec8b035b24c6caf1c", + "python/sglang/kernels/aot/kernel-runner-setup.sh": "a975029ef18a2d93d9edc6afd3919f45c5996d9825b731208c127994aebb929d", + "python/sglang/kernels/aot/pyproject.toml": "58c174b9a07901f09528cbc6f0bc29977b93019a1b5d4201f4012bc7d39faecd", + "python/sglang/kernels/aot/pyproject_cpu.toml": "6ef324147d97db4b5ec653c2f7159195aa1df47834b0686dbd13e08eb9259f7d", + "python/sglang/kernels/aot/pyproject_musa.toml": "4794ea61ab60e421be123b6d624a8c59f0594b90ef6b3455ddae914e9d0d49cf", + "python/sglang/kernels/aot/pyproject_rocm.toml": "d7d4d7203dbf53092951d62c0966b205fddcbb015455f55c1aa642bd8ed37d10", + "python/sglang/kernels/aot/python/sgl_kernel/__init__.py": "a912485cfac6a2f28b4407807ef66d31d05e140ad79a4b7e8a009d358c49706e", + "python/sglang/kernels/aot/python/sgl_kernel/allreduce.py": "89acec7bb9a4538a82eaaadb67057ec4825b4bd2b13b1e5508f0dc441515348e", + "python/sglang/kernels/aot/python/sgl_kernel/attention.py": "b7363f7e3a976ade65d62f2cdbddf27dc7d2659df623a3f16045780d359c37e4", + "python/sglang/kernels/aot/python/sgl_kernel/cutlass_moe.py": "38a92f0897ab45242ec2e75e3faf84f8b5668abcb7a4d894c58c2de2b4f3b221", + "python/sglang/kernels/aot/python/sgl_kernel/debug_utils.py": "096c0dd0dee4fd57cbf00d6b0fa734f44b25403d627f40bf95fdd7e26fd1759f", + "python/sglang/kernels/aot/python/sgl_kernel/elementwise.py": "5af8a849dff586835b679618c568940afe8d6859b329268311ff5538f1b7356a", + "python/sglang/kernels/aot/python/sgl_kernel/expert_specialization.py": "c03ff2d24672ad0656870387671437c3e247a571dd39e9768cd4f40cb0d182c9", + "python/sglang/kernels/aot/python/sgl_kernel/flash_attn.py": "610747f2c68495c5f3ba67f1247f0a1b4e4f7df116e2f89cd8e8983f0271f9ac", + "python/sglang/kernels/aot/python/sgl_kernel/flash_mla.py": "7b4d4830a23b6349db5d530ba34920337e26b814b11f79c15e0c797054e26386", + "python/sglang/kernels/aot/python/sgl_kernel/gemm.py": "bcc6815ae2bd529f7aa8e0c4649557f85f4f3a30a52a0b267c516653701dc809", + "python/sglang/kernels/aot/python/sgl_kernel/grammar.py": "3345ab05c87474b7286d606a3ecd2b3216ed2ef1a4dbde3781e597d6491f12d4", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/__init__.py": "80528ed06dc2d02295d55cd9e906574bc28a3637bf36ce993d9b58029656c40e", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/_loader.py": "2ccca1059382518cc0d8b9057aed9c178924fd9bf34ce453e420002254437ef7", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/attention.py": "98d9b084a9c7cff0902fbb7e5e8d6dc6301b517245b47cb15f68916e4a4aed24", + "python/sglang/kernels/aot/python/sgl_kernel/infllm_v2/max_pooling.py": "72c09227a77aaf532d7276a1d9438e19060cf211dacb66c734bdf50273e92782", + "python/sglang/kernels/aot/python/sgl_kernel/kvcacheio.py": "76378182be4f3bf06fc88acaa7a4a5803d302cc6279c4cb2a75960273a988dd1", + "python/sglang/kernels/aot/python/sgl_kernel/load_utils.py": "e7db471562b3fa3748af4793fc1647f23d9dd2142249d6cccd6bbe671a38c5c2", + "python/sglang/kernels/aot/python/sgl_kernel/mamba.py": "451bcf76c35cc191eb440df80918920b52abe14f39baf6b6d225068e9a008e6e", + "python/sglang/kernels/aot/python/sgl_kernel/memory.py": "1d20daaa7336a20049c310f86a18ef5bd5f39844541cc91c5b66288375383c97", + "python/sglang/kernels/aot/python/sgl_kernel/metal.py": "b4851811dac0bcef891655288617f9a0cc3288995cb1739361e8d5abb03266ac", + "python/sglang/kernels/aot/python/sgl_kernel/moe.py": "7d2b3862905962127f89eda91a537ab4e522dc251cdc404631762f166a57bbf4", + "python/sglang/kernels/aot/python/sgl_kernel/musa.py": "b9efc53b00c0b47d85026aad0a2ae639d74ea66493cdc80a8b62902e5ef5acf4", + "python/sglang/kernels/aot/python/sgl_kernel/quantization/__init__.py": "a7d723f109f161665b6b741016e9dbc5bea724919f2019e68f29054b9f94cc51", + "python/sglang/kernels/aot/python/sgl_kernel/quantization/gguf.py": "6c924e2261309dd8ebf92bdbef4b71a00a2d716faf7fb23656011dbca7f35fce", + "python/sglang/kernels/aot/python/sgl_kernel/sampling.py": "80f01a3812ff7be617c169ab82828a09fa4f22969c42cdcaedf3a01c628bfdf8", + "python/sglang/kernels/aot/python/sgl_kernel/scalar_type.py": "ca0c5beb5cc3dd2b3c02b51dfd75d2fd9f8fafb143e063be855f8d3f4012b305", + "python/sglang/kernels/aot/python/sgl_kernel/sparse_flash_attn.py": "9211e2a98615c98e0edc69232fdccb22c8a01dd2c4e822c099e2b9e689ab5561", + "python/sglang/kernels/aot/python/sgl_kernel/spatial.py": "687898eefeb3b267ce9c0476b2877b72ff7fa8308d9cbe369294fe9893686aa3", + "python/sglang/kernels/aot/python/sgl_kernel/speculative.py": "2af216aec3e41d0c3240dcc131a0017ff734f93008f99d62d4ac30d06e1f4b46", + "python/sglang/kernels/aot/python/sgl_kernel/test_utils.py": "615d5d2124c69e20504223712ec6a12a93d4da6ab97b502f5f198209faa848d1", + "python/sglang/kernels/aot/python/sgl_kernel/testing/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/aot/python/sgl_kernel/testing/rotary_embedding.py": "3300617a366ad038b1d22002a4d9a66f3fcc04ac4eed484e4044f94c3d9c1c26", + "python/sglang/kernels/aot/python/sgl_kernel/top_k.py": "567c1c5725fad322b6e7b2d54b216a48740c9c66b58af6ed8f45a944c67fda56", + "python/sglang/kernels/aot/python/sgl_kernel/utils.py": "cc778f3a0da90fa453f684086b32c9d426fad752787f899b584431f086e13f68", + "python/sglang/kernels/aot/python/sgl_kernel/version.py": "99bedc65616d05360f828b675ffd6801969d1484cb1eb017c134acd846f576f5", + "python/sglang/kernels/aot/rename_wheels.sh": "868e715de2c2947ebaaab15ee6b2017ee2eff196630732ecaa74fd6e218fbf51", + "python/sglang/kernels/aot/setup_metal.py": "b7a37c3ba45d36562ffc75b3404044db9d38aa1f8a4c53fa0fc1121f6a828bc8", + "python/sglang/kernels/aot/setup_musa.py": "0ebaff2ca7a3b0aa518d98d45a43602f3ff965eec7f51f5268493439c76a5679", + "python/sglang/kernels/aot/setup_rocm.py": "87a8171878c36d18452d24a4efdcf9eb1cf09bcd1692042a788673749e6eb4c5", + "python/sglang/kernels/aot/tests/conftest.py": "d915f91707370a962671a554241a2bbf96ba3fae0c2a7a6e3d2aaf159d6a2f61", + "python/sglang/kernels/aot/tests/spatial/test_greenctx_stream.py": "aed5808c6fb05e60b00640e7d825f65c59f3a4e97b0e6656e8a84c594761a39f", + "python/sglang/kernels/aot/tests/speculative/test_eagle_utils.py": "198d47ad4b4f81b2f5d8a8ad4161bf857c87e86c9a2b5746291f6245ddecdb6c", + "python/sglang/kernels/aot/tests/speculative/test_ngram_utils.py": "d71a84b5cab3a98e09b92b6d6c6b5b6ecf0a235387dc124d083ca93c0b90128e", + "python/sglang/kernels/aot/tests/speculative/test_speculative_sampling.py": "f59059195c8c31159833d779e8a0bc988ca233112f65d75af24ea72d0db60d29", + "python/sglang/kernels/aot/tests/test_activation.py": "2fd80bbccd5e429138a0d163d46ba79f497d6fb947040b43d6f346d6bba905c3", + "python/sglang/kernels/aot/tests/test_apply_token_bitmask_inplace.py": "bfbbc29e342aa0c44c2646aa654f9445cf91aa2dd2d24b499d937a86a5a61872", + "python/sglang/kernels/aot/tests/test_awq_dequant.py": "2873ca279cf90b1734b7c96df358e9c62929adab9bf0f3be93bd036f2754e6cd", + "python/sglang/kernels/aot/tests/test_causal_conv1d.py": "252f9b9dd90dbbdb58360c88bafc018048b8a1c4e90b81fc46fdfef59acc65c4", + "python/sglang/kernels/aot/tests/test_copy.py": "71312e5fc1f2579a676bee1769edc52e486c95412b45d93b7bdc56d1008a0f95", + "python/sglang/kernels/aot/tests/test_custom_allreduce.py": "d2ae02bbfdd1cddf07fd1bc508d0f29094215530a12bda655670b0011beef501", + "python/sglang/kernels/aot/tests/test_cutlass_mla.py": "decea5a2a956b9e109e9c0d1f5eda558f6fb3c183eb67052385e32c8496e7331", + "python/sglang/kernels/aot/tests/test_cutlass_w4a8_moe_mm.py": "f02124611a58312fb7f9dceeeebf396a2f14ee6e73341ab7f43460925ed79618", + "python/sglang/kernels/aot/tests/test_dsv4_norm_rope.py": "9e42901508a5611132a4c95e14746395964557cb87ed56c44f6a9c9956686434", + "python/sglang/kernels/aot/tests/test_es_fp8_blockwise_moe.py": "925515f5ac77f3e9e0b303896d8bd379fec655efdc5c2c38354d6a6ed52dec8b", + "python/sglang/kernels/aot/tests/test_es_mxfp8_blockscaled_moe.py": "0843eb2853ebc8858525fb86ad9142a85594bdab8f4b247c957ec9e04369c8d6", + "python/sglang/kernels/aot/tests/test_flash_attention.py": "fd827e844ec95d5def4eb24882735c5b2b9edbba1d5beacf70b05ed847db99ee", + "python/sglang/kernels/aot/tests/test_flash_attn_sparse.py": "9f0681803e24ba629229eccaa7bc5843f9e019570fd358901926a714f87ae06c", + "python/sglang/kernels/aot/tests/test_flashmla.py": "6a50b68e252985dd01cfb24530786090a5f67f223f2613f21488ce22d88af4db", + "python/sglang/kernels/aot/tests/test_fp8_blockwise_moe.py": "157c42ae1101f32e077514acaf3c0c4c166a130d7a8bc020906db5a6ce60ed40", + "python/sglang/kernels/aot/tests/test_fp8_gemm.py": "16e23f28db3968e23553049076e6848139828543d2e78b8f30e3a651bc430c65", + "python/sglang/kernels/aot/tests/test_fused_qk_norm_rope.py": "36d4692e2e514e1638c96e3bb5bf143ba325c44fe451b56271583a69c7c3d288", + "python/sglang/kernels/aot/tests/test_gguf.py": "bc903b715cddbe06a9080f85628e6fcfaabe6e4ff0a10c6a08d71076c97f588e", + "python/sglang/kernels/aot/tests/test_gptq_kernel.py": "4c629a9dfd8a89fe08231897853f1c5d6c697d38e708cc4e3d884c2058a78315", + "python/sglang/kernels/aot/tests/test_infllm_v2_attention.py": "892f282cb77b8b80a7a1bf75a2e26f87bcf19c452fcb194cf0229ddd738c8115", + "python/sglang/kernels/aot/tests/test_infllm_v2_max_pooling.py": "43da1a8132e025def95070b081dc53a396288b461cfbf67968f6b755631a2052", + "python/sglang/kernels/aot/tests/test_int8_gemm.py": "c881c4cc6b0683b8857cae1bb5641a043b58646d70ccf6d22ae402ae4045cfac", + "python/sglang/kernels/aot/tests/test_kvcacheio.py": "48cfc734b01177d941e033e05ecf060682961b212287fb84abb78bd521602d57", + "python/sglang/kernels/aot/tests/test_merge_state_v2.py": "2d057b965a2fcbd9a7771e543b911374f7cd1ce2ab7bd7a0cd09a9b751c77af3", + "python/sglang/kernels/aot/tests/test_moe_align.py": "66a80d5dc4e874f528dc3b83e06adc3f261674b9d5d86eaf6de4b33dae5f6f48", + "python/sglang/kernels/aot/tests/test_moe_topk_sigmoid.py": "70d79d86a51976b4cdd24a2794549483f4c8164fa6dd25176fe6a316d38331c0", + "python/sglang/kernels/aot/tests/test_moe_topk_softmax.py": "2ed1ebc5cf07b4dc1d99588c2d551f9b4d142985d38a50ae0e66426224d343da", + "python/sglang/kernels/aot/tests/test_norm.py": "58f5d01b30699b221faabba56cfb8e8ce1dcaab6db227ce3734b8a3fb4bdad70", + "python/sglang/kernels/aot/tests/test_per_token_group_quant_8bit.py": "db350e50d381e3e0d44dd92128862cf4301d0d9edda09ef9658f0cc84fb0d9f7", + "python/sglang/kernels/aot/tests/test_sampling.py": "4835c5e20778b0e223893aa517ce8846955ae1282651ed5545f26c70c0f5be1b", + "python/sglang/kernels/aot/tests/test_topk.py": "c59211e1480251cdb0d4d8ecf3a05838388764bb7d8d0dd8e9bab0e7e4e7b16a", + "python/sglang/kernels/aot/tests/test_torch_defaults_reset.py": "c6f480087adb952a8a4c48d889de38f084609e3282e9e83320940ea932da8b5d", + "python/sglang/kernels/aot/tests/utils.py": "59593109617eccbd0c9a23bc52f1a167437005cddbe0576fcee904307f1e2f30", + "python/sglang/kernels/fused_op.py": "d676a11cc7a68eb4e4e3fb096454b18279719df0c681562036b9db595dd65c4f", + "python/sglang/kernels/jit/.clang-format": "ff10f2f096ddc386f50248987d484d915b9c82f142e970c7af2537baba88f9e9", + "python/sglang/kernels/jit/__init__.py": "7d3a182933356ee4a73edae72cde73251f9b4ba13b7a1b1731b6bc8acae20f5c", + "python/sglang/kernels/jit/__main__.py": "fabf3deb09e00dd8d745c1a2cd5873549601acc9b71f66619866853a24bdd96c", + "python/sglang/kernels/jit/benchmark/kv_canary/utils.py": "46c598858d164bfce232eb48bfc5916aa80e3f41fd27744ab7b282af58ae1c35", + "python/sglang/kernels/jit/benchmark/marker.py": "7fbf26e2007cea158de50a593efcf8ef8ee69e60b509cfd6df89156eaf12bc5a", + "python/sglang/kernels/jit/benchmark/utils.py": "24c533e70352bf94b9a12d6185384b4305be1f4e1e1a566bcfd47fe9d1c92690", + "python/sglang/kernels/jit/csrc/add_constant.cuh": "ad1e5219cf6eb63f5affe92cb782576cc1f238d11f39c6fbaadf757b3b88fdcb", + "python/sglang/kernels/jit/csrc/attention/fixup_zero_kv.cuh": "66695df6792a2a1dc913da535cfa5df61f011ca8e553a7efaeef7f9e794cd11b", + "python/sglang/kernels/jit/csrc/attention/fused_fp8_qkv_kv_cache.cuh": "b28e18d57ce7def3e593a8f2c29364ca8a87044c8814487ca1d079dced8fb595", + "python/sglang/kernels/jit/csrc/attention/kda_fused_decode.cuh": "d0a2078431d967efd252aa8f4a003d08fce03a34b5860d8ef5b922004d11f53e", + "python/sglang/kernels/jit/csrc/attention/kda_packed_decode.cuh": "22bd2d7675b5dcdd623d4354418073aee9686951cf7a8710b27a0ce6c65e8ca3", + "python/sglang/kernels/jit/csrc/attention/kda_prefill.cu": "9d918668ab24c4c4bd9c74c193040e97af1a91f657eff8822fc94bf4d2dbbabd", + "python/sglang/kernels/jit/csrc/attention/qsa_indexer.cuh": "672290ad5594ba94e0006f73c9d1f341ba768a9adfddbc9296b94a88d4feb77c", + "python/sglang/kernels/jit/csrc/deepseek_v32/indexer_k.cuh": "18b93a66c8d194a00c2c4010059839c9a1439d36292d834b62068e6e570987a5", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128.cuh": "5b9cd573814ad422b6ea74749bf85a6d7fb572a6c8d33b706255727318b71f1c", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128_online.cuh": "56b7d8ea4c8fc3f155c0d6d40752c57b952aaa750538af39e0b6a1c2a74589d6", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128_online_v2.cuh": "8d300e8943fd6e3d7c2ccfa21e8f80489295bee411fc2f84294f8f9842ea15a7", + "python/sglang/kernels/jit/csrc/deepseek_v4/c128_v2.cuh": "e8ee36b093eca277d2fe37f51ae21d26695e135be09da518fb82d52a17fbf953", + "python/sglang/kernels/jit/csrc/deepseek_v4/c4.cuh": "16cbbc7075baeffe17067d92ca9ff2d7bb94be6812edcece91d1b5c29173054f", + "python/sglang/kernels/jit/csrc/deepseek_v4/c4_v2.cuh": "051c7de8c9ca0c22d13215905ce99b44f2b500adc9ca7eec141f9b2211715642", + "python/sglang/kernels/jit/csrc/deepseek_v4/c_plan.cuh": "b0d792dc409ea18a8d0fe9eabe26be7b338ab86da496b588ecfb93da7ad4159a", + "python/sglang/kernels/jit/csrc/deepseek_v4/common.cuh": "793ff2ce21920bb1a62531ae5355b58a69fafd6e476d9e1dac203cbc5e261ce6", + "python/sglang/kernels/jit/csrc/deepseek_v4/fp8_wo_a_group_major_quant.cuh": "afb56b97c677475c667e0399c9b7af6c1ca222577a15a4950d57bc5acf88eba2", + "python/sglang/kernels/jit/csrc/deepseek_v4/fused_norm_rope.cuh": "97f6bb13534724cde2658a88e7dd77df12273742d241252911a44222db9b3bf2", + "python/sglang/kernels/jit/csrc/deepseek_v4/fused_norm_rope_v2.cuh": "d3215e51ee7204ed78d6800705d61ff395558e264d2e75e065b3396f6c6ca34d", + "python/sglang/kernels/jit/csrc/deepseek_v4/hash_topk.cuh": "7830147cefd0b95254242883dff567549987e50dcd81b7c6dac4a89198d260f2", + "python/sglang/kernels/jit/csrc/deepseek_v4/main_norm_rope.cuh": "133631596f649104ded59981bc2c0c51f9590bde40e8097e6c64a9a7177add88", + "python/sglang/kernels/jit/csrc/deepseek_v4/mega_moe_pre_dispatch.cuh": "715272b21652502dd619ec9e9d96c8d7b20ab3ae686a78b7ecefd45aa7b128f5", + "python/sglang/kernels/jit/csrc/deepseek_v4/online_c128_mtp.cuh": "dc5eea6ac0bc4ccc9b686e6a5dd7427fce25e750b02501079b00bf7cccc49286", + "python/sglang/kernels/jit/csrc/deepseek_v4/paged_mqa_metadata.cuh": "77168812edde134a14d98f9b6a24a140cf391c5c101addf07e716c7b02270227", + "python/sglang/kernels/jit/csrc/deepseek_v4/rope.cuh": "c599b6d5bce1f3e7cfd0422707cd1a1ad33ea676493c9fe36d73810834e88103", + "python/sglang/kernels/jit/csrc/deepseek_v4/silu_and_mul_masked_post_quant.cuh": "c3330410de115d91eb14b1f395365b9243a3403453e1ee5e0a99c3715edfbb7c", + "python/sglang/kernels/jit/csrc/deepseek_v4/store.cuh": "022addf9eece267bf8962ebd0414a2945fc6b72349bcbd35be5a45be3535cbeb", + "python/sglang/kernels/jit/csrc/deepseek_v4/topk_v1.cuh": "e0bd5e43e045d2b263b4796449e513f93f0fd50a522ed5c81ce42385850e0802", + "python/sglang/kernels/jit/csrc/deepseek_v4/topk_v2.cuh": "3b2d091c830698a6ef2820eab66da83e17788ddcc72101694850f440e1ad17f7", + "python/sglang/kernels/jit/csrc/diffusion/causal_conv3d_cat_pad.cuh": "c0091f6d158cf2ec919ed981d416b40f144e3f02ea1eb55acfaf68ac5ab55f9a", + "python/sglang/kernels/jit/csrc/diffusion/ltx2_qknorm_split_rope.cuh": "cdc91194188f11eefe18df510d54f6bf53b736d0cce3610f7484225bb5aa17a5", + "python/sglang/kernels/jit/csrc/diffusion/modulate_scale_shift.cuh": "33570b4d2adc897ed2a91d95a4e5f0e6681f8504904d699a3d9da48ebac3e7a5", + "python/sglang/kernels/jit/csrc/diffusion/norm_scale_shift.cuh": "ee74320288d630067af17dcf4bcf6c93d05fa3e16fb1e04d4f8086f8e97bb09b", + "python/sglang/kernels/jit/csrc/diffusion/qknorm_rope.cuh": "4d2f194e5100beb87ae555bfe68d9188a87b24c0ae59de75ccdfd287bfa12a5a", + "python/sglang/kernels/jit/csrc/diffusion/residual_gate_add.cuh": "19f008a703f5f0181a321628e9b62113701ae97cdfd77cd1d871c0c574047fa3", + "python/sglang/kernels/jit/csrc/diffusion/timestep_embedding.cuh": "59f4d6c7e0c470b92cc0da405db6aaef11e3092cd1b7b388e91c2031e25be252", + "python/sglang/kernels/jit/csrc/diffusion/usp_relayout.cuh": "3de2834c294e709027f68a3d526cc403442c64cae101d055565f4274c606ba34", + "python/sglang/kernels/jit/csrc/distributed/communicator.cuh": "b6aa6fa2dc87103fd8cfd32a9e7e8b822d5b28c8e78b98473fa646579ff81309", + "python/sglang/kernels/jit/csrc/distributed/custom_all_reduce.cuh": "07b0e6bec91da8f83f5c59e1f8da669e42df076f2c032932baca3bb8ab31e306", + "python/sglang/kernels/jit/csrc/distributed/ipc.cuh": "6f3aa5350b9b9daf596429b57db4b43d3584862d446d869e87cd73d38b393a72", + "python/sglang/kernels/jit/csrc/distributed/tp_qknorm.cuh": "eb461062686d3294d62637c73423b3421aacd4f70d42b5ab88ae2d2d2825502d", + "python/sglang/kernels/jit/csrc/dsa/fused_store_index_cache.cuh": "1a6d0b7b9cb9c200bfa573ed99f25c4502a0d2024400d7a2923453c4a77eaa8a", + "python/sglang/kernels/jit/csrc/elementwise/activation.cuh": "f1b56af7476695688d11bb004dc6cee144cd8922a56683a12c504c53aec26c47", + "python/sglang/kernels/jit/csrc/elementwise/add3.cuh": "ff31c39fca59586f43ed78198bfc035981dd4e49b4bd924ac3f8bc57807307c7", + "python/sglang/kernels/jit/csrc/elementwise/clamp_position.cuh": "71ed5158000a33330b8fcf8d1cb7603aa0d45f9e5c5381e4beaf652a8ee20a9e", + "python/sglang/kernels/jit/csrc/elementwise/concat_mla.cuh": "ae7e5e72f33ad0a2af0933a23a4cc46230310253d69be464c72d2fb5f46e1ea0", + "python/sglang/kernels/jit/csrc/elementwise/fast_topk.cuh": "8f2dd6ae5647f44473a1666978906581c635ebc44d4e8ff6c7977d5522ab911f", + "python/sglang/kernels/jit/csrc/elementwise/fused_add_rmsnorm.cuh": "31f906f1b51f64e6c5cf57e79f8d6acb0278ccd2547349aaf133b3fe4457bcee", + "python/sglang/kernels/jit/csrc/elementwise/fused_eh_norm.cuh": "6589eefbaab4ed170cce6bc000a49b06ba3c84bf05646d109c504d06983f420b", + "python/sglang/kernels/jit/csrc/elementwise/fused_metadata_copy.cuh": "a5ed33f509938790e0561e342ca879871133f481cb922927ba99955027d4b16f", + "python/sglang/kernels/jit/csrc/elementwise/fused_qknorm_rope.cuh": "bac3d717589496835368e3a571c7592610a8d9e43b7f25dd1d37a10b61fdd10b", + "python/sglang/kernels/jit/csrc/elementwise/grouped_gemma_rmsnorm.cuh": "acd83fd2cbd5ca4f3c6ca5362560954812ca87237b48cae80e44cb0958b849ec", + "python/sglang/kernels/jit/csrc/elementwise/hc_combine.cuh": "e251e31ad2a0bf5193abbcb0b95becc3721e26c2af69d321a517e741d35e7ee3", + "python/sglang/kernels/jit/csrc/elementwise/kvcache.cuh": "987d1a3e5d8a8a288572e31a148cebc8ab435def2378fdb828ed4e6ebf9aa39a", + "python/sglang/kernels/jit/csrc/elementwise/pos_enc.cuh": "8f77ea7925da40905fe178a038b012adcc34407c653e5a37be2cf8707a9badeb", + "python/sglang/kernels/jit/csrc/elementwise/qknorm.cuh": "ce585aaa8ed461bed8cd58424c4979204f3f346af7389918fc3594b4342429cb", + "python/sglang/kernels/jit/csrc/elementwise/qknorm_across_heads.cuh": "a3accd93f8afa05d836814f7df4f83aa8c68a807ca157c2bbe35a0a7e7c53745", + "python/sglang/kernels/jit/csrc/elementwise/rmsnorm.cuh": "52f4acbc6c5f82dabb90ac1ef80d8e030e69be68c1790583f462a9d641eb8410", + "python/sglang/kernels/jit/csrc/elementwise/rmsnorm_hf.cuh": "e20a3900bc88be6979efb4abf2f74cdc71572458e10f6be0a32ee109d9c68fbf", + "python/sglang/kernels/jit/csrc/elementwise/rope.cuh": "46780a3c1b3339a5f925f463f9589b39b95cc1f6689c3b7e3384eccc0b35ac73", + "python/sglang/kernels/jit/csrc/elementwise/set_mla_kv_buffer.cuh": "6fb00d6bfd8976292624f2889fdb353692c930422a56f348c18559985494a6f9", + "python/sglang/kernels/jit/csrc/elementwise/set_mla_kv_concat_q.cuh": "1a9173ed21bc156714a8dd7e8afb38fe231150d2ea9ee794b76bb34790692ae2", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/code_gen.py": "a98b3dd290b3d51ba9fa8ff37017f3004571b4dcb1d4775a7058999e120c8792", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/fast_hadamard_transform.h": "a172ebb9e66aef598c329a5e66198123e17663bbf8cb5b2df994f164d8eae54e", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/fast_hadamard_transform_common.h": "9142ca8c99423ae5e16cbd2016baa1d1d914c70c5fade96d26cb67c8aa1bd9f0", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/fast_hadamard_transform_special.h": "3a780812ee6425803095087b2548a26998a6e4ec8410290ee0ae57af634bbabe", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/hadamard_jit.cuh": "8d9614c3b1b2ed698242dc4241102a9d6aa5b4db06efb0c9f63057cf80c9f573", + "python/sglang/kernels/jit/csrc/fast-hadamard-transform/static_switch.h": "d5563e8b2e4d240ed5b64520d550116897d3132b892bf304e6d949042596ecaa", + "python/sglang/kernels/jit/csrc/gemm/awq_dequantize.cuh": "0269dd78d136acd8cc96deff925b02b187a2b8b86c535c4944f2ddda9a1a4840", + "python/sglang/kernels/jit/csrc/gemm/dsv3_fused_a_gemm.cuh": "32e77bc885be4c51c734119ec44f56623691c17850a3e598f0846dd20d79528b", + "python/sglang/kernels/jit/csrc/gemm/dsv3_router_gemm.cuh": "dafb382089f6ecb2c2497613caf6cd135d16307c13e45683a0bf1ab670d0874b", + "python/sglang/kernels/jit/csrc/gemm/fp8_blockwise/fp8_blockwise_scaled_mm_entry.cuh": "33d41c2ef4fe7f752b3ee571697c4cff5f4a1c061c0a6b0f20f7693eef9763f6", + "python/sglang/kernels/jit/csrc/gemm/fp8_blockwise/fp8_blockwise_scaled_mm_sm120.cuh": "57c41c6d9eb62cae7fbaa4bd65a5c1cfc63c28c133f592cf8ce8ac2088825e6d", + "python/sglang/kernels/jit/csrc/gemm/marlin/awq_marlin_repack.cuh": "15e0041d645d198c49303769a1a664bf9ed77d94b2dd7aa2e6c83277bb0db9b3", + "python/sglang/kernels/jit/csrc/gemm/marlin/dequant.h": "f07f0e1284431bd630d605b438c054509573c495d66d3a2b2e017396d84887a0", + "python/sglang/kernels/jit/csrc/gemm/marlin/gptq_marlin.cuh": "00fb263e7308b2d2cf2ec180ec53b3ea18c66ce5fef993efcafe0872b8950247", + "python/sglang/kernels/jit/csrc/gemm/marlin/gptq_marlin_repack.cuh": "baf9c493860b8f2d7af160c82a65b5b963f1da77afb02adfeb9b266435c72aaa", + "python/sglang/kernels/jit/csrc/gemm/marlin/kernel.h": "d2866eb1ad6342a106bdbc4edc87b5b3a8139d652af5bde4ca3f3d4d1ef69518", + "python/sglang/kernels/jit/csrc/gemm/marlin/marlin.cuh": "bce2c9316e047749af8553b35a30a9d5decb062d174952b6d5e46f9096494419", + "python/sglang/kernels/jit/csrc/gemm/marlin/marlin_dtypes.cuh": "fbddccaab5802b44e6167ee3747a207b88defeda2addbb04f737b85843b36185", + "python/sglang/kernels/jit/csrc/gemm/marlin/marlin_template.h": "c314a899e797b788dc3b0cf7e79d2ba2bd839a8338181e4c6c06942d15e8797b", + "python/sglang/kernels/jit/csrc/gemm/marlin_moe/kernel.h": "b7a0dfdbe8bd12dd4cf87236a0c7e102b8668e5d328b7ec2d8542b942fab4ec2", + "python/sglang/kernels/jit/csrc/gemm/marlin_moe/marlin_template.h": "6b43bc72d64a591bc86f62df2db14bdea5adce7b70b00af1a3e601a3c0d24fdb", + "python/sglang/kernels/jit/csrc/gemm/marlin_moe/moe_wna16_marlin.cuh": "a8c60a970f55eb28ea5673b471a40fe1374a6578d6b8ab3427148e1587309d0d", + "python/sglang/kernels/jit/csrc/gemm/per_tensor_quant_fp8.cuh": "a482dd40cbed6f7ea40b84d1c30d46b8e137a728d1ab1575b2497a0c8268066b", + "python/sglang/kernels/jit/csrc/gemm/per_token_group_quant.cuh": "238d3d4db7a36ae36e118bed8d37aeb9893cb40d0f5c2670cb307416499e9678", + "python/sglang/kernels/jit/csrc/gemm/per_token_group_quant_8bit_v2.cuh": "7719545131a8f77de08213f347f7b6ae242dcfb4ff2b9c4b25e42f0ad1e62020", + "python/sglang/kernels/jit/csrc/gemm/per_token_quant_fp8.cuh": "1b0603ace7a61533c9ecaefc77129cf75d459b6f1f7866cd3437e686d8024342", + "python/sglang/kernels/jit/csrc/gemm/tiny_gemm.cuh": "b6fd96712b080383cfa407b72e3516720e5283c65642ba4edb5b765e4d85fccc", + "python/sglang/kernels/jit/csrc/hisparse.cuh": "58b4d685eca4506e37b50b90e3b84a97e60481913fe274bbdb6266b3ae3efa4b", + "python/sglang/kernels/jit/csrc/inkling/causal_conv1d.cuh": "8185ba6e936a3333270082de515107ac511c0b20f05d281ed7169481f284a3f8", + "python/sglang/kernels/jit/csrc/inkling/draft_extend_sconv.cuh": "81072166e47849c0f17f6002378be5fb46649d1cfaaf261752bf3c60ebede3f1", + "python/sglang/kernels/jit/csrc/inkling/fused_decode_update.cuh": "c0f8f07a69182dacc7a857198190446ac56805844c2433c677f0bb3e8da5cc9f", + "python/sglang/kernels/jit/csrc/inkling/gather_scatter_sconv.cuh": "858d9657ba459bc79be42a48ce19cc3a93e701117395f14b1fbba83a192314cb", + "python/sglang/kernels/jit/csrc/inkling/inkling_all_reduce.cuh": "7df29829abf216717ee03cfa7fafe0abaf0e8a5be19dfed872b6a64de5d3bd88", + "python/sglang/kernels/jit/csrc/inkling/inkling_ar_barrier.cuh": "ed2c9fe6fc05c5e97d51ad7c501f6ddf5cd48e2de19cad93d4bbce57b19dc907", + "python/sglang/kernels/jit/csrc/inkling/inkling_ar_fused_decode.cuh": "2538a37b776d2d3c9c99de9f49dc5af3e5d171e5ac863861aca2e85150daf9b5", + "python/sglang/kernels/jit/csrc/inkling/inkling_ar_scattered_sconv.cuh": "3fd31b83efe21ac944b9fc872dee33cb50cf68bb08989cceb61616bd55218132", + "python/sglang/kernels/jit/csrc/inkling/inkling_attn_prologue_fused.cuh": "8d4d4bfba861b2dc20265f242a2f65a6a20dce63e2ed9cfbb7cd7a8785605822", + "python/sglang/kernels/jit/csrc/inkling/inkling_rel_proj.cuh": "c3c2b11b1fea4d191c7c2ffea9f09a4c1870eb618230fcb32421b084f51e61e8", + "python/sglang/kernels/jit/csrc/inkling/inkling_row_scale.cuh": "e7ae0573ba97ffeeefda8de155f40e8c03b8262f50b722e8f7154dc33b4a993d", + "python/sglang/kernels/jit/csrc/inkling/update_sconv_cache.cuh": "ed171c22a99ae7675d080044a4bfd4dbf32535b9686696c2829706a7f4d7fbf7", + "python/sglang/kernels/jit/csrc/kimi_k3/attn_res/fused_tma.cuh": "c67a610f15cb4faf6f4797fae052340ca6b93805774cac92a95f6b602b42f64f", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/ar_fusion.cuh": "c232ca37e83915c843b6e2dcaaa94b676eca034886f04c8a7118ca17553b65cc", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/gemm_ag.cuh": "094807027542cbdd9908c8bd00fc048c2e0577ba466787d9a0112579fcce6266", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/gemm_ar.cuh": "e04b083b051ee38d98d0445cbd7483f6d75247f0d95e75fa6eb1912e829c63c8", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/ptx_sys.cuh": "3e774aafe8c524fec8b0b7744b330fc292f50ed205ea5d01814f35080fc75d34", + "python/sglang/kernels/jit/csrc/kimi_k3/comm/sp_collective.cuh": "47fbc28a578db6566206531a4f625c4b09c90026653d7ed07c3964e44709555f", + "python/sglang/kernels/jit/csrc/kimi_k3/mla_output_gate.cuh": "a898572ee61e6d5ed092508e6317c4e049453b4a3055a27b1b09f6b6e6d7d596", + "python/sglang/kernels/jit/csrc/kimi_k3/situ_and_mul.cuh": "f115fe9d64db37ab1deb85e481d98240c436a8e4236cf95fc74146726dff797d", + "python/sglang/kernels/jit/csrc/kv_canary/canary_common.cuh": "6da3c1d349c1360694ce842cb3626d24db5039916fbd21217ded985810f21a27", + "python/sglang/kernels/jit/csrc/kv_canary/canary_plan_entries.cuh": "50e31d69f717651c4699ce50bb74bbd17ff5b3ed7329179ca827944b867ad9bc", + "python/sglang/kernels/jit/csrc/kv_canary/canary_verify.cuh": "e3f4ff7b9debe237d02cbdc13014f718031735073a11c11b19d5b7761e48b4d4", + "python/sglang/kernels/jit/csrc/kv_canary/canary_write.cuh": "a70eb75252982eb80f8c886cab052b3051aa3abadefbe15b0deedd978a3b7af0", + "python/sglang/kernels/jit/csrc/kv_canary/consts.cuh": "026e2d43e2b28ffdb031a20ebb4e2096ed77be6739444aa114b84628fa334d3e", + "python/sglang/kernels/jit/csrc/kvcacheio/hicache.cuh": "dc34f219c0c18c9111df0383db55e88bd59ed0717c139f4907096202036b7dcc", + "python/sglang/kernels/jit/csrc/kvcacheio/relayout.cuh": "5eef475951686a10fad64c2fca749935fd32a4e5ec9fe544de1bb0fb11a3436a", + "python/sglang/kernels/jit/csrc/kvcacheio/staged_write_back.cuh": "1794e12145ff90d65c32fcbb276b95c912683bbc60403dbc9f4a39b8017dea91", + "python/sglang/kernels/jit/csrc/kvcacheio/transfer_mamba.cuh": "21928b36df0588cddb62e0571bd3772a82faa4c2a3b415f094c509913388e9c8", + "python/sglang/kernels/jit/csrc/lora/moe_lora_align_kernel.cu": "406a8ae7ba84990a0864906b623f7dc46e68094587a5391d660dfe81a9cd6179", + "python/sglang/kernels/jit/csrc/lplb/dispatch_probability.cuh": "7a599a45668e1f0ba5a9b818298ed96405da81a55070184a4e5845a66714a53f", + "python/sglang/kernels/jit/csrc/lplb/ipm.cuh": "57a5f55eb0747aa72454fe65ba323a8fd31e8d716c8027f982bfec01c2ca2af5", + "python/sglang/kernels/jit/csrc/lplb/lp_post.cuh": "1932e8ef7ac2158f0dd75b6c6738acf3f701798a9423479a930cd9416ad7eab2", + "python/sglang/kernels/jit/csrc/lplb/lp_prep.cuh": "7d88b8b81de7bf0587f1068f7ed05b07382afdf681056fdd58e6867d2a2cd1c0", + "python/sglang/kernels/jit/csrc/minimax/fused_gemma_qknorm_rope.cuh": "336de8cd9adb1b78dc532e5734a99b5122e288cdd220bafb563381d4cfd770de", + "python/sglang/kernels/jit/csrc/minimax/fused_store_kv_index.cuh": "e09124ed2d1a9b2a91a1264d4d03fe8d0730b6ef91d602319cd5bf441aa678fb", + "python/sglang/kernels/jit/csrc/minimax/minimax_decode_topk.cuh": "1ff9ab6bf3079cca673799943efd6c5c9ac7cc7f33cc6ac5f5bbe5dfc369612e", + "python/sglang/kernels/jit/csrc/minimax/per_token_quant_ue8m0.cuh": "10d7e1ab1bf2a23c8a3984cf2b5c80d541b8e17911acdd5cf589943bd5b6c623", + "python/sglang/kernels/jit/csrc/moe/align_single_token.cuh": "284a9e08472d44beb552c7f13c2ed5b61c893561b95227ed49dae15e08e09ee3", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_group_quant.cuh": "398d73664bb560c2a0e1f99a5788b939793093dff2f1740a318569f7cfe6d7c2", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_moe_group_gemm.cuh": "abb556104569a0d6138516d187d1fc769fa81b613d07334eefb1744a382f26ee", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_moe_group_gemm_functor.cuh": "e4c2e9a37b380465b0eb2a8a12a0730c7e5a87ef4d66f8583918cae0715cdf53", + "python/sglang/kernels/jit/csrc/moe/expert_specialization/es_sm100_mxfp8_blockscaled_moe_group_gemm_traits.cuh": "a50295047703237a860b9a87d348891e130fd49dbcf943bf2f60ddc65e2828dd", + "python/sglang/kernels/jit/csrc/moe/inkling_gate_topk_renorm.cuh": "cff262d7fd533cced45dce24c24e4a86a08bba5599b75f62e59e7022d67a9020", + "python/sglang/kernels/jit/csrc/moe/moe_align_kernel.cu": "2c17adf81459e91fd7ad149d63ef95dcc75eb5246859c83999785003e1e72770", + "python/sglang/kernels/jit/csrc/moe/moe_finalize_fuse_shared.cu": "e2fcd4ff823725a3b0d773b9c83f4c90a964e0d2c496e3a676baa143fee77970", + "python/sglang/kernels/jit/csrc/moe/moe_fused_gate.cuh": "d336c973d0491090f236e2f4585b0974452ad9f9a6260f11af2ce7627c00ff49", + "python/sglang/kernels/jit/csrc/moe/moe_permute_prepare.cu": "e58d9bab7cd10f0cd4871008a3dfac42ab5afff3e36236ba6015c0afdd168191", + "python/sglang/kernels/jit/csrc/moe/moe_topk_sigmoid.cuh": "fee82bba2fb4ca0f4e5bed7763141ea838808d37f4f771a36a52e0833b0d0c2f", + "python/sglang/kernels/jit/csrc/moe/moe_topk_softmax.cuh": "f9c8ee1f1e9af1037612418cda472b907c6455262c93a5d1e20764cf065fb55a", + "python/sglang/kernels/jit/csrc/moe/route_quant_fused.cuh": "00a830f28c924f2bc89ac280ddee233b0d2ba701850e6bfa4d140fb4960e688e", + "python/sglang/kernels/jit/csrc/moe/route_radix.cuh": "f93a2c03c15bf98203b0412b96aee97422020e4c3d22b55416afb99dd42e0c29", + "python/sglang/kernels/jit/csrc/moe/topk_sum.cuh": "7490919bf896fff6b5edae2819c675fdb526b90fdeeaeda1fd6679d8441f36f5", + "python/sglang/kernels/jit/csrc/moe/tvm_ffi_utils.h": "58649a287b1daecf47a996dcf5ff97d225181bfb6880303b60745a606fdd1757", + "python/sglang/kernels/jit/csrc/ngram_corpus/ngram.cpp": "b7300b2911647871022f10a49cdd37736f84778bf96736234bec51a307c1a8f0", + "python/sglang/kernels/jit/csrc/ngram_corpus/ngram.h": "6f0d5387ad103989b306029a9471b205b5f8ef198c68686afa430d5c22f93f4a", + "python/sglang/kernels/jit/csrc/ngram_corpus/ngram_corpus_ffi.cpp": "a2d4a93da60bdf3c6c36c439a8afaa70bf6ff3de6ba24558177348376c7e580e", + "python/sglang/kernels/jit/csrc/ngram_corpus/param.h": "659ba17b9f053a8aac36d8d3ffe30e87e781cebffe6ff9554adad8681913b112", + "python/sglang/kernels/jit/csrc/ngram_corpus/queue.h": "682d35035db7c33fd84d576b8a5d352abeb24ed422b04de5aae180d8d7586b53", + "python/sglang/kernels/jit/csrc/ngram_corpus/result.cpp": "9964b88c15f50bd3fc27fffa94d097858a5b63b3cdda2076b66bc6c85aec7fcb", + "python/sglang/kernels/jit/csrc/ngram_corpus/result.h": "fcd172342fae7beb50cd4e164caadc41908685b0ae183664331bd900bf1402e9", + "python/sglang/kernels/jit/csrc/ngram_corpus/suffix_automaton.cpp": "368f4ea6dcd5500324097171cd1b9e0cb7a0879bee227c7cc5236c7ab525fcdb", + "python/sglang/kernels/jit/csrc/ngram_corpus/suffix_automaton.h": "acc2a2f5c9b3f89546062f283910b56cd59c3be6c0cf29c35f53da38d82f76ca", + "python/sglang/kernels/jit/csrc/ngram_corpus/trie.cpp": "371ac7f5fdf9d6c55ff894a5ae668d7168257257fb484bf661f4bf0cb65ddb68", + "python/sglang/kernels/jit/csrc/ngram_corpus/trie.h": "4e72052b2c6070a923b8124f4a4d61d4424e20aad5d7190ad10c83ef564847de", + "python/sglang/kernels/jit/csrc/ngram_embedding.cuh": "90556360102cbf1ac47eaac5ab500a9ea07a924ed273fa56ab21a63c23967a02", + "python/sglang/kernels/jit/csrc/qprep_bf16_fp8_sm90/entry.cuh": "4c42ac4c702e7162acc1b36a98e8c694b8d4a1f134b2de18ea4451a224808280", + "python/sglang/kernels/jit/csrc/qprep_bf16_fp8_sm90/kernel.cuh": "4023069a19b12db9ce3489fc591e63e44aea7c4317a784f9485c5d34cbfbba11", + "python/sglang/kernels/jit/csrc/qprep_bf16_fp8_sm90/params.h": "2e37fa9934e1555f888b9c40eb9106d64ec9cd088b35c7c4b8d84d1301b20914", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/config.h": "cf5ac5b5f0f8d69f4a6d093a51df08be7f8ec1a7137508c6f6ade32431a5759b", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/defines.h": "89c365d662f0f15e264999b5556a6627f6c61a254411ab28de79853e4a98bf1a", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/dense_fp8_transpose_v.h": "42330889541bf80258014c8984fcc1b2c9dc42bdbc64018a06f6fb58db5fdaf0", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/dense_fp8_utils.h": "34165574c9498c1fc2189b495f36d7177eb6ca113dfdcc68800e3f60fba87443", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/entry.cuh": "e30b002075802d045fe5813936d1951baf5c7d3073c0f51f6fe12d1c845a1830", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/helpers.h": "331ff0405e757a62c53cc21e0936b399725e8395165803e1d65f392090c811c9", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/kernel.cuh": "a5894c569493eef70582cb18b7920bb69285fdcee6919c6946b9836872fa2032", + "python/sglang/kernels/jit/csrc/sparse_mla_q8kv8_prefill_sm90/params.h": "e4dd80e30f31c1ac368ce6f5c1bd95e2b2e4d753d0853c1dd4309e498bfcf0c9", + "python/sglang/kernels/jit/csrc/trtllm_lora_temp/kimi_k2_moe_fused_gate.cuh": "f9bc440197f1e297f8773ab0892e99800d16233f936950314b06dfbf3c34e5bc", + "python/sglang/kernels/jit/csrc/trtllm_lora_temp/moe_lora_merged_align_kernel.cu": "cc39fdf9fd8df60afad33c3c263b659d62d8961a3a5aaaac965bf0a4df50d0f1", + "python/sglang/kernels/jit/csrc/trtllm_lora_temp/topk_softmax_pack.cuh": "727b05ce97d9fae8c98d878fa552f6cecd7fc3832a705e2208ac26dae415034b", + "python/sglang/kernels/jit/include/sgl_kernel/atomic.cuh": "c6027db53247cef8de1176fa5ef4b3e1aa459a468014ad90fbde67712917a572", + "python/sglang/kernels/jit/include/sgl_kernel/cta.cuh": "591d5f3014a43cc6bef5e5e86cf8b0304f79a86e35f4fd015585bb33b7c8079a", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/compress.cuh": "fb90d430136a949651c6f56316bca5134e2e3366b6edbfa7dbeef858a4b09b46", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/compress_v2.cuh": "33c3b30c05894ec589a7dc1d377e557c6193f42603324b8ce43fab5e3b37cd09", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/fp8_utils.cuh": "18fc737eccaeb4a6d657ab601361b3391082385d0e808c9393159c932918985d", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/kvcacheio.cuh": "be8387ed456d64f9fe707a02708d541ac7793723619af63d36d2206f0ebc16bc", + "python/sglang/kernels/jit/include/sgl_kernel/deepseek_v4/topk_impl.cuh": "8b4842c35f2c6a733c15c4c0e2e6e3f6d5800fb5694ae075659ea71e5afa3935", + "python/sglang/kernels/jit/include/sgl_kernel/distributed/communicator.cuh": "6cd35c7716eaf20d184abd4ed238074042a96fef0c18e18200dda0761f03c192", + "python/sglang/kernels/jit/include/sgl_kernel/ffi.h": "def534f44595978151e47056ea77c9eb91c9c1ebdd8f8145425704846f756a8e", + "python/sglang/kernels/jit/include/sgl_kernel/impl/norm.cuh": "d8dbe98b5a69faf48aa39f13c73306c0882dd92cfaea2fbdb42541692283c0cd", + "python/sglang/kernels/jit/include/sgl_kernel/math.cuh": "9e63daa4b29bd93bee873eabc7e374636c6c28de237d8b63beb70cca755bdff5", + "python/sglang/kernels/jit/include/sgl_kernel/mbarrier.cuh": "51153324b76e8683c9127ddfbccc3c0503e39d7192c7fd4c93cb0c68142584a0", + "python/sglang/kernels/jit/include/sgl_kernel/runtime.cuh": "f5d625427f6a78ea945adafe1eb0c9af35c5a46ae36ebe20d073756db7b04654", + "python/sglang/kernels/jit/include/sgl_kernel/scalar_type.hpp": "e1c15e090e603b230c14b0589455217773c4565b432549aed8126dfdffaa3e7b", + "python/sglang/kernels/jit/include/sgl_kernel/source_location.h": "300026cbeeabe03b10b0c46b70e2e85b19a743cbe9ff462faa1dff4268cf806e", + "python/sglang/kernels/jit/include/sgl_kernel/tensor.h": "61747de0460e2075dc6bd298212d860b4bb9812645b33b48316b3648d9ec3d40", + "python/sglang/kernels/jit/include/sgl_kernel/tile.cuh": "3ecd35d51d4198d568906d7a8db30b8b4b5fed07e6c6f722710a9ce2d9619d5f", + "python/sglang/kernels/jit/include/sgl_kernel/type.cuh": "4c72b0892e8d003490bdab2633056172a674bc6a9689be552861564c7aaf8edc", + "python/sglang/kernels/jit/include/sgl_kernel/utils.cuh": "f87eafb71f39b9428ec4b3b524c95634f794b4256a6b240a17f2aa5339d92f8b", + "python/sglang/kernels/jit/include/sgl_kernel/utils.h": "68cd3ec640f9ceaf66f46be99b1e025c2a70dde32ea95ce462a1558af78d3515", + "python/sglang/kernels/jit/include/sgl_kernel/vec.cuh": "ba4ea5d07aa1a2722b48d690462c90cf4d3af2c608de1b97897d38ffb4d3965f", + "python/sglang/kernels/jit/include/sgl_kernel/warp.cuh": "6c911f6e53045e54f1119e6219cc455e0ba2cf9205cf8cdadec81dcfc030c633", + "python/sglang/kernels/jit/utils/__init__.py": "143200928e33d8630ca5b9a38cac8e4d0f37bd4657c0d6ca9bc4bd5581d6fc7e", + "python/sglang/kernels/jit/utils/arch.py": "b24cdb3c2e0f8187b188253ca47f666725b521f911690f5a4246f528e8917290", + "python/sglang/kernels/jit/utils/common.py": "cdaab0ec52cd48eddf527e03e3c109745f2bf882751802407bc51b7e7ad4c22b", + "python/sglang/kernels/jit/utils/compile/__init__.py": "7e1aaa05da2f5c814e4d2b6452a37f270d0acefe2d4b47c5dc87f5931f1e1e88", + "python/sglang/kernels/jit/utils/compile/cache.py": "45d4b3ae569886b2ea286b6feef93e618153386776c3d563a08e1fb0028f9157", + "python/sglang/kernels/jit/utils/compile/cpp_args.py": "84be4f6ab4b3a435a424e2762cf2f48c25ccf57119e6971e83f4856d779757c3", + "python/sglang/kernels/jit/utils/compile/loader.py": "00b0fcb4d284fad3d0b82c5880487434c387f6f4343afff745e44892aaa61564", + "python/sglang/kernels/jit/utils/compile/ninja.py": "68b9ff31d0fd43bf281741bef4d2a0a53cb8463a754078d2ca2085f6d6b628b1", + "python/sglang/kernels/jit/utils/compile/paths.py": "bfa8a912174607c74237f1b5f45b0a87dc8da8b5f1f5be39868966787fae76e2", + "python/sglang/kernels/jit/utils/compile/spec.py": "f762d7d90adb2770988ab0d17b444496d9d611531ab136eb37b8c8707dd42b2f", + "python/sglang/kernels/jit/utils/compile/toolchain.py": "d75ec06b9b323b0567970a1aae9c2a49ad320b88d0352bc19f18198f6f8ba41f", + "python/sglang/kernels/jit/utils/deps.py": "6c5312bba714e3d89c441002848cfe21963d91547cf8f9b0627a9f8612488922", + "python/sglang/kernels/ops/__init__.py": "17dff6cbcab853740d5c74243a33ca7151d1efa300db6b3e2f42704052270598", + "python/sglang/kernels/ops/activation/__init__.py": "3ffae92048c328bbe02761dd0765f4720be4e01a92d6298a373ad2390236a75c", + "python/sglang/kernels/ops/activation/activation.py": "1b938a3778c68ce5f24af370c674097dd9b0dd0771d960262369a200b35cd5d4", + "python/sglang/kernels/ops/activation/softcap.py": "6137b3c2d33a4d208e44bd5a32a77c349cafe56b79b78e1f092fd980e26807a5", + "python/sglang/kernels/ops/attention/__init__.py": "9c656a6e4f908e4117aad6a826e37625b511d9b86498e18ee763237d49e1e34f", + "python/sglang/kernels/ops/attention/clamp_position.py": "3b242de474485634cfc500cb5f0bdf19b44f3dc046172f6eafea93dcb87d9228", + "python/sglang/kernels/ops/attention/concat_mla.py": "78e47bfd60ed0036d211dcdc601efd90ecc2eb08358f3dd11ad9bb911a966b2b", + "python/sglang/kernels/ops/attention/cute_utils/__init__.py": "bae5c59b81a21abc499713696addc9e0f9480b0edfafd8e8b291368b91eae261", + "python/sglang/kernels/ops/attention/cute_utils/_tcgen05.py": "72673dc0362510d25f5a800a24cfd92a329170aad0c7b33005d1e70737906d05", + "python/sglang/kernels/ops/attention/cute_utils/cvt.py": "592eb52223e0e2e1525d179a75430f109b329ce87cada679b9b1b84d5172a257", + "python/sglang/kernels/ops/attention/cutedsl_fp8_paged_mqa_logits.py": "a2cee285a395159a1003530d14791b151df242ff5d36d77e0f9e3cf0b97ef061", + "python/sglang/kernels/ops/attention/cutedsl_gdn.py": "309913901b7f9787d3e5066bb3417f4d7e5412267562acbbfa9d3b6294961866", + "python/sglang/kernels/ops/attention/cutedsl_gdn_mtp_ring.py": "f5e8eb4af1a67288103e4b9af3c9a34c0483838baa9b559a0c55de0f71ca5ebf", + "python/sglang/kernels/ops/attention/cutedsl_kda.py": "c77b7c1632d281a7745d6c10fbafcfd7f6e2f10a741ad0ef0da1bdb552af0a0c", + "python/sglang/kernels/ops/attention/dcp_kernels.py": "491b0fd6db3c8fd04d1b287026f1e9108a58e217eeeeb5e6519efeaef0984736", + "python/sglang/kernels/ops/attention/decode_attention.py": "7833f6d06115dfd54b384d9ce907a012fa2f568083d90fc0f259e9ef24bf5311", + "python/sglang/kernels/ops/attention/deepseek_v4_rope.py": "dbba9685fd108c5e1d5d8e1fb824405d396c5efe3e7f1aba786740919e72abfa", + "python/sglang/kernels/ops/attention/dsa/__init__.py": "e5a6166b0b49aa607226067dde70ae0bb447aca2e44e3d8df1652d826efdfd3d", + "python/sglang/kernels/ops/attention/dsa/cp_split.py": "d41738790eb2bef1e723b59efb87bcb60d5670c8f79ea854a8b3d13c53ad1585", + "python/sglang/kernels/ops/attention/dsa/cutedsl_paged_mqa_logits.py": "ee74a18a516ae9233f5400c5373d365993c93cf1b58106ec724dba662ec293e3", + "python/sglang/kernels/ops/attention/dsa/dequant_k_cache.py": "9fb188edb6230dab5841e3f14990cc6cf2e49c120dc26400b04fcc7bcc69426a", + "python/sglang/kernels/ops/attention/dsa/index_buf_accessor.py": "5ce7ff62b2843dae6e03601708c59078de9f3ed23562210b92f007f64e4ebdd4", + "python/sglang/kernels/ops/attention/dsa/paged_mqa_logits.py": "51591504130457f6e423f8930749ab8744e4bece16ca0cd19c79d2196634807e", + "python/sglang/kernels/ops/attention/dsa/quant_k_cache.py": "23dccba0f293449067a25b90e4ac009ce4e1d424c3358aedd9396fd35c995fc6", + "python/sglang/kernels/ops/attention/dsa/tilelang_kernel.py": "29ab236ef60c67b6e20d7d89afc972e40e31336251195b6221cc529c44ab004d", + "python/sglang/kernels/ops/attention/dsa/transform_index.py": "fe6b45fe4b764e97c012c31d774041a9ad8bfacd99725196bbefbaec993ae5cd", + "python/sglang/kernels/ops/attention/dsa/triton_kernel.py": "58c0924b2c5f5ea3febeeb490fb64a9ee205d98ec142047dd1a6860a53680f28", + "python/sglang/kernels/ops/attention/dsa/triton_sparse_mla.py": "4fd8beada8f58a93a32dedbe70283b651d6e56b8dbf3035225647f3465d9d623", + "python/sglang/kernels/ops/attention/dsa_metadata.py": "4efaefe6d925b4d5f73e7baef69a63f5cec35d5fd72c06aea8bbbcbb812b53ab", + "python/sglang/kernels/ops/attention/dsv4/__init__.py": "3c54a9103bf88ec2502024fd7f5860ec6283a5250a2fe1deeb51872535ab2e53", + "python/sglang/kernels/ops/attention/dsv4/attn.py": "4efb7a3dc9ec56b81e117c9c383dd08cf153b12c95d4f3ed2137efb0689754e2", + "python/sglang/kernels/ops/attention/dsv4/c128_cleanup.py": "140a1760c899abe8968189dd7fcad026b534c889954d8967888c25f4b1d8477b", + "python/sglang/kernels/ops/attention/dsv4/compress.py": "f010f91edc9cffe44e975a2bd628fd90998cae0c502052a61da2936b4e9ee271", + "python/sglang/kernels/ops/attention/dsv4/compress_old.py": "8717e962fe937958c68e44334ad5b81006adf93bd574a364a1c912ab603182ca", + "python/sglang/kernels/ops/attention/dsv4/dequant_k_cache.py": "d11a3b063006d8454e875d5a42398c0711f16f1287bd65956262f90a19912de0", + "python/sglang/kernels/ops/attention/dsv4/elementwise.py": "883e36339a2db3f8a8b978431bb82b080d4781568c965d4564eacb2da41b5b94", + "python/sglang/kernels/ops/attention/dsv4/fp4_indexer.py": "b69452017774f74740cbe7ccfb4030607ce15858a812a3f661636e370aa844b4", + "python/sglang/kernels/ops/attention/dsv4/fp8_wo_a.py": "cba3e8d702771b3f9e01d43f2ffa322c6a13ff29c0b2cb518b322d4dfb21cb49", + "python/sglang/kernels/ops/attention/dsv4/fused_compress_triton.py": "4e17f79ed97e57f972f1fb37fbaa59e6160b66e0aaf2fb4806b9da19c04f7081", + "python/sglang/kernels/ops/attention/dsv4/gemm.py": "7d08628d9f298c404afe3201552b8c39df5a1f8718db2c1f3dc36b3a2659d428", + "python/sglang/kernels/ops/attention/dsv4/index_buf_accessor.py": "0922ebb9bdde82b115ee9ae17ca604b5c7e55a357e2fdd54f16942eece50290b", + "python/sglang/kernels/ops/attention/dsv4/metadata_kernel.py": "c9edb7c07a5189c67ea2cf55cd6c2d60a6de5b629fcd9aba6de0b8016c7192de", + "python/sglang/kernels/ops/attention/dsv4/moe.py": "13d01b06131160266ffbd560f91a6cba515483a0c48199e9f41e466763bd8eb3", + "python/sglang/kernels/ops/attention/dsv4/online_c128_mtp.py": "3d84de7e3aee335a3ec51a49a326a340bb4bd8ea74cc2d5d45b24fbb28899aa9", + "python/sglang/kernels/ops/attention/dsv4/quant_k_cache.py": "d557c3b3b7a0062dbeee5c24d6c0499e5fecb0b10a1e3b07756a0870a024764e", + "python/sglang/kernels/ops/attention/dsv4/rms_normalize_hip.py": "435e8f05d62266fc37db9956963616bc406844d984df9bfcda36dab4f215ac79", + "python/sglang/kernels/ops/attention/dsv4/sparse_prefill_kernels.py": "74bdd03e419233ed17b7070f625ba2959299fa6419c5e0cdb8911bde5baddcbc", + "python/sglang/kernels/ops/attention/dsv4/topk.py": "bbfa1356f1a65aecdeac7ca2f23436bddcc0c30d7b5c3d2d25016732a5097c49", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/env_gate.py": "a395164121f06b671c138595abb23d6d57cdf9bbf3fa121a002aba99b211707c", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/paged_decode.py": "ca49b68c9151df67919a9fbf2247828b0ab79785466959c7c8a7eda2f69e4d35", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/paged_decode_indices.py": "f008dfe6cf2332921cc613a24fc835c9746694836242ab776a451d51eb503d45", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/paged_prefill.py": "20379961e07ffc613e4ed1f0171da22ce641d697bf722f88fa65c541d30ce419", + "python/sglang/kernels/ops/attention/dsv4/unified_kv_kernels/runtime.py": "eff745080c1c530b613465f8b8ce061e1cc74371984e41615cf9b42e8bc86969", + "python/sglang/kernels/ops/attention/dsv4/utils.py": "14c23af783cf8c301b9a125f689fb97447574778de7c433263b0a656e6e051f8", + "python/sglang/kernels/ops/attention/dsv4_attn_metadata_kernels.py": "4276de2afa328739ddcbecf7d8a48f273fddfa8d8a029e7024b82e7dacb91969", + "python/sglang/kernels/ops/attention/extend_attention.py": "8aa8d01f0a73a144f51a8b7e8dae94a96c227b1dc6b6397ab8ff03116514dfd9", + "python/sglang/kernels/ops/attention/fa4_sm120/__init__.py": "05622241f5ba038d487f91084605c66360d3e59a3cd9e2830ad08c1587cd19d5", + "python/sglang/kernels/ops/attention/fa4_sm120/dispatch.py": "f317529e990321f64bc41705a6069b37c30765ec4c780601b3e0411414ff5b1f", + "python/sglang/kernels/ops/attention/fa4_sm120/flash_fwd.py": "3ccdfba82570f26eb812808fe4aad34dc4d3efc036cd78931a17af2d429cb995", + "python/sglang/kernels/ops/attention/fa4_sm120/flash_fwd_decode.py": "0623ee03ad82f3ed9d602227931870361879ea008aabc48e74e506258a337113", + "python/sglang/kernels/ops/attention/fa4_sm120/paged_kv.py": "99d640185f7e29fd80afd387032da6f998989dfb5fa21afe9b5dac01e45f263e", + "python/sglang/kernels/ops/attention/fa4_sm120/policy.py": "58bff198c322d87166f6d7330df81e7fc3073353e277641d39c66ca3ea4269dc", + "python/sglang/kernels/ops/attention/fa4_sm120/runtime.py": "560875edbed63a59d2060dc4adff839566ff603e0e8f3443181d04785c0e71fe", + "python/sglang/kernels/ops/attention/fa4_sm120/scheduler.py": "d5dd1d29975f3e07a042ba7b509ed14269103bd3dd087494d10f55e85c08d771", + "python/sglang/kernels/ops/attention/fixup_zero_kv.py": "b5d30088d783c3f9099de0151e454258013d4427e5277ac6ec7ae9dd86965024", + "python/sglang/kernels/ops/attention/fla/bench_gdn_replayssm_fold.py": "ff66ca4c761ef052e5ed10d772e27282e5a5791f45c78bed6d3c9638e9b8704a", + "python/sglang/kernels/ops/attention/fla/chunk.py": "8edab1f6fc35b86300a91dc6afd61c2456bd7a4ed3986564456977fdb098f2b2", + "python/sglang/kernels/ops/attention/fla/chunk_delta_h.py": "580a24d2e91c885ef180f5135978c3cc35f01e96a17776baa4b13fe06533bb60", + "python/sglang/kernels/ops/attention/fla/chunk_fwd.py": "e6ee7b4601ca12ccda6fd93050acedae25d2b6e6a27a27ebf194a58533a4140c", + "python/sglang/kernels/ops/attention/fla/chunk_intra.py": "1ea350047ddada714183928ff30199796817e3b6c7907557af6f6cfe00fe1b38", + "python/sglang/kernels/ops/attention/fla/chunk_intra_token_parallel.py": "b66650b2b1299a76d471a2d026aac638727431f2786ace32eb745b9c9bab41f0", + "python/sglang/kernels/ops/attention/fla/chunk_o.py": "c5e5b0f7ccdaa744c5e0eede8ec73a5767b322132a72ce46a56f04bfe4c07564", + "python/sglang/kernels/ops/attention/fla/cumsum.py": "4f5efb6cfdf25137bbdde22c84fe28783b5fc4b6bd83ce4b57ffee1924ef7a78", + "python/sglang/kernels/ops/attention/fla/fused_gdn_gating.py": "c7736d1e506fb2c3e5c0496a2ed8c23347c2507ebe73c08bc6745517495d0957", + "python/sglang/kernels/ops/attention/fla/fused_norm_gate.py": "9110a606a057c6268932cd51a3f88ffdf419f063407559805e9b4fd2211fce7c", + "python/sglang/kernels/ops/attention/fla/fused_recurrent.py": "cf5e980d86174a631bcd0872f8ebf7a6ab7c21c3435c097f66f8ba0e686debc0", + "python/sglang/kernels/ops/attention/fla/fused_recurrent_linear_replayssm.py": "a8824a71ab49fde1f070c325c89603e6198928bdcb2238f2d6e9ef8fb7247f62", + "python/sglang/kernels/ops/attention/fla/fused_sigmoid_gating_recurrent.py": "c0142cf78d5374cbff285d8d46b39710b2eed42620d41fbd93e518104cce1695", + "python/sglang/kernels/ops/attention/fla/gdn_replayssm_spec_decode.py": "74043400ac0cf1ea5dd9b30ee1fd79ad0db2f22843c0333d8611f1ca20a4d26d", + "python/sglang/kernels/ops/attention/fla/gdn_replayssm_spec_fold.py": "fb79ad9e12ec1e485cc65e12d6394debee69fb21a14c50e1bb84a809f6a46e28", + "python/sglang/kernels/ops/attention/fla/index.py": "bb0b99067ba9f2f24d4c52fa75e6c008ce3837c519e20c18c0bad1e4a3c5db0e", + "python/sglang/kernels/ops/attention/fla/kda.py": "6d37f8f7bdfc5d430090f99106448f4051a9076c6df166fd2b96bafc61c601eb", + "python/sglang/kernels/ops/attention/fla/kda_replayssm_spec_decode.py": "bb51f807c932bc19b45eedc2a6dd3d1f6533389b3d788e0b91901b4208d6f331", + "python/sglang/kernels/ops/attention/fla/l2norm.py": "b1323047a7c7f46268a9c295f4fea5c53a210ebfb04db5b17d7ce6ff4b24b7f7", + "python/sglang/kernels/ops/attention/fla/layernorm_gated.py": "3ce4895e768aead4f12031b37fc0ee511d783b9ec476016c85b715c2dcf84988", + "python/sglang/kernels/ops/attention/fla/op.py": "592dc573983a1a20a00e1cea3b2d5a2a43ec8881d6bb45ad7a1f1faebb1cb7d0", + "python/sglang/kernels/ops/attention/fla/utils.py": "72afecb7e66a2f3bed4058901859dbab6aec233ecf7ddc595a9d21e123ead20f", + "python/sglang/kernels/ops/attention/fla/wy_fast.py": "067afef050b30951d6e24f08ada0fbd1434acdd0fb6f4f253c8f5c40c363b50c", + "python/sglang/kernels/ops/attention/flash_attention.py": "a45762ec7756a436a74f94d47b4ca2bf386976edd49001547e9600a7f652e19b", + "python/sglang/kernels/ops/attention/flash_attention_v3.py": "b77ed59eb5f8d27b32eb92eaa54bdbb229fe6d3dcd4ac2be85f43682136bc47d", + "python/sglang/kernels/ops/attention/flash_attention_v4.py": "53b5fd198ebbbd67cb65dc4d783d35b03826e18010576c350a7f32fcd8d05497", + "python/sglang/kernels/ops/attention/flash_attention_v4_sm120.py": "880ac1dde246b93bc237ed05462e030dba61886aa3ffeb892ec100459e3e298a", + "python/sglang/kernels/ops/attention/flash_attn/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/ops/attention/flash_attn/cute/.flake8": "8cb396353fbdedf8028792aa3428849e7bd9c724a6ea4953da32737860570ec9", + "python/sglang/kernels/ops/attention/flash_attn/cute/AUTHORS": "82b4aba3841946660c3d8be4b565b94477af318dd185368cf1a76aa40d7d84a5", + "python/sglang/kernels/ops/attention/flash_attn/cute/LICENSE": "8c9ccb96c065e706135b6cbad279b721da6156e51f3a5f27c6b3329af9416d73", + "python/sglang/kernels/ops/attention/flash_attn/cute/MANIFEST.in": "a9c54041b68b5e51a5ba1a3942b0eed6b39ba1b8575dd83512ca1a4584ac3ec1", + "python/sglang/kernels/ops/attention/flash_attn/cute/README.md": "69e70ec669e9a5e1b843e5b8e5e8ec1366c67e70098b84ee0d79b612cb9bad1d", + "python/sglang/kernels/ops/attention/flash_attn/cute/__init__.py": "50713012c3a5e8045f368672342aea6eeeb3b3ce0968cb5639b1f158b9499487", + "python/sglang/kernels/ops/attention/flash_attn/cute/ampere_helpers.py": "0fb11626d3d68849220d251a5ee5fa1790e599cdbf0f62817e6b4e2b2f05400f", + "python/sglang/kernels/ops/attention/flash_attn/cute/batch_invariance.py": "0d47e270bc35458417609e980b9be1c26cfd54e0d91f326fa51e7aa360309a5e", + "python/sglang/kernels/ops/attention/flash_attn/cute/blackwell_helpers.py": "e36bc15d0dbcb2e91ae99541c7275aceaade0f96b471075b43e31cef065b22b0", + "python/sglang/kernels/ops/attention/flash_attn/cute/block_info.py": "607c304d0cd123595188537a9815d69282d3a7419cb457768d8c31993f25b359", + "python/sglang/kernels/ops/attention/flash_attn/cute/block_sparse_utils.py": "2b3e749380f21d6fb77853ca4270f0c9005aad52225632202d3ee442af2f7cd4", + "python/sglang/kernels/ops/attention/flash_attn/cute/block_sparsity.py": "9ca21cf8b9ae5f7c44023df646f70b793667cdce2bbb09ba15f5f7a3a19a4c26", + "python/sglang/kernels/ops/attention/flash_attn/cute/cache_utils.py": "c34ec6747921a83f4e1fa6838fb42e694a36d5f1a4b3b3a4af3e4e68d25971a9", + "python/sglang/kernels/ops/attention/flash_attn/cute/copy_utils.py": "43ae6db77b9e48280ba7b6e7413ed24929430b8a53015bc5ea9dffad57d1e9ad", + "python/sglang/kernels/ops/attention/flash_attn/cute/cu_blocks_kernels.py": "31a4b3dd15457c0fda258931544bed4ae859c71de2775bc9679ebd544aeca388", + "python/sglang/kernels/ops/attention/flash_attn/cute/cute_dsl_ptxas.py": "acc3f18e41bca5555505dc79129e45eae6a3a5510d0b9e93fc1614bdad242776", + "python/sglang/kernels/ops/attention/flash_attn/cute/cute_dsl_utils.py": "03520beefd65d44c5bb1d3420e18664f0202b3c7926ea9d5dd8c97a983ef2583", + "python/sglang/kernels/ops/attention/flash_attn/cute/fa_logging.py": "bc71edfa4b1cb7af64b78def09e790ff4c6fe64ab4fcf8e3d9699f44e8d3c0a0", + "python/sglang/kernels/ops/attention/flash_attn/cute/fast_math.py": "7e5f822bf4d0ba36967558f3ae9a1408b410cb726c31222cd61703569d1be738", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd.py": "97edf14f4be14d83176efc816f867c0bf751ae65b380942da9147932ce959ea4", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_combine.py": "b604abd7f3aa747451a733bb98ec2cb159febbc0140c58a16fba56e415b170ed", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_mla_sm100.py": "5b180193a2f3ad7c0d87fb19b7d6ea1985bf2d70102e4abbb34ab8c09015e573", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_sm100.py": "37e40dbaae7d22c87210c4e0541790e9ace2d66e469259faf5b299f746403dfd", + "python/sglang/kernels/ops/attention/flash_attn/cute/flash_fwd_sm90.py": "16815521b74bfc9e5fc16411e503da6ff5b4146a0d40e0563073bafcc90d61c1", + "python/sglang/kernels/ops/attention/flash_attn/cute/interface.py": "4d74a7506b635f9890daa6705784148a71bd0bce22e0c21ecbbc3d5090f76368", + "python/sglang/kernels/ops/attention/flash_attn/cute/mask.py": "1f4a0980b684083ab4d8bd90dc617bc9f2b6ce8074532d9d5814e76230f413d9", + "python/sglang/kernels/ops/attention/flash_attn/cute/mma_sm100_desc.py": "3f87737997bd1e589500ca8b3b8e6e56fb466760b4eb63eeaa332bbf1bd8b6f9", + "python/sglang/kernels/ops/attention/flash_attn/cute/named_barrier.py": "729f4581800b31e1b6116bc44c0f9f5268b986cd7ed108d407d4bee4441ece46", + "python/sglang/kernels/ops/attention/flash_attn/cute/pack_gqa.py": "71b087e2f1d299a8c9e5181e6d083444e9a421f749b7cb51c5129abeef0aadf8", + "python/sglang/kernels/ops/attention/flash_attn/cute/paged_kv.py": "a80b0cafdca4a570722d6d4edaf9a35e5ec31d535360b14a931bbc393d51a359", + "python/sglang/kernels/ops/attention/flash_attn/cute/pipeline.py": "71f7416f99bd187758e940d51094e881a0e485c96d5fad5224830c7d5fa1f846", + "python/sglang/kernels/ops/attention/flash_attn/cute/pyproject.toml": "ab14226518b1a9121bbd2ac19794d7babebf1a89a2e25790e94ea8f2a397d646", + "python/sglang/kernels/ops/attention/flash_attn/cute/seqlen_info.py": "e2444eb09131f12dddf4444e54985e60435b877012ea90e73ae4b8da6483e6d3", + "python/sglang/kernels/ops/attention/flash_attn/cute/shearing_bias.py": "2c1d13ab9b569a6b2309098cac4f946c4971c34158d13d563f1de28a3acdd195", + "python/sglang/kernels/ops/attention/flash_attn/cute/sm100_hd256_2cta_fmha_forward.py": "6d315ad3f40404b0da688f57bb481bbe0766a92ff6b4ffdcb5b35686b7c0072d", + "python/sglang/kernels/ops/attention/flash_attn/cute/softmax.py": "b9bd63eb9f27be36e60e7c3040eefe9f6a5967051086b752e80a005513e4d268", + "python/sglang/kernels/ops/attention/flash_attn/cute/testing.py": "e83f8804a1198f967267cb3b081bc8cc3bd1b4e7d50a7bf04b6e2bf020956cc7", + "python/sglang/kernels/ops/attention/flash_attn/cute/tile_scheduler.py": "e6d1b4ebd9708f01cfb5e12f4aa54dc9f7d9b15d7a92c93a28faaf9407a7102d", + "python/sglang/kernels/ops/attention/flash_attn/cute/topk_gather_kv.py": "f1e226cb2552c6cc1ceacf706a5c5ac40b39ad7ddd2350136e2579491199dbe5", + "python/sglang/kernels/ops/attention/flash_attn/cute/utils.py": "9ca44a24082e440b13afa5c6f18fb00cfeddbf6f79d1e5cc5274eb9dc2543a78", + "python/sglang/kernels/ops/attention/flash_mla_sm120.py": "f80df68c252a8c8960f96e97d1ae9d89825358ad286f716f7d8eb66300c29495", + "python/sglang/kernels/ops/attention/flash_mla_sm120_triton.py": "37e6dd6dcab87a812b20a2ea2d35ae01a32cdb2e8dd67fa0ebbf799873c1e4a7", + "python/sglang/kernels/ops/attention/fused_metadata_copy.py": "34a84755371995870a179ce60a20a216a6f5aaced4640e9348df424203f83054", + "python/sglang/kernels/ops/attention/fused_qk_norm_rope_store.py": "0803a0e0a4b462b4211abe8b6cc51684a47cdcce8d8027b3a6aa13eeb7cc7241", + "python/sglang/kernels/ops/attention/fused_qk_rmsnorm_rope_gate.py": "d1972dffb4da33fab4410567f32359527bc5c32794c8d8015ffc39b9b9d80cc1", + "python/sglang/kernels/ops/attention/fused_qknorm_rope.py": "fc0131556a5b80bc6585caba6e6cccab3f4a44079e72bc7f93cb1381ebd64d90", + "python/sglang/kernels/ops/attention/fused_store_index_cache.py": "e5cb4a31c5a51fc0b413fa729f9712270f86c815853baa6183efe6861075fcf4", + "python/sglang/kernels/ops/attention/helion/__init__.py": "307fa361ccc4a4eb6347d5d3ca1199a17be821efa55511946609af5e763e8953", + "python/sglang/kernels/ops/attention/helion/kda_decode.py": "25803b176e1830355afc854fb1117bbd96637e7b67a6778aa627d90567260a7d", + "python/sglang/kernels/ops/attention/helion/kda_prefill.py": "200e95d07f68b1dd11c4d6b76f962dc98e383ed2af19ebb05740dc37b0ece58c", + "python/sglang/kernels/ops/attention/helion/kda_replayssm.py": "327b25962159b19f310330a2882be9517979997b7b0f1e869d04d4644b5a2137", + "python/sglang/kernels/ops/attention/inkling_attn_prologue.py": "463474b4a7617981611db3ff36790e95d2d98488defac193c6f70a1de8e5fb1d", + "python/sglang/kernels/ops/attention/inkling_rel_proj.py": "5deee148391d06dcb2e78b3f08cb6ece6d563c7c5b361f488f3ed90aacad472b", + "python/sglang/kernels/ops/attention/inkling_row_scale.py": "8abdff86ace18bfa9d90953d054dcde3cc28c306c6235d108e3bc29bff830924", + "python/sglang/kernels/ops/attention/kda_fused_decode.py": "0038e4b82f74ff2569a29e09b1b9f4a8d5b0008b2b6784a67152b190f36fe7f3", + "python/sglang/kernels/ops/attention/kda_packed_decode.py": "518855d312f44ae0ca1bc5f730fd5f26c98e731f9298ddb1e493a3d46edebef2", + "python/sglang/kernels/ops/attention/linear/__init__.py": "121dd755ac7b2e17c9ca8bfa0892813d98ac8af6a96b865c37be5b7966713d00", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/__init__.py": "773bcce973a6496403b6e07413928903931da727520e680b7d1f51b2d97c36d4", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/kernel_h.py": "e751896358a46abb7e338847962b1fa1a12f5c99979092a54bb719c61dbcb126", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/kernel_kkt_inv_uw.py": "f5743c4a14bdab8baf6aa79ed7846931b2afc883b9f58dacf7339e971116bf71", + "python/sglang/kernels/ops/attention/linear/gdn_blackwell/kernel_o.py": "c06b292daa82e720c4c6ca0ee03cb1d84c851e05e95f795adea4ffffb4df4333", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/__init__.py": "da6231a532f3bca80336e020e10ee5e099ed9ff39e27548fc9aaabe51631e6b7", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/kernel_h.py": "c7f6ae3771d09223c61689649cba1e9d87656b3c75115effdb67ce1e62fd7842", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/kernel_kkt_inv_uw.py": "115feffa986944f3e538cd47403f738e6060c8c9ab3930b673c79f1b7ed16a98", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/kernel_o.py": "4d9cc537c45dafffc2654a9851bc6213bec267ba7dd0895ae9377b102b896f5e", + "python/sglang/kernels/ops/attention/linear/kda_blackwell/prologue.py": "72c1b42d256bc797d291bbaae80493206813beccf098b99cccd4e145b4807785", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/Akk_inverse_lower_triangle_bf16.py": "418208ba8acd2644750413ac223b18423a45f8fdc3aea2714f6987ada8e991b2", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/__init__.py": "04282eb62222296bf6778f01eae374aac1d0fa185da63498898dfc55fe504a3a", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/chunk_fwd.py": "e70269de406548d9ab0e4180a293746e9c7d3fdb687fc9ad45cda5c3c414e88a", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/fuse_k4_only_persistent.py": "79398ed857a586dad6e71fde4cf64b22006941e48d929b503e1b43fd875c279e", + "python/sglang/kernels/ops/attention/linear/kda_nvidia_prefill/fuse_kernel123_persistent.py": "d9c79963c50a01704c306965585bfe2f41b89f2e77c746144fa87967fd58c4f6", + "python/sglang/kernels/ops/attention/linear/kda_ptx_prefill/__init__.py": "5967689a59d9eec6a188fea05331a3c554ee38e9b4de590310f090231eb777a1", + "python/sglang/kernels/ops/attention/linear/lightning_attn.py": "e7c81f873addd1e66f1b6ca829f13ddea1cbe97b54702f42c10971c8738f7ad2", + "python/sglang/kernels/ops/attention/linear/seg_la.py": "a5a52db38a754a2358984022bc0c81a027376cc6b8c14c5f719799526f4e7e6e", + "python/sglang/kernels/ops/attention/log_scaling_tau.py": "a879bd967980d4c7a9cfdb084c23aebf117d6324827fe5b526b5736339a04302", + "python/sglang/kernels/ops/attention/merge_state.py": "bfd9c3d356b97939e4c19c4cc0446daeb45f0b9aece86c6460ea44ae400f7182", + "python/sglang/kernels/ops/attention/metadata.py": "8301be5035f976e02e91323fb469f0e925193ca4a25a39cf25640d50c66f0d29", + "python/sglang/kernels/ops/attention/minimax_decode_topk.py": "3e773a7cc4d20a05585993242d10d5fa0e59a16cf06b4c31596ebc97308eb090", + "python/sglang/kernels/ops/attention/minimax_m3_qk_norm_rope.py": "e782750231f136aa4d606c1b06fbaa1f9c66d2ac9a0a97900b75ab2268ef63f0", + "python/sglang/kernels/ops/attention/minimax_qknorm_rope.py": "b97f5a99b370e6b7e561f68b29e3d56755cfdb4f62dc46d3272adaac52637a23", + "python/sglang/kernels/ops/attention/minimax_sparse/__init__.py": "891d49998a7c1bf8dcc77139b4bd6e1702fe40c17efcc315895af5e307ed3c63", + "python/sglang/kernels/ops/attention/minimax_sparse/common/index.py": "f7141f5d82e92f88533ac3a4ee7001cb1c2181f1f0a8b487c41da28646f9484a", + "python/sglang/kernels/ops/attention/minimax_sparse/common/utils.py": "7dd6ffa28fcc14374cc2d7006c884217300b344fe544e56d8bbc662c1a9af3bc", + "python/sglang/kernels/ops/attention/minimax_sparse/decode/flash_with_topk_idx.py": "84a9816213d65af954a712faacd0e44045aeb60376ccf2bc735f6e1f143be6f4", + "python/sglang/kernels/ops/attention/minimax_sparse/decode/topk_sparse.py": "a7ba7bf7919a7faa02bdd2888f939e7648c6b84bdd6b6616c28b2aa8fc28cbc4", + "python/sglang/kernels/ops/attention/minimax_sparse/prefill/flash_with_topk_idx.py": "e9ea1ab4e617d261752c49ce40650ff561dd05068d410f99c82270d3daebf87f", + "python/sglang/kernels/ops/attention/minimax_sparse/prefill/topk_sparse.py": "1bc59d10771c5f4ecf98b0addd50e7de88cc7aeeddb9121532ccd259458c3688", + "python/sglang/kernels/ops/attention/mla_kv_pack_quantize_fp8.py": "dfab3349c84cc1ed458ff18253952a0dd88ad67798e0f90b1d37d84952cccba7", + "python/sglang/kernels/ops/attention/mrope.py": "5d42bb01f7ceee189879678054e3023c0c34130d75543ce242da7cd14ebb7cb7", + "python/sglang/kernels/ops/attention/nsa_triton_decode/__init__.py": "7b1934f54d88e22c722df8986d7ae30c4609d19e3b257af13985c14aafbb07cd", + "python/sglang/kernels/ops/attention/nsa_triton_decode/triton_mla_kernels_decode_fused.py": "9664d16537fee95b0e50fd24d14b8f12b8aac495691aef2e9895654952f707f5", + "python/sglang/kernels/ops/attention/nsa_triton_decode/triton_mla_kernels_decode_optimized.py": "7eba46e5715be8584edd1403cf8d9088277bd4d8679737e31221d1966c437234", + "python/sglang/kernels/ops/attention/pa_page_table.py": "f21bf6bbf7ceb104bfcf3f0b9a4e4308a8526dd3f08fc1d98310b99518ad3daf", + "python/sglang/kernels/ops/attention/pad.py": "805e534b8533092ae375f7186d5bc35051abbfd9bff38e4238df41d9ab2d5ea4", + "python/sglang/kernels/ops/attention/position.py": "5b0c61b2bd74d4eeb1d3fa21dfb37c52838ce3533701c4f9f66f6031fdabfb17", + "python/sglang/kernels/ops/attention/prefill_attention.py": "eb158c4c03e69091eb95a1bce093c9b054ac1ca5aab12769063d2e84630ca7f3", + "python/sglang/kernels/ops/attention/qprep_bf16_fp8_sm90.py": "6b76a8f3c6fe6a2588f78cf2f3af0b23529bd9d2dd36e305a2dd2c99d25ed628", + "python/sglang/kernels/ops/attention/qsa_indexer.py": "2e413f99a9c5e475f98529691f1dddf7b59061ff234e107b1894e96e956a54cc", + "python/sglang/kernels/ops/attention/rocm_mla_decode_rope.py": "43e72631dde538f70478b8f31ec9298561109f772538826c6ed558b3a41473df", + "python/sglang/kernels/ops/attention/rope.py": "079a4d99dadbad673159bdb7ec9231467a4ff6c4aa63a40850022e61995a70f9", + "python/sglang/kernels/ops/attention/rotary_triton.py": "49b3a2ca2784b4ffb0773947d2e26055f55a520c9cd847b86bcc3f6c2bf94d05", + "python/sglang/kernels/ops/attention/score_mod.py": "01f6e619d93d1f025940ffda81f39d36ce31cc8608bc7d21c923979d41ee924a", + "python/sglang/kernels/ops/attention/set_mla_kv_concat_q.py": "0b56dd69bc4d5975f7b20fad798508eba5d5230ee04bf8623f3a9f5795578a85", + "python/sglang/kernels/ops/attention/sparse_mla_q8kv8_prefill_sm90.py": "0ff15d46709c97554652c6052d67832fc234376752bbdd4ef918773b7e033131", + "python/sglang/kernels/ops/attention/triton_gdn_fused_proj.py": "c3a7595605ff253d9ad46018bd123d7d1fb10002a3d556fb6bc5d0b323e04bc2", + "python/sglang/kernels/ops/attention/utils.py": "649ba76f5997dbb95abacf9b32626e3349b1156402f5acd30a15d741888fefa7", + "python/sglang/kernels/ops/attention/verify_mla.py": "40b1dbee180ffc289977953a448979088b4a99f7eed8b2cc0b04a41dbd84aa59", + "python/sglang/kernels/ops/attention/verify_splitkv.py": "0c2c4009b3553e13bcc4ae1e0e375aa5c96c48e6c96ab9a475a3e2d874c3c6c6", + "python/sglang/kernels/ops/attention/vision_rope.py": "d0e27aca64cf83cb90548d9e931835d44046da8178f216c8fde81befdd732194", + "python/sglang/kernels/ops/communication/__init__.py": "f9a34481689fa042fc994899cc4110f44f41c8f9c51211e86af7bdf5f64b4b02", + "python/sglang/kernels/ops/communication/all_reduce.py": "a10b7bc586399ae06acd2766b74c27ae309ce28b64ae982755bab1c26ea8a1d2", + "python/sglang/kernels/ops/communication/inkling_all_reduce.py": "b323b96e8cae729484d70d418326affaae2c78f4e71582c98421e78ab9e17184", + "python/sglang/kernels/ops/communication/inkling_ar_fused.py": "30cfef8bf611749121715f8c5bb5c1b9d22517ae6884faf00798628571d36057", + "python/sglang/kernels/ops/communication/inkling_ar_scattered_sconv.py": "ccc90e7dbb8a2b9dae4d61fc30b259c9651116ed4178051b9b40a74031af7b06", + "python/sglang/kernels/ops/communication/mp.py": "8e229fe09ad4e938c946bfafc0bce6e75457f39931ad264b0332de76863e91ef", + "python/sglang/kernels/ops/diffusion/__init__.py": "48a131d5c1ab2526dde5c0bddd9c563735521d745d47ecf0fa86f53d83110f33", + "python/sglang/kernels/ops/diffusion/bitexact_gate.py": "a9a5bd028d32117f426fa4bca29222f999354d1e1c426510597243a84dbcc840", + "python/sglang/kernels/ops/diffusion/causal_conv3d_cat_pad.py": "16df0e84da819237ee0b689a18fd3769bb30b9fe3b399820f48c83883e332508", + "python/sglang/kernels/ops/diffusion/cutedsl/common/norm_fusion.py": "8e4feea1ef0a026fef873136c2cde82ce5cf823357ebc60267e770d89c71bfcb", + "python/sglang/kernels/ops/diffusion/cutedsl/common/reduce.py": "90b8a0ea9a857849799ae8c17e3306271b68156082fcc4c257b28a1d051e7e2e", + "python/sglang/kernels/ops/diffusion/cutedsl/scale_residual_norm_scale_shift.py": "db66599cb0d4cd16aa62b8c775218de5da95b00a46ff448b78ead3e230e98bee", + "python/sglang/kernels/ops/diffusion/cutedsl/utils.py": "5bd351c9360fef8596b5cd3cca269d2dd60ca3d1f3218f1149948c6549d92bb8", + "python/sglang/kernels/ops/diffusion/flydsl/fused_residual_norm.py": "f1317cd8ee0ec111739d51931444d0fa06b1cfffdce18a098e44f485bb820ced", + "python/sglang/kernels/ops/diffusion/fused_gate_rmsnorm.py": "8a6333c6f65e8cc54d3dd7c581cff06fe65b9642a37aa5075c5664ef6472043c", + "python/sglang/kernels/ops/diffusion/fused_linear_gelu.py": "f76926ea975e5cc91977f4dfb2651f7b09bab6d9b681b7584ececb641a8d2d14", + "python/sglang/kernels/ops/diffusion/fused_ln_modulate.py": "10de436aac55149942babcf0b59ebe53180c59ac0137abd6be6faa587c75dd1d", + "python/sglang/kernels/ops/diffusion/group_norm_silu.py": "1f5d6318c41d3821f915fe4790c0f7935977636b5d32d6a96d2d55afa4836498", + "python/sglang/kernels/ops/diffusion/hunyuan_qknorm.py": "d6023352ebd69bceb57330e2406c72d0a2329b7c57788473c7145eb98604851b", + "python/sglang/kernels/ops/diffusion/ltx2_qknorm_split_rope.py": "d4f8fd1d3f8d810525268ec0a678619ae7d8b13498a3838e7541b82f574cf6d3", + "python/sglang/kernels/ops/diffusion/ltx2_rmsnorm_modulate.py": "98e170af81879494ae17ccc4f356be5d04d9f0adace0715c597e0a651478f41e", + "python/sglang/kernels/ops/diffusion/modulate_scale_shift.py": "59a5b7512980429ea2b08d8479ea4cfd94f81709bade49e3d83cef319846e8b5", + "python/sglang/kernels/ops/diffusion/norm_scale_shift_native.py": "fe63af2ceece6a0960c21536b964e5cb0d8fc497e3c171f130235e278356fb40", + "python/sglang/kernels/ops/diffusion/qknorm_rope.py": "53700c9b76253b84e043ef52c35c1b65ba05b68dce3f84740c6e4bcd3f2591e5", + "python/sglang/kernels/ops/diffusion/quality_gate.py": "b83cda11bd2083dd5bea7cb09c79dfee11697832f23125faf243d0438482b975", + "python/sglang/kernels/ops/diffusion/render/__init__.py": "c7c1501d0385ccb9e500061b6e087ac3965367ce82751d9f6c5d94026135f54c", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/__init__.py": "f24c32c50fbcc6e324689f74d629929d95b76ce64b5901be23bcf7bf8d7fec26", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/rasterizer.cpp": "618007e9eabca702f43ff0f7499dfec9fe8d93129f6d90deb2a20299e51e07da", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/rasterizer.h": "0129c0d8d7d5f35ccc4f6e5c3a1a6e68878725ddba380085cb0610969b446e94", + "python/sglang/kernels/ops/diffusion/render/hunyuan3d_rasterizer/rasterizer_gpu.cu": "23139f3ce94197170e068f696de9dc50ad1a64b5cfd87c066f3d208ad191a4c0", + "python/sglang/kernels/ops/diffusion/render/mesh_processor/__init__.py": "3af13541c7aeef8f92bba2e7276bdaf5824308008c0f22232389cc5a438e4141", + "python/sglang/kernels/ops/diffusion/render/mesh_processor/mesh_processor.cpp": "5a222e19c4707394cfb868f5722f7b806e5100b0e5c9d364ff7397bada00e610", + "python/sglang/kernels/ops/diffusion/residual_gate_add.py": "7a461f604c9939204fe825936017a71faa10395edd150890920f234b7158d230", + "python/sglang/kernels/ops/diffusion/sparse_linear_attn_kernels.py": "c92e69aabe9cf122f25213951768d2bb67199e5d401a787271840ec7ba6166d7", + "python/sglang/kernels/ops/diffusion/timestep_embedding.py": "f4d1128cb425bf1de9327309e121bfe0605afc9f4d869ed2345f802450df1dec", + "python/sglang/kernels/ops/diffusion/triton/causal_conv3d_pad.py": "f2f0bdd7571ab72a0891d596f09b3d2eae211e4bb83654deeb8db5e7be004d50", + "python/sglang/kernels/ops/diffusion/triton/group_norm_silu.py": "03a0e073cdf7a8ea5111393f952af511dc98849c2545d40da829d11e928fbc1b", + "python/sglang/kernels/ops/diffusion/triton/group_norm_silu_twopass.py": "edfafcb3c51bc47606ef41f8c2eb247f29d52986b421847785a12055da742d13", + "python/sglang/kernels/ops/diffusion/triton/hunyuan_qkv_pack.py": "d12d307ed3c0365f1e36e3e1ce8b59a0618522a834e576dbcc618e19105e4408", + "python/sglang/kernels/ops/diffusion/triton/indexed_modulation.py": "a9771bb71b6a34ac9f28f55b616684d209e68c0165d70cb50f788b470dbebef4", + "python/sglang/kernels/ops/diffusion/triton/layernorm_modulate.py": "d82e26b94ee83bdbe76ce50dffed8e7ff33361891002f97588c8aea91bdc44a8", + "python/sglang/kernels/ops/diffusion/triton/ltx2_ada_values.py": "9817d7593a60e9eb959f8b80673dbf00260250a3bfc53131e00f8b11290b6bf9", + "python/sglang/kernels/ops/diffusion/triton/ltx2_rotary.py": "16feb7045fa6a5be7ae42191da396d97d075b1ccff7692049f4dfe205bc8efb1", + "python/sglang/kernels/ops/diffusion/triton/mps_fallback.py": "1a24599b415bbb1b8cc0c4be7e650741a0f9b0a34e83b26b8c632463cd429c46", + "python/sglang/kernels/ops/diffusion/triton/native_bf16_rmsnorm.py": "e5f32428b41f771f63e81c1bd0118520d8102069a0564be99937aaa92a75c802", + "python/sglang/kernels/ops/diffusion/triton/norm.py": "aae6388237a26b33f5ab63dc9795a654edabd984f3814a00b2fe695ea3e0741e", + "python/sglang/kernels/ops/diffusion/triton/npu_fallback.py": "daa3d71a16a20024d88b2ddc509e0dcd305e8acef994e251b0c446bd0c7ee478", + "python/sglang/kernels/ops/diffusion/triton/numerics.py": "bb2a5e18c36f92107382a3e8fd23d345bd4b6df879a34721ba79b2c0fc47b6e7", + "python/sglang/kernels/ops/diffusion/triton/rmsnorm_onepass.py": "e1f80c95a8e707135e58e1f8f8ed95006b49e25630b80bec7804e35abde0af34", + "python/sglang/kernels/ops/diffusion/triton/rmsnorm_scale_shift_bitexact.py": "4cbecffe13479ed25803e95ac390a7c2b0263753cbb53d8886647793eb0542bb", + "python/sglang/kernels/ops/diffusion/triton/rope_rotate_half_bitexact.py": "ab4924019695c20bab2b2808370a83e0c3ed7934fda92b2cfdd11095661e9598", + "python/sglang/kernels/ops/diffusion/triton/rotary.py": "b1d04f149681103315e79c5447fdad36f49b9989cd603015fdd6d8e7b4972587", + "python/sglang/kernels/ops/diffusion/triton/sana_conv_post.py": "df2a5d8a8e6b0efa5aae8f58c6fab1ce7983be12cacd6cec1307b5bfc29195e5", + "python/sglang/kernels/ops/diffusion/triton/sana_wm_gdn.py": "614e1b1bc48600791883d3ed7b7e2db1044768d2495fd41079b7ddb11882c33a", + "python/sglang/kernels/ops/diffusion/triton/sana_wm_gdn_chunkwise.py": "6222295886ad7f4162e47e5b6940f3d2167b8be3e716b45fc7a85fc792680dea", + "python/sglang/kernels/ops/diffusion/triton/scale_shift.py": "21fd89999067c57b28c6f912cc2875e220572c850403a38f74ef6110e870059a", + "python/sglang/kernels/ops/diffusion/triton/silu_mul_bitexact.py": "a5da4c5e6e1c0b75f88047a2ea823c9ac1ad33659691994ac84e1bfd696e8e10", + "python/sglang/kernels/ops/diffusion/triton/torch_fallback.py": "6b2a61c91709aca46f0bb8e9634947c3c623ab9cfe53c609c4f0ad14c85b6101", + "python/sglang/kernels/ops/diffusion/triton/ulysses_qkv.py": "96e589548c530d2de091f07a4497f52efe09edb7029c5b0dc413e12da8ca8c4e", + "python/sglang/kernels/ops/diffusion/triton/varlen_pack_pad.py": "23077c268664919b1bb08b8c863e54a98e4d8ddaa9ec66cc936920942c35a62a", + "python/sglang/kernels/ops/diffusion/triton/wan_causal_cache.py": "0cf15e3897a74e9ce6351f469c2b39b4763c7e569731ab2b108dd3c03b5be959", + "python/sglang/kernels/ops/diffusion/triton/wan_rmsnorm_silu.py": "e16e33f202e7b88bdc0a2507c0b04b6d3095df46cd2c24b5a1816a66a1a11abf", + "python/sglang/kernels/ops/diffusion/triton/wan_temb_table_slices.py": "5c77ad9c0fa0b62589b2e49706d2c27d61df933d57e46d8e0de7b5cd019aceff", + "python/sglang/kernels/ops/diffusion/triton/zimage_native_norm.py": "957e568f47910de4efa9d9a848ad51ac4ea94e6203bfc347086f84a25d189caf", + "python/sglang/kernels/ops/diffusion/usp_relayout.py": "4cf547bbf6c3b08e2606f01add0af522f1b2c90ea40dc489617fb58f7c86a893", + "python/sglang/kernels/ops/elementwise/__init__.py": "c56d53ff6b763fb7f8eb9729b04ba8d4bd69fd62551d57c77af60a9f5b7d0db9", + "python/sglang/kernels/ops/elementwise/add3.py": "48f3d6656705e38ae685bba0b5a873db8357108e299a9f854289ff935456e587", + "python/sglang/kernels/ops/elementwise/add_constant.py": "9a6ead19ee80eee6d8323b8342737a160620c6a39164ddacee686d4c243e3d48", + "python/sglang/kernels/ops/elementwise/elementwise.py": "2592f87a688dc86f217e5e35bc88ba4c49639d5e3b52b3a4132126329f079ced", + "python/sglang/kernels/ops/elementwise/fast_topk.py": "77780478c7b48517fbe9240d62d8a71371203a1acea42d27d44022cc1e9863be", + "python/sglang/kernels/ops/elementwise/hc_combine.py": "13b7ac26cfd039495592199b2479669621503695d9f30232d1b9ec7f2f9772fc", + "python/sglang/kernels/ops/elementwise/hc_mix.py": "363c5371c5c940d802f09c8f72565174cf7cc979f638dc7657def71316d16e3a", + "python/sglang/kernels/ops/embeddings/__init__.py": "342660f1c240300f60785a0eba6927dc834c56c40e44ffa8b96103e76e5bfafb", + "python/sglang/kernels/ops/embeddings/vocab_parallel_embedding.py": "7766e50514e621317fec277fd5975adc469d70ab2951722a99d56afbb6dc16d4", + "python/sglang/kernels/ops/gemm/__init__.py": "4235aa78f78a59493159c0121f7609c91d8293b4729824a40a95c350223940bb", + "python/sglang/kernels/ops/gemm/chunked_embedding_lora_a.py": "1189c7f90730dbf62f0cbcbac07a4ff858a1871a2ab9181aa5d73ddf2da8403e", + "python/sglang/kernels/ops/gemm/chunked_sgmv_expand.py": "ec3927c0c0319fd030734b5cfc480ebfbded87e1508fcefc6fe1221a8988948c", + "python/sglang/kernels/ops/gemm/chunked_sgmv_shrink.py": "f078bcb16ad462933c6d4805f6f0656ec2ec3811198ab8ee5aa9bfe00c166595", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_expand,K=1024,R=64,S=1,device=NVIDIA_H200.json": "4dafa32ab78835e78d67e9a92f0fa788a32e28ea7c3d2bd4e70771d813bdf50c", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_expand,K=4096,R=64,S=3,device=NVIDIA_H200.json": "1656bcc75507725947af06940bd290b0fe5cee1dfee288ef4cf5a35202d85dd1", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_expand,K=6144,R=64,S=2,device=NVIDIA_H200.json": "b5dae0b58af37bec41a5d2a61ac9f0a7ad6f965b2096eefca9023c9b3e103627", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=1024,R=64,S=2,device=NVIDIA_H200.json": "637806800dbf01eba94f67067db60c9179b8016909a36d63bd4e43eb09ec356e", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=1024,R=64,S=3,device=NVIDIA_H200.json": "2d701fd6dd639b389826903177910ac727561da3e4e742d2c8eadabe6aad641c", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=2048,R=64,S=1,device=NVIDIA_H200.json": "c04d42f40c70acb8383f430226c88abb9af7d57ade0ab0304c313588a8e0b547", + "python/sglang/kernels/ops/gemm/csgmv_configs/triton_3_5_1/lora_shrink,K=3072,R=64,S=1,device=NVIDIA_H200.json": "72fc03f2163375f242dfd5e6a8eb2f9c5630b8fd0b1ffa46ccfa16f98ef52e9e", + "python/sglang/kernels/ops/gemm/cutedsl_bf16_gemm.py": "6217583a506217f5d001f4aac125ba9253c1a65ebb6f378ce98442c0d70e55e8", + "python/sglang/kernels/ops/gemm/cutedsl_dsv3_fused_a_gemm.py": "20a48ac344d9c82198052cdaca386c504fee6bbfbe19260b42a6d3df1f14195f", + "python/sglang/kernels/ops/gemm/dsv3_fused_a_gemm.py": "7eebd0e7c5c2fc3ec5afc283012c94990f7d8995c923ff3037e3dc0c79047807", + "python/sglang/kernels/ops/gemm/dsv3_router_gemm.py": "70a421bfd27b85680373a742e49829d3dfb392f736f609ca42b9eca982082c40", + "python/sglang/kernels/ops/gemm/embedding_lora_a.py": "44a704ebb8e084326d634e1f5697bb49c6bbd3a825790849da7f4c6c28537557", + "python/sglang/kernels/ops/gemm/flashinfer_pr4266_dense_bf16_gemm_sm100_splitk.py": "ff7fc374b440218d3261c94c54be04efdd7fa549780746ac0954cb88986dbaf4", + "python/sglang/kernels/ops/gemm/fp8_blockwise_gemm.py": "86026c90a00063193fc848cff90067b3976c32255e023d6cb52ca3c3afc60b6f", + "python/sglang/kernels/ops/gemm/fused_a_gemm.py": "a7e41c536e4ad55ab04a4456a6a52bcf201707c77e51c320de245d28e361e55c", + "python/sglang/kernels/ops/gemm/gate_up_lora_b.py": "a1444cf7b161e5ce7801453ab719006e0f59d9876d293f8e97a3e8474586587e", + "python/sglang/kernels/ops/gemm/kernel_utils.py": "cdafe7d0763c7baeeabf141bbe9d38ee75ea3631dc157d9263097bf37c1db6f4", + "python/sglang/kernels/ops/gemm/kv_b_lora_absorbed.py": "59f8ea4af698f4ac2b47abb986f166f4d4930adf80cc72e630204d5b66c8543c", + "python/sglang/kernels/ops/gemm/lora_tuning_config.py": "aed0be9961f803cc6d4956e0e5abb0bdda960e859477e85007c925f24a1a7ddb", + "python/sglang/kernels/ops/gemm/qkv_lora_b.py": "57457ce0c29538c60e95f8c8a212e07726ade389460baafdcb1b6d230eb719aa", + "python/sglang/kernels/ops/gemm/sgemm_lora_a.py": "5d175ae4e9671085f24e298ed7ed3042e829bd2079eb8221fa3d3e2c0c04ecf0", + "python/sglang/kernels/ops/gemm/sgemm_lora_b.py": "266579cda8289e8c87c5411cf69a8fd7276e32b2b255328484a995e2d64b04fe", + "python/sglang/kernels/ops/gemm/sm120_online_fp8.py": "949793d24c9e166f46f173279e96541698153cb5d4765ed0e29d60d87e04df31", + "python/sglang/kernels/ops/gemm/tiny_gemm.py": "f975b4092e23ea26cdb62b07e3db41c68caeb293969ed90643a7b05da9ef65a6", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/__init__.py": "46a41f87b80b661d990f84ce9925f265ae3d833b378aa496822df31392bf5721", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/gate_up_lora_b.py": "a8d57f36f29d36284a2e0a9a045e36fb369e9a68681359254e6b58994c602c2f", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/kernel_utils.py": "14eab93e5bc85eeda76d679e422e95d48ad3fb3b7b86bdca728b83887e1aa829", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/kv_b_lora_absorbed.py": "d2e100d3af9711fe9fc9f8312e9990898397fcffcc55b8da8c4bbe2234d13b84", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/qkv_lora_b.py": "85a494048308de003890526ffcad00c4d6df6f3ce67a059147d7cca750a3a1f8", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/sgemm_lora_a.py": "db88315cd2db0b991273c00f9388953f0123df355faa7462f749bcd20fcadf03", + "python/sglang/kernels/ops/gemm/trtllm_lora_temp/sgemm_lora_b.py": "8a6453a9f32c23ba46b7800868b6b7392e23f50c5f367fc66f33963ba7624b5d", + "python/sglang/kernels/ops/grammar/__init__.py": "650612778d49fc2fc68e5641dab243c22ae5f73117f9d363e1477ed77847fc6d", + "python/sglang/kernels/ops/grammar/bitmask_ops.py": "5a34de9fd8aeb8558bce41359801d0641f7feda232e501fc5a37fe941f856a6b", + "python/sglang/kernels/ops/grammar/token_filter_ops.py": "7f78601f2f6143dfbc8e29c5aa4daf63e7d4002bef1c7e8b774cf7683d3f3fee", + "python/sglang/kernels/ops/kimi_k3/__init__.py": "d05bc02c371ab2ed217af119bc40cee853f7ef8cfa5204bd50d027f9dff86830", + "python/sglang/kernels/ops/kimi_k3/activation.py": "af6f58799eb172d39a350ad23440621915dd76dad5479339fbcfd550e3710cd6", + "python/sglang/kernels/ops/kimi_k3/all_reduce.py": "6e1d0eaeb4e8bf29f887c84140bde18691dd9cf38d89b1c4f409d18c757ca348", + "python/sglang/kernels/ops/kimi_k3/attn_res.py": "c851a9d2d3c3da409cc2ef535a9f94eb03bf8b4d4a47154c623b2444006354a4", + "python/sglang/kernels/ops/kimi_k3/attn_res_hip.py": "95ebe877ec7176f869e5d19997c92b0c57079b32430da8e264ea13809aacc51b", + "python/sglang/kernels/ops/kimi_k3/configs/sp_collective/world=4,H=7168,device_name=NVIDIA_GB300.json": "64fbfeb5b29e1eb1870692b6fbe7e74a1706c12742c4cfc69567a27607aab8f3", + "python/sglang/kernels/ops/kimi_k3/configs/sp_collective/world=8,H=7168,device_name=NVIDIA_GB300.json": "219b532137b089b3ec9693fb3c199034b7bc44d1a6a97a9b5c395bc5967a9b10", + "python/sglang/kernels/ops/kimi_k3/gemm_ag.py": "db348314282a1c38cf81149db702fd2e162bb2634c1cf2edf3159391b95b0a64", + "python/sglang/kernels/ops/kimi_k3/gemm_ar.py": "dbd6b822687a4dff30511202a3ad08853093cabbe4f1086b9340d9c5f9721ad9", + "python/sglang/kernels/ops/kimi_k3/kda_decode_mtp.py": "2a6c135ad98b823243d8492b81105df07f3c72db908c873fb0bbf25171664adb", + "python/sglang/kernels/ops/kimi_k3/mla_output_gate.py": "155c434b7b5001e9f4778b0d6bc2dc7ad2cb760b93e050ca2241a91ded5f78c5", + "python/sglang/kernels/ops/kimi_k3/moe.py": "ba62b68696260912ff1c7eceeb4f255f61411b72bc9071331934345b954164ef", + "python/sglang/kernels/ops/kimi_k3/sp_collective.py": "ef40307391fc97b15a39a93fa2ac15682b291e354c6fc5bc5a55efc193abd48c", + "python/sglang/kernels/ops/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/ops/kv_canary/consts.py": "6bbef700edfed32676d101c4e29f45ca6d7c9327019d8f3b0d01be4e83d3a83f", + "python/sglang/kernels/ops/kv_canary/plan/__init__.py": "f89a48c8cf947b6f98762eee9f338ee20cd8dfd1483c51e27f1c688d05eb5907", + "python/sglang/kernels/ops/kv_canary/plan/api.py": "8906795df412ba2b346593bc4825a40442bd3c1d8894a8c6f20a724af4cedb64", + "python/sglang/kernels/ops/kv_canary/plan/entries_kernel.py": "8971648dd987b7033e5fa111e9c6e3099afb2784a814fb0a675756c83b6ed222", + "python/sglang/kernels/ops/kv_canary/plan/offsets_kernel.py": "b2de9670740afb283edc8b6c33c8e77698a6d4f255fde30469b68d94dff7c800", + "python/sglang/kernels/ops/kv_canary/plan/utils.py": "d4f55a6637cf5d75ee6b32d0a26b7a60fff8d69d38b26f40653c45d7243fb11e", + "python/sglang/kernels/ops/kv_canary/plan_ref.py": "b2a3670f1f882a42f7459006b7309dc902e8ef5644c9edd372cecc73f02f26cf", + "python/sglang/kernels/ops/kv_canary/scatter_req_token_ids.py": "c14ef46d47a3b3039da885d349448c8091f8760b95a00a0fdca136a0573d1e0b", + "python/sglang/kernels/ops/kv_canary/verify.py": "ec4e777b3c6147b3e077fce68747161484662f570eeff0a531fa2d525f3e7147", + "python/sglang/kernels/ops/kv_canary/verify_ref.py": "03f41f0419bdda26c76b8a8db53ec67ae023fc76ef04b9a90fea0e48c19b9047", + "python/sglang/kernels/ops/kv_canary/write.py": "6e3c8ad4ab1dfae483070cf966a244bf3bf86382d346ef63d2da4cee6df2d4ce", + "python/sglang/kernels/ops/kv_canary/write_ref.py": "39c31b22ea0e908842f557770cc25f1f98ba42ac8ba1a8f79bf349dd18df6e8e", + "python/sglang/kernels/ops/kvcache/__init__.py": "ff8b033d0695a90a804b80116e08e93535013a2af6d4e4cadbfe6ed0ecfd921e", + "python/sglang/kernels/ops/kvcache/aiter_unified_attention.py": "4b295eeb1d77a7e40b3aae690ebdbfbe46258c90525317994a2b6f3164243a8b", + "python/sglang/kernels/ops/kvcache/cache_move.py": "eabca144a116c58141342d6dc6471e8244216776a3b1692aae6abc9e73d7b75a", + "python/sglang/kernels/ops/kvcache/cache_ops.py": "8965e5242a80e12cca326272a67ecb38eb36f2e6d3ad41dda22035861e59458a", + "python/sglang/kernels/ops/kvcache/fused_fp8_qkv_kv_cache.py": "88755d730cec527a7135aabff1c57779d11752ea7b286343c47c285a0be39fa3", + "python/sglang/kernels/ops/kvcache/hicache.py": "9b8e174c83d10743795f14ea5118abb4be86d895c8df238e7b163134883eee2f", + "python/sglang/kernels/ops/kvcache/hisparse.py": "f4b3958f0ed4c154fe39cc1fae217b2b80a7e1547c186d10105098af4ed5c566", + "python/sglang/kernels/ops/kvcache/kv_indices.py": "9d676688776c6c30883feba9f87a470ae364ff04e6cc1d51e5b2e7d2d45b6303", + "python/sglang/kernels/ops/kvcache/kvcache.py": "9a2101696be86275ea15725e11f8fe3ac55d560876ba66d81740236a916e47b6", + "python/sglang/kernels/ops/kvcache/minimax_store_kv_index.py": "dc8cf08f18f287f3a01c4071eed01d0186f38a4b7cd0657fb25c78922b20dbe5", + "python/sglang/kernels/ops/kvcache/mla_buffer.py": "3726d1c298e50cfcc3704573ffc001ac9343294480d331552e22f907bcf546de", + "python/sglang/kernels/ops/kvcache/rope_cache.py": "3aa237838d71d235a6df3ea41a91921d0450ef8fdf207cc340da03a8bd577f6d", + "python/sglang/kernels/ops/kvcache/set_mla_kv_buffer.py": "0cd007ea7fc26c2e3c84c0fdfe4caaf65b8b71d2b1b3d5775bc4d7d1b49bc2ce", + "python/sglang/kernels/ops/kvcache/triton_store_cache.py": "6c4b892865a0c198e9b980d03a8e7b75803cbc0b0a565ec0f1e3533bc8db6584", + "python/sglang/kernels/ops/kvcache/trtllm_mha_graph_metadata.py": "f58a0217a26dca700d1a91d73fdc069643b1870f6312c1a7745b0fb2dd81fecb", + "python/sglang/kernels/ops/kvcache/trtllm_mha_page_table.py": "1f47077656f99720d37aead72242ec7ac8dfcc1bd2c331c95118a3a9f6c7bd6a", + "python/sglang/kernels/ops/kvcache/zero_pages.py": "765e5ae8b8fae7ac7ea9c2c3a4e361cbd35e07d052adcc60f98da1e2a788a5fb", + "python/sglang/kernels/ops/layernorm/__init__.py": "50106dfbcc81884ec1ea9dc3b7522423d196d731fd051f7992347ed260889967", + "python/sglang/kernels/ops/layernorm/fused_eh_norm.py": "662a38cdbfde51eeed8ff07af486affa467b93a2f051eba1cb7f7b9f7b468281", + "python/sglang/kernels/ops/layernorm/gemma4_fused_ops.py": "f9d8c7c3ea71afc1341c2de02807b8fda94e418248bd9ee404b15b3337463ad3", + "python/sglang/kernels/ops/layernorm/grouped_gemma_rmsnorm.py": "ddda52c6d0bbceb817e83815a8e89c54b408a1b5bc238df7df81e2b974dfddc9", + "python/sglang/kernels/ops/layernorm/mhc.py": "d1bf39ee70af251ae539de44fd56671f95d76bcdbb02f816d5f3f25ec55634e3", + "python/sglang/kernels/ops/layernorm/mhc_head.py": "a82d40c36a0c9b40285116cf1701f5e449b895eb48f18b00ab6600ef53537826", + "python/sglang/kernels/ops/layernorm/minimax_m3_rmsnorm.py": "e7e81662d1989eacd46b757b0240111ef9caae31a77fb3035ca2b9196307198d", + "python/sglang/kernels/ops/layernorm/norm.py": "6105bf76253528190cae48c77f2d62315debf3c201950337ab7ae2273a3a7d17", + "python/sglang/kernels/ops/layernorm/rmsnorm_hf.py": "9933deb3f66af9e04c125727819d47b392cd804f509d04bd23484301efac6d87", + "python/sglang/kernels/ops/lplb/__init__.py": "cc59c1c96943b4860375c4d45b2bdfd668f653613cccc1dca62e4cf38766b1d7", + "python/sglang/kernels/ops/lplb/cublasdx_solver.py": "936110bc5799cc43ac1e50c65e03a8099bdf057a24b75c506b42e1aaaf79ad64", + "python/sglang/kernels/ops/lplb/cuda_solver.py": "cada08e6b9c6e421adbad7b37857d97dcc40d0fc96074d74c52bab2a889fac79", + "python/sglang/kernels/ops/lplb/shmem_budget.py": "360bd9171b75299b4f5563d6fd2d1ca2b5f7012df68add0a93a575432a95449d", + "python/sglang/kernels/ops/lplb/torch_solver.py": "f8c4501c5fc51795b9ccf374cc9c803f314d6b9092be8c4634bb45dde30558b5", + "python/sglang/kernels/ops/mamba/__init__.py": "97bc4578cddcf40ce2badad85079f2446b3240281195dd2a8960606ba3518bac", + "python/sglang/kernels/ops/mamba/causal_conv1d_triton.py": "5fb01e6aafe9b9ddf1fc3adac49c2a09c8aec310de234e2b0d8d4f75f587bfe2", + "python/sglang/kernels/ops/mamba/inkling_sconv.py": "fdf8b125ad55e8964ae7cef273880aa08953ff51f8aa146c243fb68285ba9517", + "python/sglang/kernels/ops/mamba/mamba_state_indices_triton.py": "75f8ced02daa10b77a284e5cf8cf176ea417259ea09ae4dad51dd4c0c0d6c6b3", + "python/sglang/kernels/ops/mamba/mamba_state_scatter_triton.py": "67681aefc281375e96ea48fd471b14a9b1594c6496d53c3bce3e5cc026537abc", + "python/sglang/kernels/ops/mamba/transfer_mamba.py": "07a7649666ea0651b549a071172dc324b8bf97d1ea6cad23ff2ccf621cc63757", + "python/sglang/kernels/ops/mamba/triton_ops/__init__.py": "01af68cc89077d4152b2684f4553f53e5ed3e5767841fcb5c13265e76a416b34", + "python/sglang/kernels/ops/mamba/triton_ops/mamba_ssm.py": "fe453aa738428802bc7ca4dbf5afa653787bfb646434b73ef91376c028adf7f3", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_bmm.py": "27afe193a8f5ea7f51258cabfbd67200929be9526da8cd73a189c1ceb3dea37d", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_chunk_scan.py": "9fbd0140cf03a60effb215fcedacb742f04450ee1f11c9a0d4ea2953cf0a3e21", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_chunk_state.py": "dc2fed284d4fba3328b45e531a21ce61e94bc5895470acaa9a5ceb1a0fed1d24", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_combined.py": "0f98cd2e9a9d6f743d7d334ccd89b18f2336dbbaa5665bdbe4cd4d08024d9648", + "python/sglang/kernels/ops/mamba/triton_ops/ssd_state_passing.py": "cf0460418fabf6035e0af6f3ebffa63d25d0805e135151f5ac378a27f1bbb7d6", + "python/sglang/kernels/ops/mamba/triton_ops/ssu_dispatch.py": "a6125c8c4268d7aeafb67b983cae4f0d3cd0cfc3109613504cf4075b2e888e11", + "python/sglang/kernels/ops/memory/__init__.py": "eb0efdf461a1c718a18c3d85872f15402d6e8d4762fdb624d6d0c2a02e99afcc", + "python/sglang/kernels/ops/memory/allocator.py": "ea84e0af085cf6821e6c4568516764da706aa9efd997f8d7a8dbaba8d97461a3", + "python/sglang/kernels/ops/memory/common.py": "a2377e0d262b8a527475477a7e76a3dd137ff8cd589f9af0067f5c23378a6aa3", + "python/sglang/kernels/ops/memory/gpu_tensor_hash.py": "0401f647b849a0f763e55f9f917dec78678f5a735aabb401e64801e49123a38f", + "python/sglang/kernels/ops/memory/memcpy_triton.py": "a81f299bb4186f9cae247cb3f5c97c8554e9ec7f248aa34266156964ca8a939f", + "python/sglang/kernels/ops/memory/virtual_slot.py": "3e11bc67d4169134a9b8c3984749baf89b5971d827bcb0a87cbb3ccfb01fab48", + "python/sglang/kernels/ops/mm/__init__.py": "8b8c0d9e89ad6a28d359ef75769e6496ed7812b6aef71031dad6e4a53eacc829", + "python/sglang/kernels/ops/mm/process/__init__.py": "2cd3d5d1285cd203e6c10bdd5efd5d32c79d6f64d4c1627c65ff519df2fde96c", + "python/sglang/kernels/ops/mm/process/image.py": "79870c590b700056cafff51814d892bc090a0d3dc73fffaea5ecfae266a1ae33", + "python/sglang/kernels/ops/moe/__init__.py": "907720e21482bba929cad791045c785d9885e1db1acd5bea3dfd5c15c2a4ea0a", + "python/sglang/kernels/ops/moe/configs/moe_front/epilogue,E=896,topk=16,device_name=NVIDIA_GB300.json": "f6140a7d1cf3b8f75c53cc41e7d4aaf4c8fe10b34189119ed4293d9419a56966", + "python/sglang/kernels/ops/moe/configs/moe_front/strategy,E=896,topk=16,device_name=NVIDIA_GB300.json": "c333815256dbe18a9043b16c66704498b00d392e1e6bdbade3b647180cd20af0", + "python/sglang/kernels/ops/moe/deepep_waterfill_kernels.py": "ff5685f930c3a630e3f72551d3b810d773c2f35bca5482104d77622d9dea443d", + "python/sglang/kernels/ops/moe/ep_moe_kernels.py": "e685835c09cf82a5d15481345cc8163f083bdf391e94f58d8398b073b77f62c5", + "python/sglang/kernels/ops/moe/fill_padded_rows.py": "18439c7bf44073acc136ff644052e9b9a0d76a2312108ff3d0a2203a251bc022", + "python/sglang/kernels/ops/moe/fused_moe_lora_kernel.py": "0042c5aabfee2bed6985a9e3796dbabe2426a9ec50fe9c5f23c7b48754e123b4", + "python/sglang/kernels/ops/moe/fused_moe_triton_kernels.py": "9c3342d3147e7d60a78a2c934111f0fc1becbb8df1d2d32aafc82e6c8a0b2e70", + "python/sglang/kernels/ops/moe/gate_topk.py": "9bbbe6a89810f6ea68a90dfed2dbf48da02dd1872eb51e2c9e5a9b5b5ebbe6b9", + "python/sglang/kernels/ops/moe/inkling_gate_topk_renorm.py": "b2da874fb42e04e5525e218db074cbb28fe42efaedf0488d49aa87150ac55c9c", + "python/sglang/kernels/ops/moe/inkling_moe.py": "0727ceccba5c74700ba47230f84cfbd937bd251018c505cda338bedcd162ac2b", + "python/sglang/kernels/ops/moe/minimax_m3_swiglu.py": "4e2cd1f047ffc5b5dd5fd20359e51dc31816d078adff5a8045260800231261ed", + "python/sglang/kernels/ops/moe/moe_align.py": "86877951a95cb96a4f92586bd3fc649493454dddb7521297ddd1560ecece3b17", + "python/sglang/kernels/ops/moe/moe_align_single_token.py": "5815a12c30b00719496db29860353900d27225803eba16d91a3c09eaabb30498", + "python/sglang/kernels/ops/moe/moe_align_small_numel.py": "ddeb1b65e6b86338c51077029fbd1e1a9c61b6fd625ef6fb272435c0b8608008", + "python/sglang/kernels/ops/moe/moe_finalize_fuse_shared.py": "6702f87cbbf57e73707313590368de95af3c6c2dd571facdaa6dfc73be0993e2", + "python/sglang/kernels/ops/moe/moe_front.py": "951be9046a5785294866d747c130fa2fa25aab945304cb49b48fa0e4b7209849", + "python/sglang/kernels/ops/moe/moe_fused_gate.py": "945eae03580d034420a20f2c38adf8d9ae8fed4a13de364d8c235466ffc513b0", + "python/sglang/kernels/ops/moe/moe_fused_mul_sum.py": "937d437f85e600b4566f9c436437139d27f5e0e65b76c4d407023468338e58e4", + "python/sglang/kernels/ops/moe/moe_lora_align.py": "0a0e28a7c7ce9c41fb6ed434b316e998b08e2af37d808dc32d68c5b841d24288", + "python/sglang/kernels/ops/moe/moe_permute_prepare.py": "53df1bcd7c072f23e44ebfa4cecd1a51d464793ea2b5a33d7236c563ca6ed46c", + "python/sglang/kernels/ops/moe/moe_route_quant_fused.py": "0c5965c027558dd464d9af83f7bb11bb05785309fa53292ec0a6000f978d19e8", + "python/sglang/kernels/ops/moe/moe_route_radix.py": "84a7b2e8977dbcca38b92fd56ecf8c72f4d6cb8dac484fd137ea96bad64682ed", + "python/sglang/kernels/ops/moe/moe_topk_sigmoid.py": "d4351193f9cf41e51086f50432c88eb9ee1a3e3ddf06c50be05fa2050398c52f", + "python/sglang/kernels/ops/moe/moe_topk_softmax.py": "e5403377267035a6a9914e8e35b80a59158d2091f83d458bc4198c70c7ae28a0", + "python/sglang/kernels/ops/moe/moe_topk_sum.py": "1847f8d4eb524e3b2e11969496f6bac485c1e275a5da58d3737002048c5c8e37", + "python/sglang/kernels/ops/moe/moe_wna16_marlin.py": "0f99349d7b7efd56f3a6fce990c6792246e83b1696a409798514ad5e0c309e6a", + "python/sglang/kernels/ops/moe/mxfp8_moe_amd_gfx95.py": "28e68a6a9e6d5db18515a670a3fa622a9ba2bfc11b489e3e6fdc81b8f3debff3", + "python/sglang/kernels/ops/moe/pack_topk_ids.py": "01114f7c2d013b2629fde0cf50fc4cb7e2ebfd09951f90b0bb496c61d2a7d3ed", + "python/sglang/kernels/ops/moe/rocm_moe_utils.py": "2ff5f8ccbe7e1454f6c9ca61dc5521211c07b32a765dde9ebe6e99a504047b75", + "python/sglang/kernels/ops/moe/router.py": "787fcfe75984ec59f5154fcc7cd0dadc37cdd4548545971a8533d2a7c63d86ed", + "python/sglang/kernels/ops/moe/sigmoid_gate_topk_renorm.py": "308766f6b682bf7938da86ba85bfb731067d5ce6191c866828cdde119afa3366", + "python/sglang/kernels/ops/moe/triton_hash_topk.py": "ad764744fb1b569717dc6f6d2952326dc41a8fc05637c9d2232627e5907fb17d", + "python/sglang/kernels/ops/moe/triton_sigmoid_gate_mul.py": "7c357dfb96efb31a52e1895477a97f96d17c11e618d35cc0cb04ba4d051a6d89", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/SOURCE.md": "14ab603836404013486041129d3483d6da61e1d708ddd0ebdfb0676a51c3cd92", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/__init__.py": "d5a67ad8c9c69f9099eb9a27aa92b15a7f0fe590019eaf094f1b5f138c053774", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/core.py": "70aa97a50971d8731d1e756f095fcfea76d9394447730ae092e8d5ca77015762", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/fused_activation_quant.cuh": "9cc9f7dc1cedfa7c79cfd0e0c35023efe860de11c3d99fd5868ee731f5f4b822", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/fused_moe/trtllm_backend/trtllm_fused_moe_dev_kernel.cu": "d364842bbe3efc86f1653ab5e9e7c03c3debb6829da31cc60b212ce591680636", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/fused_permute_quant.cuh": "d3d48ef13dd4966f7130e98dc53d12dff1c4dbb067768661fb77f2cc1c9299ec", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/trtllm_fused_moe_kernel_launcher.cu": "94e7367cd8be10b4c800764bf20bd420816d038d64477a90e603355967905c16", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/csrc/trtllm_fused_moe_runner.cu": "404b03aaada56bde468bf43001bb0b62422f617131840c34d3fbea438dc887db", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/include/flashinfer/trtllm/fused_moe/DevKernel.h": "7e8e91cae9a0730654e4f096ee35c2d770f345cc5795eadea67ee42daaa4c917", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/data/include/flashinfer/trtllm/fused_moe/runner.h": "3fc2f48d1acd13ba71cd7747d9415936a7155b4f92c67b62d7ba83bb513ef9b3", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/jit.py": "4993f260c64aeba3c46874fbc43ed0d28edac29a8932ab4a667e45f9fad7ad3d", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/kimi_k2_moe_fused_gate.py": "3a06d43b3c1291646e7c9f20650b9f07f51f05f7cd1896114bf2ebb760ca8dcc", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/moe_lora_merged_align.py": "b623e7d7f0c0d2c5f60c1296113115abfe64ee395a7d8a7151f86f79b17170a8", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/topk_pack.py": "9dc26c3134be47ea6af4078ca4e0e28d71056d7cc68704f960bb1733061669a3", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/topk_softmax_pack.py": "9960dbb95c50bb403180b4204b08fb82a0f21ffa6ef8051193ad7d18545d8d7f", + "python/sglang/kernels/ops/moe/trtllm_lora_temp/virtual_experts.py": "911f7e344ec3b19e198ceabc2d8eb3b7e4e7a22f3f6405bd05f5544ff9ec0b19", + "python/sglang/kernels/ops/moe/virtual_experts.py": "43ce29967827ab2b3603e6ec06651edc984cbd5f915ba3d83496855ded8a7fc9", + "python/sglang/kernels/ops/quantization/__init__.py": "26d3f9c70f1b68dc2b2820530a85412dccfd27a12d82c725094ea230f8b12e12", + "python/sglang/kernels/ops/quantization/awq_dequantize.py": "82c4c1396bcfb05b6d6f0f8de2ba6060c6b0dccf8aef8d5bb2a841365ae504e6", + "python/sglang/kernels/ops/quantization/awq_marlin_repack.py": "4d10f132f5ee312ce6d48926811851ea0630d3182a58c89e95e8da0dcf1e2ba1", + "python/sglang/kernels/ops/quantization/awq_triton.py": "d50c29c4fa2a71f7b7b0353cb91b372d705170366fabe33dc50ecd13d455d0c7", + "python/sglang/kernels/ops/quantization/configs/N=1280,K=5120,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "7e0ad2a82391ae0500492bed02e65a51d4c36e9dbb159cc17f265c7621528c95", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "45d1d0c565f05eabe2a37d75f76bec2da2a312be1ffc38e930f2a56ab6352009", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "d2f2da260a3907db62f97305289baf4a83068ec650f918474b1e1c0bc5e38be5", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "b642e3c0b0bf6955e1ceebe8fb64079288d765ab8f26c7f78cd1c59f54bbb910", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "08fa355911741e0b1030f064be9a0898495032b7f0a492e112f2fce9ee9f90f5", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=1536,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "f6a77287a922f4b032abb5433bd58c46604e3d6292ad9854f88ef3d44f5b4ca0", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6a24dca01603c27b88c3a647d5396097a6e34c5239acb1d0fca06869da25eff", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6a24dca01603c27b88c3a647d5396097a6e34c5239acb1d0fca06869da25eff", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "f726bd7f536dd20d110feeac45105939a20f2d2a521590b3ee336fa933eb8051", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "dc4f8b5da5b514fa138823c1bab9bb536495e0a9968b8c66ab07428c7bd99240", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "68ef3be22bd7a67afb5ab1540bb082378871c5cfc8cce4f0d9260dbfa2f4fb64", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "4288fdacb2d10db28ce08281097bcdf11731cd298d3ddd1341488cec25c3a872", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "5199639f1c424a3c276655f73a029664919709fe41585fda804a4d5fc2386717", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e03dcabb8cbb042544273b9e2af402fcabce474dbac3738d5acc5fb00fd8ac47", + "python/sglang/kernels/ops/quantization/configs/N=1536,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "e8f397cd064774dc1c043bf5c3a04929b2cc443b748db154b8cb0c35ff93a04b", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=4096,device_name=NVIDIA_L40,dtype=fp8_w8a8,block_shape=[128, 128].json": "2f46d4a0a76cee0bd0ce11cd379b18ce4f1ea99fae6c696a19008ed5b288d21d", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "d46d91b8a352f3c9a30fbe9985717047e2c184a6aa96dba9195250761b0ac09a", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "d035cbe8396572f76c17bae82d8a44e7fec99811237135a2170da21e3114511b", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "eefe2da7445a4f8bf1178bab481ae42b9151ff98a478543586d1770f00e5d659", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "de66ada02cc47b869ec70a1eed84e6923c84e0d03c9215978cbe44c92b8dc330", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d09d8c16068b92ffa67d5139c77eb796054a614ea688b1bfc513b7b495206bf3", + "python/sglang/kernels/ops/quantization/configs/N=2048,K=512,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "25e5cd2e46cc023743295f96a73432f3b497374eada30a37c54a1f2edbd80902", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "93cd6296dd75f799cfe2bd7ded6edc6689cf2797f667902d4b05198c6da730e1", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "fef928b83c0620fcb2762140d95c7c4bd30ae542c5506b374b0ac83da2e1c47f", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "e2e6db8704855ff5db79f44b1242e85b126471eb4558fcecb333eed17dff5abc", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "f5ff086f880b10549f74da4ef082fcba238d226bea9e53db26b6741ccdce07ea", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "161ca78864f1e50782b95ac14954d0caceaad393ebe653c470fca4a405fb232a", + "python/sglang/kernels/ops/quantization/configs/N=2304,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "0686bcdd948f6742efceab5f2c6be88ace502b84e625fc230369fde9cf444f9f", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=1536,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=1536,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=1536,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=4096,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "3d7ac07c8cdea58f76746a72b01b4b82f869a449cb891c54d8d942e2d21a571e", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "7e66f3a427748b25408eb9d49002e6abf464c2ecd5fd59daa656d2d4c8ff72c9", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "c18f0fb7cff9ece2c8bf210b92da8d7b41b5a79184c1551a719df111e6c69cb3", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d2fd7bbfbf291135efe92d99a226de9313958624e60a6f34ec3606e0338d51c9", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "238e0fbc98fbe7cfacc3f7c239544e2d3a46d0d439ff93c263241ca590b56126", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "b46e7f8957910474e01d7fa588e7fbf675918e3fe5519f8d4164db06b0603914", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "0c10b1991dbd41ff5fefc0cf719378b7f61baf8dd300b3594fa179bc03fee7a2", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f82547a829513a58bd1567bf167967b801b62e2162bc314afe78211fab7e0567", + "python/sglang/kernels/ops/quantization/configs/N=24576,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "f6d099c49d1e003ec060c1fb3aa4b7006a692549652a724b36f32aec531776c0", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b264f5620f1f54b03346a42e6c20b18ab589f4a2dbc04a82b7dbcffdda0fbffa", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "7537b53b75225d272c2d4499a381a28f843901eec894bdc34a730f8994d8d366", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "1ac2e8624699da9e10bb40a88fe5fdd2cec95b27d904e9682073e5c8d29221eb", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "0692b0798e077c1c79c6fa92bf035a872f71ed1e451fe60af23eab2c541d2b0a", + "python/sglang/kernels/ops/quantization/configs/N=256,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "40c55f3174b46238286fcffdc69b35c6e662e8a9d8e65d8c78ac572d18d37a0e", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "23a6b9c10d11ddc069f22c7f3c36a6599376689995ff5a74b60e37d0bdd4a5d8", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "6d2c536a9b5d7208f6ee640699d52642d6139f857ff04726b5169536280a8cb0", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f33b8984575de9a5d11298aa3c58482841560399602d51ab1b4f9af545dc06a9", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "8a75d7abaf113f9e347e02c2e472378163397d166fb8243fd4cde759d559074e", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=1536,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "667d53be10283cebf4cd00581ce661c1d0f0de8ab2c66d3321aec82644c21e9a", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "caa8ceef330bec4b1e049c3a067e4c4f21de022b643ec97576775778be919fa0", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "fa740884a00e54242bc4b57a1c395c0f457c1cc5afaabbfebf288e45553baa5b", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "261b38a1dc76e5f817c974a69ef6e63595b2a6ff7da2e85d04324a0f776b541a", + "python/sglang/kernels/ops/quantization/configs/N=3072,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3379f0a59776fb4c36eb7cb066df606b0e77cfb30debbdd3e6d978b5ce3736d9", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "ecf69ac0312680218e2a77f997ca15a02116c7d97a00f9f6e67759f18aed6abe", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "ba92c3c86b2b89abed5be0b4b9367602172d5540f3c6fff95d5e2bc08c9cb5e7", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "bcba15dc932dbc738aa51e43d4178240f32e625594025ad7bb9e20072364c0a6", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "32dc3b6bd052b298f64f30be68fc44f36a352c4bf0ce06d4b88a1fc11c54340d", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "074968dd2ba8417841127a231f64f0a557aeaef94a0fcc88f2442b2793918565", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "e55f381bf372105778a3c70be32df830f598ed4ab12f9e1c43eefdadac9cebce", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "347771ded6677cb17b36996cc0ccdc4d16d011014bb42860e2b77b194f6531b3", + "python/sglang/kernels/ops/quantization/configs/N=32768,K=512,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "658674df388f1b01b6b026ac1182e3ed920feef34ef14341479a8d4e62a044cb", + "python/sglang/kernels/ops/quantization/configs/N=36864,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "95a61e1f8c348993a3d98837bc382d2a8ae83509f00445f819418bacef74f792", + "python/sglang/kernels/ops/quantization/configs/N=36864,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4d670f0d9da6890303e8e5830b516d791b3cd0d0fd442fa824bdcf2d59896ed2", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=12288,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "452380d435c282ae8eef1269c65086c6d55b54aaa2ed41233daf541a575faa2a", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=4096,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "9bebe165ab5295f364809405b9501589d9d39e50bd12ab5ffd375a67300ff240", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e87becadaa46ccbc820197bf344d1575c253489bf56b3b43d59a851bb54e0d40", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "c7135f1ad1c09710d55fb3c19ea13124dd149d8940d146da6285d49ae5f426c2", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e99ee421ad7846356adde93f0b5e6ae6652ed48ad8dabd0e3fc4befe99be3185", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "afadd2664509255f3b074d21017d3be3fb9a0bbc3041776eae526c0758d40342", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "6d52657a30601e34563c36effb991b933d671e3a542fa54a72d8372c6d477152", + "python/sglang/kernels/ops/quantization/configs/N=4096,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "c4187174215fdf069352c2f1271039e11f74cce0db0bf0ca2375d70552a3291c", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "5c635b518c9e4676f93727e94dcd65b9e1e35bf8b8f4ef63f4c03e328adab1d2", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "5c635b518c9e4676f93727e94dcd65b9e1e35bf8b8f4ef63f4c03e328adab1d2", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "d7a424e01adb55039d47d12dd93dd29cba6141dbc4c2eb86dd6dd70a60056b7b", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3bf495dafa3fa1a0017d3e8cc6a726a35da99e12ad7d7e139d77ded3639c1c99", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "835d9792eadab7ba144bb2dd4bda472ca165babe3f15a30688606f76afa2042b", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "25ca5511359c6d7e2e3e668ececc0b2e5696a90b4e7ce90c4319e202a3196461", + "python/sglang/kernels/ops/quantization/configs/N=4608,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "b4576b6399c00e65d495285d37cc3c273931ba3fd13cb5c245c797f45850df91", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "600e0fde2590732bf1f70460bece733aa8f730a6f48b79434df5f7893cc98767", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "600e0fde2590732bf1f70460bece733aa8f730a6f48b79434df5f7893cc98767", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "9b413d4f07d98efb68a5816123dd9549aaa18946698c1bbaf64bf9eab28c12e4", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4cedaa4469a9dfbbf9dd9aaef09a1eabf0526edc0cfe6a55a28cc6ca8360d3ea", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "aee99424f346bad39bb2ee24ba71613daec1a207d18acb36a82ad07f5fe23a6e", + "python/sglang/kernels/ops/quantization/configs/N=512,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d31aae7f4d1f81fac3383a5ac72aded150dc8ea7f3a84c63f77f6bcde27ca4ca", + "python/sglang/kernels/ops/quantization/configs/N=5120,K=1024,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "5725fdd408d67cdd0ec970db897280e946e85d64bec8d045377b65f6ed470ec8", + "python/sglang/kernels/ops/quantization/configs/N=5120,K=2048,device_name=NVIDIA_L40,dtype=fp8_w8a8,block_shape=[128, 128].json": "7600f18a8ef9f95ec1806991d1646737e6ff43aeacefb62d9f648616b4c0456a", + "python/sglang/kernels/ops/quantization/configs/N=5120,K=3200,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "70fef34b838e2aa124a97bc30943d3fcd70649b2bf63d0861d99efc47fd83a6f", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6c14caeae1ac9b0a57c9ca19bbf1cd477f58dcc854869dfca0747629ece8524", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "c6c14caeae1ac9b0a57c9ca19bbf1cd477f58dcc854869dfca0747629ece8524", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "038bb35894cd87235587b9ed3af5294f44e179a115bbf8ecd0d08d75abfc993b", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "ba1d872d4351188a8dba555226b85a9af328fee1311c0f92da891077aac707c6", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "497093dbede595d24507348be2e93ad1484606bcd5db3337e00d919055e05c4b", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "a86eafde7dea17a2c4d837464fe98321779c6756bbbe0ee9dd0a97602317f399", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "1201531b25bf62e0f0c840d40a81a0972235113763f49ec047451f27cea33282", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "0692b0798e077c1c79c6fa92bf035a872f71ed1e451fe60af23eab2c541d2b0a", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "956f0260a2fc1561187e0a0008aeabc0b4cac40cad3bc7878103cd4476ec237c", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "362a2b2603a8b7191070fe3d203df3e5a975500e10403ad3f0cbdb0b00162f96", + "python/sglang/kernels/ops/quantization/configs/N=576,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "15cbb37262857f645b694a40680b2e39b51e7dc18c80d3cc0db55d1d7464a066", + "python/sglang/kernels/ops/quantization/configs/N=6144,K=4096,device_name=NVIDIA_L40S,dtype=fp8_w8a8_channelwise.json": "0303aa74a51f84f4322d9420573928d55b111eee725891949a9d249a3121277b", + "python/sglang/kernels/ops/quantization/configs/N=6400,K=5120,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "dc2594d10e4c2d7621d6aa529d3a7e6f6a61b3eac965977ce4a4a6bd3d55604c", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "60a3dbf72bee313072da69de971acdd1e61cb9f68c1f5660371effd2018444e2", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "6905658c4c740b3be0916433f2437cf6a9ba43e89024378aedd2ab728f68a052", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "6cf416b6f689af338e22023e47e308c6cfdfe320bf1686e40f276edce90e16d8", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "877da509316294b97229b31eb89bcd586d6fd32249ccd8fdde4c12be5ac77da6", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "651822b876764850babbe595e431b06aee24d5188f2c8ebb78434ed1efb96258", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1024,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "92343f92f177f1b64672669e246489b1247435c52350e8772d9dbee5ce243ef1", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "0ccf74f23ee224a2b478b0d1f11d9a066642ff398c8d67362d7c4b92d62da807", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b7e99ac5ab0afbc92fdf6fe025638af7b41f42bb24de25d6f3528609a2e6e473", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "fa13ff3fc34cd0ad38986cd39a91813626d0e71c61e603f3e56b68317868cf51", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "d235fecf6953815c3b0012e65ac22c41da96e048e66d72910c7c9efd73cb0801", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "141e4b7b8a1bbcfa028054a70bfdfe521e7d9fe32de11a25f2c69755c2b744fc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=1152,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "999194dfdb286ed52a3582a3b722068e1399c82390149305dcc8a7035ce34c90", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "5245f3c461955eeab7ca6a9a5dbd5012a9ea5dc5c137e985bd90d9a0a1c7e641", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b54bdb6e0975f1c81b6e64107b64adf8e7f8c248720bd41039682355306efdd4", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "90bbe21af56782980eb9e95f2adbeff48b3b31643cf6b1b196898c44feadd087", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "fdec4cdf027714c9861f0781707fbc231c1907368e98f685dd270c33a283a626", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=128,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "b9eda85a6976a2e51365e958c7936de69802998fa26f798b575ade24bf59b9d1", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "dadd659a7878167ebb612ab89da3f683f46a602d15b6c5604f0e464b5e00fffc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b326f4b4fc2b7585023a807b7d3117112d06689ea3cbf22a2378b5dfacee75be", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "be5cacd198bf09a694e3538719b59206d6d5825162f7c6e0a84c9204c73d49d8", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "616c81c8e94a4aaa7995b7146bc7aee8dd9d1d1289a890db0834a37434099e08", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "10d45661d530234a281dbe88c1c1e58aea5158e3e7c3eefe5adc5907ea901892", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "ee14d6b044935498c2f317c6a0b179a19a2b1299dc7eb0c687a9579cb6611488", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "8f93d35b4202e19db2408ca071d20268eb2f6fadfdbba32ff99a49624ac14369", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=16384,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "36ff4a3ff28b1ac44974917be7975906f6d3c2cdfbbb518cd948a0311940b65d", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "bf657018b62fad8cb735fafb0a23a4b23691f976f01eedb546c5d9dc9ebfc9f2", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "f6f4ed082b447fbca132c9e0f9910053f82f28c4ead38c1381eca45740609d3a", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "1a0cb885e8e47168e2c39062fb01b348fe492d5baf3a38a9feb6e35c504965bb", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "5f2e26819c798a212fbafdb274ee1d14d213f2cd2380184d1c4d6fbbdddf1893", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "4dd5ae136448b08cabe089b6e0cb962b75f288db5b84efe10220170f3e603549", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "9c3f8a8b75ae43e324b6f1476ac624f220b5b323d499f6e9b2871751e6bd05dc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "c78efa9c57a5b41ff688ef7feb2fb3d8ffee9c06e1ee084b3c58b9cf62ce4cea", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=18432,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "64e584a3ffe8532f008498809510ae18d01935d370785756045a6d258930c6cf", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "b156c7e1844b4f106abd387feb16ed5e48f7a2b3ab2b2b65c0cfbfe20b43e886", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "b13bda27446209a41e9b8175cfba044ba455449da02a006e71c5f5dd2d52a867", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e2e5a240c87771963f12d2c0d1adcf53c675542ba71763e9a254cf61e3fd463a", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "0f49a888aa92ef7a2b8a5df688d8f98112545a94f6499e637fe65eb1466736fe", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "afece7766553144f9bd639ce37dcf0b8142f4c1a2856e8f5aa37fb86f8c512df", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2048,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "377edd50bfc9d8956980b1659e5cfffc293b6789e344e9cd00ef15da8883aabf", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "cee4983b40de8ee1c92b476a4accd3c92a195058b3823b4b2174a38ce0bf9697", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "cee4983b40de8ee1c92b476a4accd3c92a195058b3823b4b2174a38ce0bf9697", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "46af9e30c2b575e509ce61d0387d04fe9c103fb97e654f840933fb5f07a06afc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "2ddb4ec97b00f6bd7c1a21649833a48918a7b03499059f0d61aa4be7d119e223", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "d3b19aac11e68a2624caa9feab112dac07200844ee51baa6e87aa56c7f72262f", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "655166100eb58627b2a79c40c8b4e4cdf94099672e36d5d88808e57c0c0cc7b8", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=2304,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "904baf0ac5b760d07217e0c02d8a8f6695b74cbf196ed43981436aefef18bd9e", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "6a8ab8efddb33e8f3b40eed5ac47fd7dbfef8f4ccf88722eec7a3d68c5f070bc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "6a8ab8efddb33e8f3b40eed5ac47fd7dbfef8f4ccf88722eec7a3d68c5f070bc", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "fd11ef15c6eda6c6412b166d7b6f84dd2507b4bd69c11b6ac21495e0131cc8aa", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3c3e002580a41dfcb68afbfd6da328b855f3053cb478a32e99b01fc5f9bdd472", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "148980f9327fb500e3ab0a0d5b14befac443a0a0d77fd81a9a5304ded9311f9f", + "python/sglang/kernels/ops/quantization/configs/N=7168,K=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "1450634969692973317c0514614a976ce2bf1ddeea05e06c7db71a6bdb81e2a6", + "python/sglang/kernels/ops/quantization/configs/README.md": "62717927306fbf720b6ad618eefa94a4657894711680f57d9ec82aeb3ced816d", + "python/sglang/kernels/ops/quantization/dsv32/__init__.py": "871331116c34886397cbea62e19403cbb8b428353f1efd93723773620bec1cb3", + "python/sglang/kernels/ops/quantization/dsv32/elementwise.py": "d421f877d20799ab5f00fadf550fa33a36fb02bfa62ebf8194700254222d6f8d", + "python/sglang/kernels/ops/quantization/fp8_kernel.py": "bf4d819c35f35e58be94085c081425284de4d1efd640ff4b000219e1bfef1169", + "python/sglang/kernels/ops/quantization/fp8_quantize.py": "7d47a3d63f815af25a31cac61da9e108d58933f7a07339695e8e6eee3bccd3ef", + "python/sglang/kernels/ops/quantization/fp8_utils.py": "98d78ce79860f027c0b5989de2aff153529e28258d53bb6f4f6e32f51b308549", + "python/sglang/kernels/ops/quantization/gptq_marlin.py": "e1be46383797db3fc4235bc18ac43d54e696ae1a6be2c6240921dbba6d2f9641", + "python/sglang/kernels/ops/quantization/gptq_marlin_repack.py": "c128316664f70a631d2a0a88a6d0ebc1e4ee435114425914bb69bb1c89f30ca7", + "python/sglang/kernels/ops/quantization/hadamard.py": "bf8a100d8e1d75b542aeb3ef74c109d3170b6a0ddfa4697976d05e7714460330", + "python/sglang/kernels/ops/quantization/int8_kernel.py": "601e0fd6668af8d12d6e192e653112fec890745cd5fd40521be6b38bf290d856", + "python/sglang/kernels/ops/quantization/minimax_quant_ue8m0.py": "2e21e5a4dedac4aac89813175d3b6ace8379c74d822603d4ad5bbe5b6ae52700", + "python/sglang/kernels/ops/quantization/mxfp8_amd_gfx95.py": "a80677e9863df4f7d9ad35dccdad414488d7eaa53e81c7b35fefc3f8cbd66baa", + "python/sglang/kernels/ops/quantization/mxfp8_interleave_sf.py": "69601b1e025f5b4efac2004ad73ea5a85ee424ad916d958553f0cf6cae116dbd", + "python/sglang/kernels/ops/quantization/mxfp8_quant.py": "9c6c81711dcb6833fd12f8f2e86ff4728b5b3e97ed2862273c5eb4833d775892", + "python/sglang/kernels/ops/quantization/nvfp4_gemm_swiglu_nvfp4_quant.py": "aa8129b1cf1489d988f45658a730e9f593d20eec6d7e8e2df936efcd28658fea", + "python/sglang/kernels/ops/quantization/per_tensor_quant_fp8.py": "7fc8f52c4802eb4d33840e14e4261bb7baf45bbda336bbd861726a7b62ac9f27", + "python/sglang/kernels/ops/quantization/per_token_group_quant.py": "e06b15269ef3d75f6a85ab7a3268ece5624572e4fc95cfb0ff2ba26442432f54", + "python/sglang/kernels/ops/quantization/per_token_group_quant_8bit_v2.py": "c93f3059787d5d39d70fbe6affd28b1fa8286e2a68ead5c8becfe0004b0d14bc", + "python/sglang/kernels/ops/quantization/per_token_quant_fp8.py": "8f9ba0c5036d805eacbbb16cd4840bae035137be0fdbbb032873f291d1b510cc", + "python/sglang/kernels/ops/qwen4_ple.py": "9aad781e87bdc3be74dfc29cf9d1f5286456c550846856f6d7d0ca689a78ea7f", + "python/sglang/kernels/ops/sampling/__init__.py": "1c7676b6b0247bdce410ef682e7efcaf3409558d53ddf5383b3bf11fed55ef75", + "python/sglang/kernels/ops/sampling/murmur_hash.py": "0f1907f9b4665641166d1cbe94d392f1145eb468493fe66b44d515c394858bd6", + "python/sglang/kernels/ops/sampling/renorm_triton.py": "4c1a02b67c4aa518de72c27c495678e83c32178ecc8cc877c72dbcb34ba2232e", + "python/sglang/kernels/ops/sampling/top_p_renorm_triton.py": "ca04085e3a572a3f7ed41dd566f8cb3d3fd5f0eac03ad31ad0f101539701126b", + "python/sglang/kernels/ops/speculative/__init__.py": "a383c49aba6a5345e3879aeae9b962c5e66a583d37b32fd8b9a19784d7e19d4b", + "python/sglang/kernels/ops/speculative/cache_locs.py": "d1ae7029c4591ba79f9cc62c42cb2aaea896ca32bd918ce046063515f3ee0e65", + "python/sglang/kernels/ops/speculative/dflash.py": "f4cc3f2539a9ae6b1db0c0704f88bff557afc88f6bf25269e33ed13d574373b5", + "python/sglang/kernels/ops/speculative/dspark/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/kernels/ops/speculative/dspark/dispatch.py": "8baa09b85ad97aae209b55f40271bdd4168a2b889247dd5aaa6a7dd1e0d1772d", + "python/sglang/kernels/ops/speculative/dspark/dspark_accept.py": "184dec7ed90d64840a4f9ff3ffd583ce9ea4c50ed1bb676d1e8b1157fd207381", + "python/sglang/kernels/ops/speculative/dspark/dspark_attn_metadata.py": "9718b4ebb5934bf3eefe57ea7ae6df888d39cd1d8894db11a2b46253513f7a22", + "python/sglang/kernels/ops/speculative/dspark/dspark_draft_model.py": "c917b63f5754569288002757f5d65980de3325460712112a4af1d10dedd260c0", + "python/sglang/kernels/ops/speculative/dspark/dspark_schedule.py": "420478eac029ecff9a8914b7df4d7db2fea4f61be9dbafa1cf34b1b890292c06", + "python/sglang/kernels/ops/speculative/dspark/dspark_verify_window.py": "10266a2d86af22a42e6020a0753efe40123789f26093661ac2bb3de92387ac20", + "python/sglang/kernels/ops/speculative/dspark/fused_kv_write.py": "f48e2481327f8e5355ad2dee4c9b6d40fb4802e9e05b13d21e722f072f6a5cc3", + "python/sglang/kernels/ops/speculative/eagle.py": "b96e3d0538f52d73b32a7f29f649cfb52a88c8a74110a55bd5128524374c404c", + "python/sglang/kernels/ops/speculative/fused_kv_materialize.py": "b8dd985b7764d3212e9e3045b2daa5be0c481215346ab28f2513f8201e9cbfeb", + "python/sglang/kernels/ops/speculative/gather_spec_extras.py": "5b4e41ce94ef81db8a6a80cdbfbbf379675288a9f922a74a2cb4ac2b9f8c35e9", + "python/sglang/kernels/ops/speculative/multi_layer_eagle.py": "f43949449eef3361780bdf3b0b8d258fb6cbfe384936871b442dc90868cb6544", + "python/sglang/kernels/ops/speculative/ngram_corpus.py": "61848bb43c31193f8911dcf9cfda9e8e4871c63283d1edd96cbd0a219fd4f112", + "python/sglang/kernels/ops/speculative/ngram_embedding.py": "1bb015b137476f5fb1707da971026a9a17634a0c4469d9257aaf5b4e9008dfa0", + "python/sglang/kernels/ops/speculative/ragged_verify_kernels.py": "9d004ba087b74550b471b2fb0946c3edea8cc94f692dd7b4be6db4ce06ea6c45", + "python/sglang/kernels/ops/speculative/reject_sampling.py": "c1e1b66aba3f0a0668fab32ae46152d5fd36a23defdfe5a6b27a6380e227e1a3", + "python/sglang/kernels/ops/speculative/spec_tree.py": "8b3dde69be73a7982cd8ea8bb8b39dc3b39b412bcb6fce6f5fa4ae8cc6418f52", + "python/sglang/kernels/ops/speculative/topk1.py": "2dc54fd39c34a6aaaf46fbbc5c3737c57bf70c42f036f33490460a03b6034533", + "python/sglang/kernels/registry.py": "9d9614b4a54647fa40c66d6baf962b4a105c653239075542ce2482fcded01cea", + "python/sglang/kernels/selector.py": "e13283e97d664d9ad70422c0b0b4c27c046dd934332d40bb5610887018741504", + "python/sglang/kernels/spec.py": "3ac2cbe41ad81f147d4be6b13555f50dabcbc394a56ac60bf5b2dff63a1f6d83", + "python/sglang/lang/api.py": "15edcee0a734716e4d8986ad3a33403aeb16c9f364ce4b93d2430e85a5db0af8", + "python/sglang/lang/backend/anthropic.py": "a975aaa85964d3e9c2eb64027182118cb4dce001eb7532a997b842783cd1394b", + "python/sglang/lang/backend/base_backend.py": "b44bad182539b678b5c4696b223015bc0f5a7e5241b7676e2ab203cea69b2567", + "python/sglang/lang/backend/crusoe.py": "c653bcc66d14be9c1d508a5d1aa16ac0c3693e984ddc007d8798607ba8351549", + "python/sglang/lang/backend/litellm.py": "ba098beec7d4c6450755b1edc0dcc781d40011de140a33506e816e13729385c6", + "python/sglang/lang/backend/openai.py": "605b3ba420caebf0e86268d36bebe00d575a784e0f62bec4fac202d6aeef027b", + "python/sglang/lang/backend/runtime_endpoint.py": "82d37c4e9a07cefc0d7afb2e7780ef5ad8973cebd8227da57e9b9ff3695516bc", + "python/sglang/lang/backend/vertexai.py": "833d2e358c816fcf236cf633e99209efbe1f79fadc6ee55da0adf76e98546692", + "python/sglang/lang/chat_template.py": "d91a4548101b581828c3e7b0517360a9a42e06d8295760972200147bb51c6a19", + "python/sglang/lang/choices.py": "f96d43570f4df59962569be65abcc85c6e1cb3001a87c78c42b1d6ce44b70fca", + "python/sglang/lang/interpreter.py": "043cb4a126eeb75cae6ae1801a2b9f0fe516d6488efff53f7ca3e4023f4da6f9", + "python/sglang/lang/ir.py": "2b153e4cc92d90e4f7a57a9fe49cd405c248e0f63738b9c47e0509634eb6dbb3", + "python/sglang/lang/tracer.py": "963068f55674cd5686c33364df6ab0db569cca8eb4374523223a816d3e5ad562", + "python/sglang/launch_server.py": "9a54ec8ad199766518c519b6b98ea6170ad8ec157029eed4bb3a49431b86a540", + "python/sglang/multimodal_gen/.claude/CLAUDE.md": "3da0db1401eef176fe5e50189b6af0f894be536d8caddc5e01a11591a12c320e", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-add-model/SKILL.md": "234fab7222e82bb86b0953f26122bd8c16b3a07c91000f7bf74b5c79b236f985", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-add-model/references/testing-and-accuracy.md": "33b247b92654aa65517116c6551ee78907dce01ce830aa8acb27b023ef0da80b", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/SKILL.md": "45f542a134262717bf5725bed165e207e16e3cbefbd0e61a1118422c5f847d97", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/benchmark-and-profile.md": "34653767d8097b2ce6cafc721c53b7b99a64cfa70ba6d89305e3e0922375689f", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/existing-fast-paths.md": "fccf0458844c5b763879d19e4ee14f89d0276abcf37ee9feccdf0d6617dfffa2", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/scripts/bench_diffusion_denoise.py": "a9599c3bede9ef00b6be0466cc1a05a1b2945b119db05276478bfbb7da97e1fd", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-benchmark-profile/scripts/diffusion_skill_env.py": "6e33eceb3f170aec98937c63a7815d8132c0fc3565b20f5a6dee4ed5a8e3f050", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-modelopt-quant/SKILL.md": "d69bf54195574ff5fa2ad5f2f8c3b16dc0c9f17ca0f43796877e484f5a7c8092", + "python/sglang/multimodal_gen/.claude/skills/sglang-diffusion-performance/SKILL.md": "856426d2ca69413f10d4b704aedb9e33d88450aa753b6882263d5cbcb30d3846", + "python/sglang/multimodal_gen/README.md": "0a3cbac65031be3e1a0faf19f4c55ea8365ba13d159efc3dad1578546bf990cf", + "python/sglang/multimodal_gen/__init__.py": "a97a11a1ed866e58e1f18be0e697e07b97baac4a02aae38cf855b9308708aa37", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/README.md": "ea28cf5d4e9ec20c3b00abf731d1564f762ea41c2938ba7fa52e766c1574c1f1", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/__init__.py": "d559ddb65041458385e826de59b213d6508d0129b2cb3ac7be8a8e571d18bb7a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/__init__.py": "8cfe466edc4c988edf29e63b24c9bd32b3a9eeae33a3c0b982448df1c718656a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/generator.py": "5d6332833095f5822238b9265df5f19dfd7a2b47643cfd08ffd0c42824b1a2fc", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/model_patcher.py": "8744ad46bf889f92398d872cee25a6600151f25c380c30c94d6b78d587a71b0e", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/core/server_api.py": "ce31460c870b5a10cf69510081e3c63dc16717219002b43a1dc3759107f49250", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/__init__.py": "d43d7b1097c2657e6f65d20d8e60deee98428aef48c34dae19feabf90e4c6457", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/base.py": "e1ebffa3b2584d3a9498491ade0cfbded3933832910ac22f6f1224c1f7d517c3", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/flux.py": "5dd565803807e4db602d03fd4171491e2a7d80a0b76d01a819c63e7ff1da2dae", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/qwen_image.py": "bb28bc708a7d7dfec124b4c3783d9f1beb268b531b9b26cbfe731a6c93f7807c", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/executors/zimage.py": "670252d402274c0f90887ac97152ff4bea5d086069903d66d106dda3fee4792c", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/nodes.py": "f58804c6daafc726b97fadcfbe5a32fdd2063fc0ab67021fce1f7e9f51b2ad91", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/README.md": "579b98f08cc508a3b111027470b9e1698dae7e63cf316cb08c7ee96d50b9735b", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/__init__.py": "2b9cadc14fc06788a3c041eb674898f0329fa173ee242a7bac748504c9f7a513", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_flux_pipeline.py": "f9df682faab73350ca77e714cdc2504aabeb82ecc936ecd9d2fcfa87660667b9", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_edit_pipeline.py": "9843dd2905e60d4510d056caaebc3e95e99ca02f2b9a49d8ff4c67809f35275a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_qwen_image_pipeline.py": "7ba2f1139ad2a7391d60c4f73ce95c0ea3702dd355e525214df85f08e5aff139", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/test/test_zimage_pipeline.py": "5ddf814b78fe683dcbf77bd1f286c4ef29df974f59d496f2ddb63f81e1c6b1bb", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/utils.py": "18ccb69ba09c25f2f5d1704157b6a8023ab177fbdf5c746a198b59e2d7d185f2", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/flux_sgld_sp.json": "a32697dba5a49820bd4816174b25a3eee45a1acdc8d95db5f115513abc5c403a", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/qwen_image_sgld.json": "bab2400001f92d01f4fcd331a491d0029e68023ef37bea118e84e410425ed77f", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/sgld_image2video.json": "e8d532a567959ec2f9310426a6a26f4dd71e3f6b569a63d5bbdb55062b91e842", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/sgld_text2img.json": "8dceff5513a380fb79586fb88c319b8c385f1f1ed5943e41097c57bea861fd4c", + "python/sglang/multimodal_gen/apps/ComfyUI_SGLDiffusion/workflows/z-image_sgld.json": "67deca18066b0d71576a5865b340ff116201cb4eea67bb8b10bb67420983b927", + "python/sglang/multimodal_gen/apps/realtime_webui/README.md": "c2acc71067182e70792fc607d6d4c1a62b01de8fcf044b28a30c453c52270a5f", + "python/sglang/multimodal_gen/apps/realtime_webui/app.js": "6e654cd3620e2524af7c4275f1e653a19069d372ed210ac367101f0a11b6fb1b", + "python/sglang/multimodal_gen/apps/realtime_webui/decoder_worker.js": "7d2655224ee3e24fb2347ef27214bedc7cf16bba60e8621aff05549055a06cdf", + "python/sglang/multimodal_gen/apps/realtime_webui/index.html": "8161da333a0e0889db51e2c050a7bf9b3c9a7767c6ca2c153af73bcb18becdbc", + "python/sglang/multimodal_gen/apps/realtime_webui/playback_controller.js": "3e01586ef955fcd35fb10969ade00825ed5756d9b1f95a2b82b00aa32ac62e0e", + "python/sglang/multimodal_gen/apps/realtime_webui/playback_controller_test.js": "cc5b19e9aa5548afb9268e9d154f4fa44153531994aad02e8560065e8788a022", + "python/sglang/multimodal_gen/apps/realtime_webui/styles.css": "179ec7d17cd189119c2180b7e0c78e7dba2b8aad65632cc5b4765958d294b39f", + "python/sglang/multimodal_gen/apps/webui/README.md": "7cb942ce7ab99a4d4c8003229acea6b600ebc46060d7303e8dc249190dab3cc4", + "python/sglang/multimodal_gen/apps/webui/__init__.py": "1f081fe4d4446bea793d8df2b829704a545ec7ed315a6411b4190ff834bdac29", + "python/sglang/multimodal_gen/apps/webui/main.py": "c39733d00b9c2a648fe47bef15cf6d78aa196e9aaa2b8dce8329b7f639589568", + "python/sglang/multimodal_gen/benchmarks/bench_offline_throughput.py": "a4c3e077312ed5c0495e7b0f2753f68234efa365dfe8641c93674ea2146d93e9", + "python/sglang/multimodal_gen/benchmarks/bench_pi05_openpi.py": "b175c2d7465220c88ea51a96f00bc2ec2b62b5568d3149f6a20b0c8d7d284ba0", + "python/sglang/multimodal_gen/benchmarks/bench_serving.py": "e934cf27af6e551fefeadf51143d8eb79a6d7446aaeaa106017b9e0e043a40b7", + "python/sglang/multimodal_gen/benchmarks/compare_perf.py": "0bd7da189b5ba7dcb84f8d18fbfff7d3a47b3fee0ec022147d0542d39239a14a", + "python/sglang/multimodal_gen/benchmarks/datasets.py": "1897ad432e7a48172d2b1464c337acc7ea1812015c171527a271ca6cc3c2bbf7", + "python/sglang/multimodal_gen/benchmarks/request_manifest.py": "14d4bfe40e878787c52e70020320965f3176d74552eb0ed8ca71194d8a7d0b60", + "python/sglang/multimodal_gen/configs/__init__.py": "2826d8dd051f9024e382088f3d1508a841881e92f9979fcfc8176479610ec70e", + "python/sglang/multimodal_gen/configs/backend/vmoba/wan_1.3B_77_448_832.json": "5c9c6a807a0943e169ca1595b302c92fa17266f3ed07a71ca565b83701f3cdce", + "python/sglang/multimodal_gen/configs/backend/vmoba/wan_1.3B_77_480_832.json": "ccb9da0f5da26aedc6a0f77394b4d4d5e4e8575d214ab4d3a2b7b2c070d90b8c", + "python/sglang/multimodal_gen/configs/models/__init__.py": "cb5d104fbae96c0d9e62fd62e53938fb666c8d21eceb6dd56839c6ac8820bdda", + "python/sglang/multimodal_gen/configs/models/adapter/base.py": "fdc068bb5ce39c0ba4a265d4b565a38e2fb0fae53de4ff4493e113f4f61c5ca7", + "python/sglang/multimodal_gen/configs/models/adapter/ltx_2_connector.py": "7c824ee702a3f023da47e5be40c9063e05c9e0aa691f56bcd455b7b64ab3ab37", + "python/sglang/multimodal_gen/configs/models/adapter/ltx_2_duration_head.py": "29d115306458b08b4a8c30f3982fac43dd04f1f5a58798ac81203b0bab6f606e", + "python/sglang/multimodal_gen/configs/models/base.py": "78506d1723cf8b6fc5c34ab8b3df228ec7a9cf4f8f878520c0d6addab5fc859f", + "python/sglang/multimodal_gen/configs/models/bridges/__init__.py": "5f2daa21e492c411fc514553b5e2b7afe9bfa1b1f3748b72e083322308ee9455", + "python/sglang/multimodal_gen/configs/models/bridges/mova_dual_tower.py": "5952b3f122ce18aaa12ebb73a51e04697e1eb832e0db202a285eb14371763b33", + "python/sglang/multimodal_gen/configs/models/decoders/__init__.py": "e86ec17d67a947d20f77d9e24d3fdf15271d6231de81c60a6ac56939a467ea28", + "python/sglang/multimodal_gen/configs/models/decoders/ltx_2_5_diffusion_decoder.py": "16e1dc5b55c95c49e1c9001136c41b0719ad16721219c3d25865c42920797646", + "python/sglang/multimodal_gen/configs/models/dits/__init__.py": "f5dab49623982c6b0a1d089922ba23f2098df59cc97d88ae390b0ddcf5a2fbda", + "python/sglang/multimodal_gen/configs/models/dits/base.py": "94db17fce1f4801fbcdf6733ce49caec5db4d2133ad84b9ecdc92b0b7f1e934e", + "python/sglang/multimodal_gen/configs/models/dits/cosmos3video.py": "d32e65a40bccbe48add895843496d076c04cb3898225ae09f9059e80393892d8", + "python/sglang/multimodal_gen/configs/models/dits/ernie_image.py": "cc10dccfeffaa9a77200aeeeca15d1057e59e1cc2adc20ed047f5b7d0f391fbe", + "python/sglang/multimodal_gen/configs/models/dits/flux.py": "0a6de167dc42c36d8d48ff448407d8e9a8df6fb7578b743a8ec38e62f4bea0eb", + "python/sglang/multimodal_gen/configs/models/dits/glmimage.py": "3daa2ae842980b184c873882de3d2ae47ca6cb6ce63e57b2225a56b2aeb85a31", + "python/sglang/multimodal_gen/configs/models/dits/helios.py": "46642a6f6d63d2d7f574406ef2599825b2db39be4a0dc7dfcaf7652d33ecf51c", + "python/sglang/multimodal_gen/configs/models/dits/hunyuan3d.py": "b438cc0fdd229821f77d388fe5d11587e129bbe438a77b250801590c7e063ea2", + "python/sglang/multimodal_gen/configs/models/dits/hunyuanvideo.py": "e32ca1339b075d4df96d48be961817b35f613d106666b1087a3bceaa20a9339e", + "python/sglang/multimodal_gen/configs/models/dits/ideogram.py": "fca2a4b7ba50eeb11abb9b5db2d3f4415eac154ec837bf607915eea3d2a27735", + "python/sglang/multimodal_gen/configs/models/dits/joy_echo.py": "ad3243260a1df4dfcb63f9195133d6605b275f7894819cac5d08a0524de63ee4", + "python/sglang/multimodal_gen/configs/models/dits/joy_image.py": "3236d64d8bd1cee09068e7318ef41c4903fc8012d93a6387504d9eb335f45605", + "python/sglang/multimodal_gen/configs/models/dits/krea2.py": "4da56df4f83573b459ca1ae10892a1a105af4c0e64c912c5f0a40ca11a769150", + "python/sglang/multimodal_gen/configs/models/dits/lingbot_video_moe.py": "219a5a9db3ba7786c7a90fb83c0f37bfb8db167f5a76b56f2eda026511b6cf08", + "python/sglang/multimodal_gen/configs/models/dits/lingbot_world.py": "ffdc1d327df385b1daf8653c621b3e192de25bfa96c9356b124a43b218ae46b1", + "python/sglang/multimodal_gen/configs/models/dits/longcat_image.py": "a461a25403b46200127e620809f97450be5522b9cb50d16134635371db1731cd", + "python/sglang/multimodal_gen/configs/models/dits/longlive2.py": "6b0f2ece41cf7ef0c8ce92e7a3300fd89d881b06053bec5bfdee1c39dda250ef", + "python/sglang/multimodal_gen/configs/models/dits/ltx_2.py": "70c3319ad2e1ce026f3ff02e8e4b5cce58d96b1e2190e33a461d031517ebc333", + "python/sglang/multimodal_gen/configs/models/dits/ltx_2_5.py": "7008178dc37431d31f06eea942e196d5d0667b7783f448e75a849d8c814dce71", + "python/sglang/multimodal_gen/configs/models/dits/minimax_h3.py": "8a239ed923abf82d577c220896d28b42c01f6aa7514a8dc2dd4cd2db4afd0d48", + "python/sglang/multimodal_gen/configs/models/dits/mova_audio.py": "7ee8ba0eef9083fd49b21136c7cd378431549b4e43bdee034e271d0ddf9a0594", + "python/sglang/multimodal_gen/configs/models/dits/mova_video.py": "0a5a9809dbd9c6981c1b195cf62915ef43ce14450d6f5baa79856986c994d871", + "python/sglang/multimodal_gen/configs/models/dits/qwenimage.py": "14da21d839495ceb9ec028386a2573d48995331f6289cf2ec3950183ada3cb32", + "python/sglang/multimodal_gen/configs/models/dits/sana.py": "d4d67b037d1ad81856143d2f641c3e47bef55d7c06de183d8ea014f198f72310", + "python/sglang/multimodal_gen/configs/models/dits/sana_video.py": "f42763aa57df5eef983adb221259e773f9736d6ba2b266643bcc28f1f5f29280", + "python/sglang/multimodal_gen/configs/models/dits/sana_wm.py": "97f3e28b2659d5eaab3954dc7601d274eb01e88868d0722ccd7bcc16e48e156b", + "python/sglang/multimodal_gen/configs/models/dits/sana_wm_refiner.py": "301ada1b905f745c13fe0717c7855a7b5e1b428a791e6a7d817c77b34be7d51a", + "python/sglang/multimodal_gen/configs/models/dits/stablediffusion3.py": "3d290e5515cddf0d40824224bf624be446d81f02c76c4c78c631da8ea66b0904", + "python/sglang/multimodal_gen/configs/models/dits/wanvideo.py": "e2703b8edad216852365e7dab09fc65d099078182806a97cf66bb7ca7d7a6fd6", + "python/sglang/multimodal_gen/configs/models/dits/zimage.py": "1ce4ec3bcc47e4f78e8e50ff5b5ff079c0ba0d9214f2721ebd80e424f487f8fe", + "python/sglang/multimodal_gen/configs/models/encoders/__init__.py": "982dd2d1dbbea63217e4dab5d4d806a7d473e86ca2efdba27fa1783ea8249d28", + "python/sglang/multimodal_gen/configs/models/encoders/base.py": "0f5e4b4ad6406c4649fa02487cd639a8d18728dd01c8d21436432591d6f491df", + "python/sglang/multimodal_gen/configs/models/encoders/clip.py": "95dd43242f1bbd8a3d4eee62dde848ff2d923ce2296ced6415772e1bc5c68c7b", + "python/sglang/multimodal_gen/configs/models/encoders/flux_2.py": "4c1e39bfc899f56a5dbc0c8faef7249b6d5f7f209a3fb9298096dbf07a51aeec", + "python/sglang/multimodal_gen/configs/models/encoders/gemma2.py": "15334d16485d0d16ccd3ad5d9ac7a22da3603178f9f6883186770f8277145df7", + "python/sglang/multimodal_gen/configs/models/encoders/gemma_3.py": "5f99d876b7ec0709ac731985cd9108f53391a9fec6fba3be06e11194cd9b4fb9", + "python/sglang/multimodal_gen/configs/models/encoders/gemma_4_unified.py": "1a3285adc6feb47ee1ab62acce97391a3608bd58ff8645248965a61d68a59373", + "python/sglang/multimodal_gen/configs/models/encoders/ideogram.py": "f2fb04c48efb5e34172c3d00a173e54b692f1ec20e750d5ca0c7949be7b68701", + "python/sglang/multimodal_gen/configs/models/encoders/llama.py": "860ebb8c5760c40ca774272ce059a0a03dc8a5f56c9453c4220d9b38a72f9425", + "python/sglang/multimodal_gen/configs/models/encoders/minimax_h3_qwen3vl.py": "7ebef8db507047384fa1cc78056afe93f7c4b707ce10693bd435014c8187f1e1", + "python/sglang/multimodal_gen/configs/models/encoders/mistral3.py": "72e05222b7961fe0561853f48cdcacb7bb8235bd93b52e2350cc73ace6286f29", + "python/sglang/multimodal_gen/configs/models/encoders/qwen3.py": "10f848e8643309e3468a856e98ee46a4e79c6c1e465edc2e620e42b5220d6aca", + "python/sglang/multimodal_gen/configs/models/encoders/qwen3vl.py": "b7f74023e4318dfe5857239a18a6ae8e36b3b963433ca1ae54d98ae6c77478de", + "python/sglang/multimodal_gen/configs/models/encoders/qwen_image.py": "c2f8e9ae8ae4dc66fb41dfc386e8194f6337efe197a2e7875778cd65b6af9e8e", + "python/sglang/multimodal_gen/configs/models/encoders/t5.py": "f142658cb9187c9258c1cf725f5a973ae8d51a87aae3e1cb042556c9330f5d9b", + "python/sglang/multimodal_gen/configs/models/fsdp.py": "3ad41ffde2108072950e2f82876504a0255324119a0470f1ff4e525ee1ac2e19", + "python/sglang/multimodal_gen/configs/models/vaes/__init__.py": "e4d897af0fa4c3307b543991d62bb785c88f443e845b7461646d8d47eff4df11", + "python/sglang/multimodal_gen/configs/models/vaes/base.py": "d6c4696a6c18f41126741ecd7c14691d819253bbd74f8d70ac08ae6f5634b452", + "python/sglang/multimodal_gen/configs/models/vaes/dac.py": "fe3b6b8a42cd23362479af6fd36c773ad8fe35e50ebc857b74a85984fb6b4330", + "python/sglang/multimodal_gen/configs/models/vaes/ernie_image.py": "bd8cf7d4b64815b7f963413473b5a1af322d21b5bf9396ad299af0c6eb24bff6", + "python/sglang/multimodal_gen/configs/models/vaes/flux.py": "1c47aaca7238d01792e3b0f3630270e06f2667f0363317159364074ec7a9a65b", + "python/sglang/multimodal_gen/configs/models/vaes/glmimage.py": "a9684072f50457c607ae4a785658ce7a7ed727998c72b2cc237888cd40941310", + "python/sglang/multimodal_gen/configs/models/vaes/hunyuan3d.py": "7381f9e37b1549be676099f850b61ef161f44dbbe6f64478f515879dd611aba4", + "python/sglang/multimodal_gen/configs/models/vaes/hunyuanvae.py": "7c3dde2a48e25664d619e1296af9c2b57f9ad9b6322f7077210bfe92b8efaa3d", + "python/sglang/multimodal_gen/configs/models/vaes/longcat_image.py": "9763882931ad55a71bc37730daab6cf72bcea4bda44289ec3b90663777b93059", + "python/sglang/multimodal_gen/configs/models/vaes/ltx_2_5_video.py": "c549785982f1fe27864c1f835064fea74ec1b6412e14467ca0352de0178667aa", + "python/sglang/multimodal_gen/configs/models/vaes/ltx_audio.py": "480423289d72034b97aa5971ad15639b6da0a595d8a10900da43a8b5cab65bff", + "python/sglang/multimodal_gen/configs/models/vaes/ltx_video.py": "00b942b8d00f2d053335fd90d169402d46d96ec7d7a1464b9c0f81a41542efeb", + "python/sglang/multimodal_gen/configs/models/vaes/minimax_h3_audio.py": "3737e8659a94aafe662c12c937b18e84551f518e2802e13a7914433ef1159c59", + "python/sglang/multimodal_gen/configs/models/vaes/minimax_h3_contract.py": "d0934b2d2acdf692983dd6ca3483ddb17f91c601c3ae07c8442cf7c6b5acc258", + "python/sglang/multimodal_gen/configs/models/vaes/minimax_h3_video.py": "cd28c09c06c77b0d398c3a7f670b306792e68c1b2f785d3177de6a374f33e161", + "python/sglang/multimodal_gen/configs/models/vaes/qwenimage.py": "17c44d212e94d29c94e9460b8918f7cd3d441f2e9a3c8dc147f8c7d77b30262a", + "python/sglang/multimodal_gen/configs/models/vaes/sana.py": "88a2c5396c5fc65b92fa5e024f8991c194b2f26aec9d126bd21417a6f589d7a0", + "python/sglang/multimodal_gen/configs/models/vaes/stable_diffusion.py": "ccda6acb4bea0a6fa821c25875c47787795102fff9a0bf5ab18eb640550b730b", + "python/sglang/multimodal_gen/configs/models/vaes/stablediffusion3.py": "08c64fc004f286459c0809200d2cdcf3c4e14406906fa0f270db134ea462a416", + "python/sglang/multimodal_gen/configs/models/vaes/wanvae.py": "1d1428ec59abfecf598cc54705bc7e338c2487aa485a4b4df1c58926e72837e2", + "python/sglang/multimodal_gen/configs/models/vocoder/__init__.py": "595e115ee5493cd740fc0cf2781ba9f5412733e630e21a3fa38ffdb90a2eba04", + "python/sglang/multimodal_gen/configs/models/vocoder/base.py": "5c017b6fae254c1da159d048b4f02c5b7eb36ca667e2ed446d3b96c892f29db8", + "python/sglang/multimodal_gen/configs/models/vocoder/ltx_vocoder.py": "ffc9f3d932daffe269bc95b0c90ad84bf13dfd1aa17a30b1f9abd28c6f6ca450", + "python/sglang/multimodal_gen/configs/pipeline_configs/__init__.py": "c1b294c5a3c418d8f1b44ecd95c02d975b87608086b3a876786829bdfe6e2591", + "python/sglang/multimodal_gen/configs/pipeline_configs/base.py": "066a8bb949d100f4a6b88e71fcb4892273f253820aa7b974019b60213e6a7bf7", + "python/sglang/multimodal_gen/configs/pipeline_configs/cosmos3.py": "bd7eac43e24677d7963f3e2537c04f8e8af5908336cda8cbe0ba56c935a8e610", + "python/sglang/multimodal_gen/configs/pipeline_configs/diffusers_generic.py": "567c368b86cfc3443ffba89d7d1112f807f8ca69586ca495c1581099da1acf8d", + "python/sglang/multimodal_gen/configs/pipeline_configs/ernie_image.py": "f859f7cc9993d95b269bb11ce1e4beb1c3f642ba27aa2d223273442b97bad247", + "python/sglang/multimodal_gen/configs/pipeline_configs/flux.py": "39c60bef47f5cb69bdfaeb9bc3dd115f7b26f6ee03181980534eb2c8e6f88ab1", + "python/sglang/multimodal_gen/configs/pipeline_configs/flux_finetuned.py": "ddb3dd4822d318c93b22ab6df895aebc34cf12d82168561be28eb87d0d39f9c0", + "python/sglang/multimodal_gen/configs/pipeline_configs/glm_image.py": "d0ad46bfad24b2f784babdf8ee788cea6323ae13a7fa641e36f79c4086ea56c4", + "python/sglang/multimodal_gen/configs/pipeline_configs/helios.py": "094a4544fb2251016ce4b62f68737327a722cf97d7506cf6ba47bd4d64de7f9f", + "python/sglang/multimodal_gen/configs/pipeline_configs/hunyuan.py": "6115724e8e69d65c7b407d3ac6166878eaa38a5e7e97aab9b2f338a8649e053f", + "python/sglang/multimodal_gen/configs/pipeline_configs/hunyuan3d.py": "570408aeca5fe43122cbdb4b1c7feb1dffa6fa1202a6619f564fb863e8eb5a4a", + "python/sglang/multimodal_gen/configs/pipeline_configs/ideogram.py": "0767e6b4ef030413a6adc279b2f6e00d74aba7baf4c86057671e8758d1377454", + "python/sglang/multimodal_gen/configs/pipeline_configs/joy_echo.py": "69b6caf69142b33c8cbe02ca93c456b6308c5bc25218abc785efb8ebf6b7ea4e", + "python/sglang/multimodal_gen/configs/pipeline_configs/joy_image.py": "6d162651eddbb853b5729e8ddf49c24986d995ef127d51ac2ae370a03008e39b", + "python/sglang/multimodal_gen/configs/pipeline_configs/krea2.py": "5da1560111d0e48ce7e0bfeb369f3ba646e3f1be0e5c896d05b0965efcde5b09", + "python/sglang/multimodal_gen/configs/pipeline_configs/lingbot_video_moe.py": "994bb9b7a0ad07b36b595abcbae968ab73b635711ce98a18263ad5ea2627ab49", + "python/sglang/multimodal_gen/configs/pipeline_configs/lingbot_world.py": "5c5a1c79887ca31ccd085379dbb23af1b1710c7fd1017129ce46a84af0000e0b", + "python/sglang/multimodal_gen/configs/pipeline_configs/longcat_image.py": "e3b8ec918b9f2b4a34420f65bc3bc14e0e0cbb2182cd267b074f4fdfa0f766fc", + "python/sglang/multimodal_gen/configs/pipeline_configs/longlive2.py": "ca4a7e2a6ad9866f59ebb8cd4dfc0bfb6e108542154ecd9db1985d9075ca04e4", + "python/sglang/multimodal_gen/configs/pipeline_configs/ltx_2.py": "76b57a82baeb51409f140cb7627e3fb2a9461abe80305dc363662fc0180028b3", + "python/sglang/multimodal_gen/configs/pipeline_configs/ltx_2_5.py": "4fe8f9ba981a668b6809520852f8053ba9412c63ca2b805c861d1817dd99f4ef", + "python/sglang/multimodal_gen/configs/pipeline_configs/minimax_h3.py": "02cd79f1b40abfb21b62bf0f6803ff925d0538671cfc91c3a8b051df329e0791", + "python/sglang/multimodal_gen/configs/pipeline_configs/model_deployment_config.py": "e6abd027ad8e0cdfca40c6d900fddb0dc07a6ca5e0031a7689c7ee5a54528ada", + "python/sglang/multimodal_gen/configs/pipeline_configs/mova.py": "e5b7e3cbd4cb343c2cccc04cb8ed890091aa4861b9183c9426efe0a8ef2197a5", + "python/sglang/multimodal_gen/configs/pipeline_configs/pi05.py": "3a96e0e67fa08540dead457c345abfd4c1c71e06ab27d6ec4a7340bfc3e08e4e", + "python/sglang/multimodal_gen/configs/pipeline_configs/qwen_image.py": "160daa9faf33cd38f17ce596a4e364c470af24b2915a0c16ebb4e83edb898c1e", + "python/sglang/multimodal_gen/configs/pipeline_configs/sana.py": "1b8eae33471d32576570b4fcc131391622aa5cda2742b3533110269fdd08a9ca", + "python/sglang/multimodal_gen/configs/pipeline_configs/sana_video.py": "58206af7c464be639e8c15f39261f465148a05856f69b238cab1c4eac202a5b1", + "python/sglang/multimodal_gen/configs/pipeline_configs/sana_wm.py": "440b9eec0707d38812506e669e79e972269ec4876987b1977cfdb47cabb281a7", + "python/sglang/multimodal_gen/configs/pipeline_configs/stablediffusion3.py": "4bb8f9d781bc7fbbbafee672cfa108b1533e5e451abef5627b7c31d11bf97f31", + "python/sglang/multimodal_gen/configs/pipeline_configs/wan.py": "7b98d3af2d1e5ae0d55763b217792c9a7c439cb06567e7c47f7dc4efd8f0341b", + "python/sglang/multimodal_gen/configs/pipeline_configs/zimage.py": "00c3b09219e95dba90806c918275041ff0a05f50dc7745358fbf946e72f29d20", + "python/sglang/multimodal_gen/configs/post_training/__init__.py": "9af6eaef9cd2746bbc48411f2f1851a8a5c754a54a1a3997d70b21acb65ca66b", + "python/sglang/multimodal_gen/configs/post_training/pipeline_configs/__init__.py": "384b0bb57d8d6e35f2d2cf5c9c91e648525d129c2cad5a3853af3587b5d22569", + "python/sglang/multimodal_gen/configs/post_training/pipeline_configs/qwen_image_rollout_pipeline_mixin.py": "46f0cd5d327e7bfaa4bd45c37e4ce5be9dbbde9e3bfe82ef6e82c00b472164a5", + "python/sglang/multimodal_gen/configs/post_training/pipeline_configs/zimage_rollout_pipeline_mixin.py": "7ce0975d78cb71ee7dcc40078cfe535ee76749375961f4bd7fde50d70e52b13b", + "python/sglang/multimodal_gen/configs/post_training/rl_rollout.py": "549259dd777cac147012d00cb3742553cf0b1e526bc2e45b6ae65b8400c8bd32", + "python/sglang/multimodal_gen/configs/quantization/nunchaku.py": "46d75c6bce484ea14f96aedea78e372c7ac49a21c07f8f6bcb5da606dabe7f2a", + "python/sglang/multimodal_gen/configs/quantization/qvg_kv.py": "dff09aa18af398bc7c820b90fac1409f3792bbe7ad6be76415ba424d469f2291", + "python/sglang/multimodal_gen/configs/sample/__init__.py": "b778b25f520563ab805431511e1843e2565058268811952e1e21dd689eaf5f89", + "python/sglang/multimodal_gen/configs/sample/action.py": "312e619c42f4a7827b1976c790945ecb1b64e032dec7697916f1984ba72d6d5d", + "python/sglang/multimodal_gen/configs/sample/cosmos3.py": "e336b83f7c92738b520e97ea05870701075e5e92248deec5b00a90904aa2ddf3", + "python/sglang/multimodal_gen/configs/sample/diffusers_generic.py": "7c739ba3f8885dd79142937df6023f4210eed2cf6a60ade68062eb517b3ff129", + "python/sglang/multimodal_gen/configs/sample/ernie_image.py": "0024b04ba1443b06d10376f794af681c880bf035cf6ae4d341f2904fe3a1dd0e", + "python/sglang/multimodal_gen/configs/sample/flux.py": "442dc7509cf5bc555873f5b31a8396bbc3cc44ab889fd498332224d8fa28113c", + "python/sglang/multimodal_gen/configs/sample/glmimage.py": "877bd695ee7245b829b540fa2c3fa326de7e891bc14cf022b7e2d47b638f20fd", + "python/sglang/multimodal_gen/configs/sample/helios.py": "8833aeb5318dbc983ec8860138b39d9c438a96f8bbaefb2402c306b97cf721b1", + "python/sglang/multimodal_gen/configs/sample/hunyuan.py": "1cbfff666fd539a55c3d21a2f91c7f81a688b34d03ecf698a080ec11d304f3bb", + "python/sglang/multimodal_gen/configs/sample/hunyuan3d.py": "a0e25f004514dae1a3ed0088c2c223a2ee893f2968c3757cbbb2f7b9f5c47920", + "python/sglang/multimodal_gen/configs/sample/ideogram.py": "6dd82d4d64a1de984bc3c10e2fed512f0490bb045f860c54e44795f94527ae2e", + "python/sglang/multimodal_gen/configs/sample/joy_echo.py": "57162970cc3cbe6c3c763cc20087eeb3c06038a4ea7652d16d15a3f97681c466", + "python/sglang/multimodal_gen/configs/sample/joy_image.py": "b61ace5aa2d288ef0b640ae2ec2acddbb497695ab13f86375542d41ee498e11f", + "python/sglang/multimodal_gen/configs/sample/krea2.py": "be892859626e7fa990fb00b94322add56e1eead791e8f4bfb8b266765f20d148", + "python/sglang/multimodal_gen/configs/sample/lingbot_video_moe.py": "70a071406105599dcb355ec82bc3bfe6c71edf2687bb91ac760877682716e276", + "python/sglang/multimodal_gen/configs/sample/lingbot_world.py": "5179822eac4a52098c168fe09a83afce311d506b9b78a45dc071b082ab7b978c", + "python/sglang/multimodal_gen/configs/sample/longcat_image.py": "3dcd05441fb21ce755081b79c190c750078ab194b1cf1779e57d7d42e72ffd24", + "python/sglang/multimodal_gen/configs/sample/longlive2.py": "c506485d0f0cb8f15e63a20d4896f6bc6f45e031b3922cc7d0c4a91d23e401eb", + "python/sglang/multimodal_gen/configs/sample/ltx_2.py": "99c5a0f17b090d77b2c6ba384c132bdd2a8a845c370c48b4a6b2a7fa72ac359d", + "python/sglang/multimodal_gen/configs/sample/ltx_2_5.py": "fcc768ce71f87c55e8a62ccd229863faa16122053a46dabf0e56e1b5f63af64c", + "python/sglang/multimodal_gen/configs/sample/minimax_h3.py": "18af182ad5f8afa61f179d17df9f9b5114a8fce54a4f2f9ea30cc388924312ae", + "python/sglang/multimodal_gen/configs/sample/mova.py": "1c3feae81b4b4e00a94844657967222b95c7d01819520b912e1afb712d4f0014", + "python/sglang/multimodal_gen/configs/sample/pi05.py": "5d43e92d41f54254482506620822d19950e8645f5f503f31a2c725184bb6d543", + "python/sglang/multimodal_gen/configs/sample/qwenimage.py": "ea8444691bde59d12f1a6d43997e9951618c56521741144b92d32cdc01474d96", + "python/sglang/multimodal_gen/configs/sample/sampling_params.py": "6884e0e62f02f66936a8ffa2937be94af2b97b32943f56b8ed1219a634da1d6d", + "python/sglang/multimodal_gen/configs/sample/sana.py": "f85ffe657605d8bebf9598b33cb05589b7304923db0a37fda65462006baf4ebd", + "python/sglang/multimodal_gen/configs/sample/sana_video.py": "2ddb49fccd4ff4e1dceb15f0a2d70d25e7d26d17598db480c901bc80024eac4e", + "python/sglang/multimodal_gen/configs/sample/sana_wm.py": "8181be4bcf14e4f7b1423ae681678409d066356d7deaa3c2ea08127cb53c579a", + "python/sglang/multimodal_gen/configs/sample/spectrum.py": "18cd0b88b5b5a7fe1f068973ba22a530c7810e4e8d1f79ea36dac3443ada0139", + "python/sglang/multimodal_gen/configs/sample/stablediffusion3.py": "a414cde6f8779e90d1828b3a75446550f9ef604f78d64d8721fdfbb1b085fbe5", + "python/sglang/multimodal_gen/configs/sample/teacache.py": "f0a19433a5f11c7d999651a1d09663d6bbbe840e7a654aeeca87fd12b262794e", + "python/sglang/multimodal_gen/configs/sample/wan.py": "85302beb7475c408238792ff52fdfc672121e63d7e17765f12d0063a82b82e27", + "python/sglang/multimodal_gen/configs/sample/zimage.py": "d6ed0e9dbd2c69e3397fd19968b5c974deb2132c6418fb6d443c91c1de21a772", + "python/sglang/multimodal_gen/configs/utils.py": "7600c200fd9da5f922009f9f1b7787f9d3bc47857ce2a1a96445e2f872d6b27d", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/README.md": "8c55e15fcec89519413672672d58175a172ca8e94786926b0ca433671a09ef8b", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/setup.py": "7cb78abf9ca9acf25098d7a460b3367e6886fec303fbd9dd950e5f0c5b7a6f83", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/tests/test_vmoba_attn.py": "7a52823f5176a6f0961b40e0cc8fc226adc8098d7706a64bea938efcb9733e50", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/vmoba/__init__.py": "30371a641040376a6189b06621a789767c059ec9df7ec1f2d4dfb12a6dc9c1b3", + "python/sglang/multimodal_gen/csrc/attn/vmoba_attn/vmoba/vmoba.py": "cd227e62840beb31d4d1ebf507c81b8c33a54e20c1a1699b7fa8e5dcf8000a71", + "python/sglang/multimodal_gen/envs.py": "f71bbe54d90f8d07e8d4131f01a05b91a8a6d2cb9224373bf1d937184b10708c", + "python/sglang/multimodal_gen/registry.py": "a771a635ad06ad8a11824bc225bdd160ca3b9cba88f69a41e1398eb992d6ce1a", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/__init__.py": "ed9938cb6b128de384c2b176d2fa033e0273bc3eecd6d0d2f1a6a82721b2d99e", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/__init__.py": "e691594a5ce99c7f54e73d0f971623d7f1d2ce3aba2a05da9aa8917833264a9d", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/ideogram.py": "636fa822c85d14bcb59787a0f534ea369915bc68db897dbc9515ca208e32ff4a", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/minimax_h3.py": "ba1e588c1a880f91faae63568bcca3aace973beac3d53d0d9e5abe96ac74ca7e", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/qwen_image.py": "ec4b97f00fc9abf51f0b3dd5b0b66620c2d19672818390ff1e0787e8e54f1084", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/model_padders/zimage.py": "3a4bda19ac8238b3ffba87b0cde6331d6212d6458e995cd0bb0fc4a46122c130", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/prompt_padding.py": "a25dc551ecb6a063acfe78c5407c5aacd8675eea4bbadd38020162748243120c", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/replay_token.py": "a369b0fd300c533037ea85471488ae86d6ab6933204e62b6e62f060e046a025e", + "python/sglang/multimodal_gen/runtime/breakable_cuda_graph/runner.py": "1a02770b3a0e98c8b3b61d56e2fc616e985f7669bf1d9861cf317a92dbccba6e", + "python/sglang/multimodal_gen/runtime/cache/__init__.py": "0593d7834935ab33a73567fdb33dd0d39d4eb1b2f34ad9dad698c08a6890f252", + "python/sglang/multimodal_gen/runtime/cache/cache_dit_integration.py": "42a68d1cbcd78069590734f895df0c4ddabb805c929c34d3215d91c6bffc5a4a", + "python/sglang/multimodal_gen/runtime/cache/spectrum.py": "913cdbb160a29ed347d926dd134bc578486f5b621c5fb91436cffad4d6d97bdc", + "python/sglang/multimodal_gen/runtime/cache/teacache.py": "786188df7fc2012b074d560fe5cb4c7c3ae4d6edc0ae856e072ba794f0d9e41d", + "python/sglang/multimodal_gen/runtime/disaggregation/__init__.py": "637371500f02c55002eff448b2f32dadc9e0d01e613b6bd2bcd13551611abeba", + "python/sglang/multimodal_gen/runtime/disaggregation/disagg_args.py": "3ff0019ac448754180d7d566549d77427b551177ca753a8c0d491c29438d27d8", + "python/sglang/multimodal_gen/runtime/disaggregation/dispatch_policy.py": "957c7b881f80fe26a8594f97582ea0f97fafc69d8b8406689dda44c2f148ccd2", + "python/sglang/multimodal_gen/runtime/disaggregation/metrics.py": "0d1df4dae44b1815ba2a002a58693fb09f5aba042045cb41652c5aa8ce30aa27", + "python/sglang/multimodal_gen/runtime/disaggregation/orchestrator.py": "95fe507d88b67addf3c9c050fa715cdc5dde8f8a5f38b53d058569a30b76df3f", + "python/sglang/multimodal_gen/runtime/disaggregation/request_state.py": "86dd2c18a08633d96adbaeb24214d5726fd86db3f5f7d0c35966bef062e7188f", + "python/sglang/multimodal_gen/runtime/disaggregation/roles.py": "7c21ef11bb940c6e91d67fcd43ea20837be91130bb4a877f73609f70bb6831c7", + "python/sglang/multimodal_gen/runtime/disaggregation/scheduler_mixin.py": "fe6399204805e6cfc2820cf58d935ae0e9a066ad5157cca4bebe81bfe18b8f29", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/__init__.py": "6deb74a4679590b2b641b8a2b62a6a6fc390af3b608bf0319bba2f0a8aead715", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/allocator.py": "35f6f2c20ab6b83bd5f30f5b9803ae5618a1fcb044352077aab933eefac12093", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/buffer.py": "20ab807cc1fc4f82758370289a7da6e3ea2cef74a6a795799c668519f626d38c", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/codec.py": "fd4df92e4c5dbbb601eefaf25977c274ccd498a85fd28c0538e17effd58a04f7", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/engine.py": "ab6005a8a3242764d01cb17f238982e5c70e78b76f1f6ba28ae67e68590c2f90", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/manager.py": "97c74bdfd98ee84dd1bcb7ac9b505b3a137d87838529c9a0dab81c925f998372", + "python/sglang/multimodal_gen/runtime/disaggregation/transport/protocol.py": "ea19ef2ea91b7e411ddde6d46edc0ad2d9e7d1836033ef5b244e794b790d8e4f", + "python/sglang/multimodal_gen/runtime/distributed/__init__.py": "5ef3261028b21da8e68affed24d0c66af68d68b4d65ba66f6a55f995167d0c00", + "python/sglang/multimodal_gen/runtime/distributed/cfg_parallel_utils.py": "722358a14230412a93135f00dc013c0560d93afadb03c732a9541feb60ed9499", + "python/sglang/multimodal_gen/runtime/distributed/cfg_policy.py": "a0cf5b16d0dbcc534f5b6487c7a2cfcc17fd1280e37c20e9b50cddad27f36e8c", + "python/sglang/multimodal_gen/runtime/distributed/communication_op.py": "a1d2aad120fb6bcd062f157b53165dd2d363b6318da4efec58fa2ddccab69568", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/base_device_communicator.py": "f3fdc26e0f9722a2662dd43e7f11180ffefd634d90e12b1740b2a9a0d2303f69", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/cpu_communicator.py": "7d1a179969c451e8adb9b2907780f4c2b4fdd18ace8f10d7cdcb129eeba1f66d", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/cuda_communicator.py": "24c6930bc8d15f50354209c71f7dfd4365c89d3d806c138aa49d7a90d220c79e", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/ipc_a2a.py": "cd01f9b81c72ccbbed1c942a4cfc4906f8be1a3dd74e1d52baff5bf0c48fed15", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/pynccl.py": "8cb46b8eee1063af1a0f8eca6d0912e64fcb86583131856863c4b6df96482ad4", + "python/sglang/multimodal_gen/runtime/distributed/device_communicators/pynccl_wrapper.py": "0eb4f8a9d5cf935f8126b8edc9ef80069d406ac17f8df491cff1c29a68939bd0", + "python/sglang/multimodal_gen/runtime/distributed/group_coordinator.py": "068cf27a3cb33da6d76b5076e46d3686f63b63453877a8a37d5012f29cd73631", + "python/sglang/multimodal_gen/runtime/distributed/parallel_groups.py": "b33f9e8238660a595e80c5073abcf424b7af2081a1ac9cd694778f23f994cdf7", + "python/sglang/multimodal_gen/runtime/distributed/parallel_state.py": "97692d77e1cb060ea7643eb9ad5342ae3db360010a20d781fcb6b642b3a6d3f5", + "python/sglang/multimodal_gen/runtime/distributed/sp_shard_utils.py": "40cb3fe9936966d020003d316a01bcfdea5f091637d05d2a5bd2af5260234f2b", + "python/sglang/multimodal_gen/runtime/distributed/utils.py": "d38d571a05dc1c83532b2f7942ab07807b3d0f0b7a2839d24ddfed86fe01ec40", + "python/sglang/multimodal_gen/runtime/entrypoints/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/entrypoints/action/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/entrypoints/action/api.py": "d8c16daf739fd895a65086aafba13273424b3e4cd4f5fbdaa83d7c14aa4fa94f", + "python/sglang/multimodal_gen/runtime/entrypoints/action/openpi.py": "bf41537b451d25887007df345a27a2d099be539fdbad302c5d4f89c8d156c994", + "python/sglang/multimodal_gen/runtime/entrypoints/action/protocol.py": "46188a7fdac7ffbf24ae3da4be46faac448f290f7ae2fa90a6389195f695a070", + "python/sglang/multimodal_gen/runtime/entrypoints/action/ws_utils.py": "ce4f1a12e9f5640cf0480d985a8b87b5701cae1c064b32e25b298f2f473b6e70", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/cli_types.py": "ad856b9c58ac35d9b1a6fc3fcd7767618faaff98c310ac8cccba80008b41be49", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/generate.py": "9ab20ab25260882b3128573e14b12f54c0bf53560f08040ed90fad6cf0d573c8", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/main.py": "290966752105570d8b96f3c95245e84510c4ac4ba72443c4e6724f7689eb0456", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/serve.py": "23db35d4bfbf3ad55aed39c4597aa61be1667b16a5b3d73377c86167ce663e9e", + "python/sglang/multimodal_gen/runtime/entrypoints/cli/utils.py": "f1e98ed568eb39aa8d41e077b5092ccc95f49520fc664037ee909bab13ca70a0", + "python/sglang/multimodal_gen/runtime/entrypoints/diffusion_generator.py": "8b4b23bd0420f0f88e7b354daa3a5e20f8d1d5569aacbb97c084645c296e996b", + "python/sglang/multimodal_gen/runtime/entrypoints/http_server.py": "09278b36165f2c7d81b7409b04cc1f1fd13a575af49007206271158a0eb946b2", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/common_api.py": "ff05244c75a516c93b6009ccc06698836d10501e812813177bce3c5eb1ea0eb2", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py": "24dbba5240324a27bf72f3a8e41f980b70b704c7b14da8d9691f886371c15184", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/mesh_api.py": "94a9c8469bc9644835df54a62a47ebb63473ee3880f1719eb5c2427738f686ac", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/protocol.py": "b8ba2aefe78ac6a948cd3a557b771e06cd57fbb35884d476abdbb62492218db5", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/adapters/lingbot_world_realtime_adapter.py": "85124e3287205c3eafb506b096b535360f7afb235c30c96b1a2967126cd106f1", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/adapters/sana_wm_realtime_adapter.py": "be6916085f7b325979e0746c3d23f689f625697dde361bb6218e96e25347fd01", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/generate_session.py": "11346d37d5022742798f4ebdff58a7656765a10dbf2b2f41e3a213c54183e189", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_adapter.py": "55f1ab90571bc336d6a7d3fab679b051a863b0870bf43c0a7961256b1dbf2470", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_output_adapter.py": "9f344bb1e243c41c726a4f4608a06108bf5456d9bcb92a32e84ac6c38226ae98", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_video_api.py": "331d27962a902a72f68ee6b19986b602806c5efc4cdc856b4ebac72891917ffe", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/registry.py": "181c5594ed95f042cd6493810880f39804ff5383c1d673e5f48a382f25468f08", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/timer.py": "5cedf5f6e7f97b0e54baa7122eba13a31ff0bd357046a88c235eb512a7181c08", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/storage.py": "2fd45ef1c008baa9ae0185c65e077525df78e1c5fb155401cefc8022c5b9d471", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/stores.py": "8e290bd34d3e50ad173133926a9007b5930f440faff7eac00573fc88b39f51bc", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py": "78c1f60d5c4a6fb73acf24308586b1e1f95be25c373f6dd00cb4a04509604b46", + "python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py": "446b3616c29a1b155619ff94d8460fedeeeb490a877abd0a0488b13f378d2247", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/io_struct.py": "d62d372fec05931b0c584e51ce2a874413799e53ea4d63d61cca69b6b19e77e3", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/rollout_api.py": "f61f6a43234e29fa985aed7adbb3f6bd81c03b7a6b9367461a9cc707afacf762", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/utils.py": "361613b9ee8ad2bfd25e19ae09f6ded30952d16b5bcd5f87bf2f424eae9210bf", + "python/sglang/multimodal_gen/runtime/entrypoints/post_training/weights_api.py": "be183aa4332472ca3a0d128e0b0a31f56b107bc44012ff351962f1462fc35dda", + "python/sglang/multimodal_gen/runtime/entrypoints/utils.py": "04afb89171c1807c301aeba6767efc4a6ec468437d16b8bc2c9337d8f5e3fd41", + "python/sglang/multimodal_gen/runtime/ipc_array.py": "a2c78346bd200520a3d29638a08edf0c6a4338a8b9f396d8c2357ce0004fb5c7", + "python/sglang/multimodal_gen/runtime/launch_server.py": "6c6c7c56a49299d8c6b0e5ce0e9aca59b5aca654d165b9526274dc0c1a1d46bf", + "python/sglang/multimodal_gen/runtime/layers/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/layers/activation.py": "9dc28da8e1c91e5489f4d9b02733e24807b150df1d9002990db9fabedbc0ee69", + "python/sglang/multimodal_gen/runtime/layers/attention/STA_configuration.py": "fded1886b3a0fd838f5bafe9a10aa0e351ec9f7aeaee50894af3c5a017f89a4b", + "python/sglang/multimodal_gen/runtime/layers/attention/__init__.py": "46c51ac1389ad58b4f46217454123de8d3f7ddf43e31c938acdf7a2f657c8833", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/aiter.py": "928da73506dfe0e3c1fa2b8c809206b6b489318e70a9c7fe35ea9365d95f5687", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/aiter_sage.py": "c022df1d60224c845a7c257e913d2e54769022b76f0327b95192285ab5c8fe73", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/ascend_fa.py": "5a61939216e8ad7d52fb0822bd114b224dae5e677acd7327734905916fb418e4", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/attention_backend.py": "12393e6ddc45229d38ceab55ce9a0a17ddfb1e8ca713de14cddf0dc48d6b6f47", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/block_sparse_attn.py": "93ffcbcac2fde37b53e7527cb8debc587e28038869e90045dfbfbf3c662f1dba", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/flash_attn.py": "eaf432dcd08afd649c62976b81802fb3c70fd338a434851a65db13b793b825b3", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/flash_attn_2.py": "38140528f6f6669844a2b746cb007c721f60c0b52df0801e9fe73bf0ade543d8", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/laser_attn.py": "8a13f75f0c27b4e686fba586b49f313da404789ef133b443778928ad53124f4f", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/rain_fusion_attn.py": "8c29c01bb8384ab729070f448b8f4444401aa1bd77b2a6484cbc87cbc7257887", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sage_attn.py": "fb8b9ac4f1b5d0c9f866cbed8f4b5405588899b6bc5a2a707be74215d0bd7bdd", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sage_attn3.py": "ce91c06a4eb6abb7fa027666274b23855c412f8e82721ca4ef4e89aa5c02d294", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sdpa.py": "49afb36bf827dfaf534e3e3b9cbece6e71a1db8b695829ba06bdb619826c35fd", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sliding_tile_attn.py": "e7c5dd336059ada2b7526463593d8989751cc822c600054c98e5136f6abe1ec2", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sol_attn.py": "996102079ecae4df164701a8d08deeaa66452006fb810daa35c8ae2fdda5e517", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sparse_linear_attn.py": "37e757c73e82e3826c919091f51dc7e2021312927c3ce4abcfc77626574cbcaf", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/sparse_video_gen_2_attn.py": "4669d65f68ae16436c8969ab5c98ef5374f5d144aae30579c3864f8171690bb4", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/README.md": "6d68705da25541ee699796eff43b4ada400362c98818e4c4c01155014bd8b677", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/__init__.py": "39d2a968dde6bc116d17168f190f11f5666fed502611d099014778742339124b", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/kernels.py": "7b8b2943ed05f13a380aa1c1843973cf3b7c3c7af6d34d6fce74cb7958bf663f", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse/router.py": "03330e28e03b059ce08a9d095f0212c1cc04ce11ab52feb220a3b6739add2407", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/subblock_sparse_attn.py": "54c2946bbb4ffb37cd2d707b45ba015bbe294f8d675ac45bb792ac286f72c055", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/video_sparse_attn.py": "a6c80e39f2622b2f1f6d01b9267ff14a36c10bf05a8d8f1f0681a6a8ba33c68e", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/vmoba.py": "f3f1037eec6ecdd186df6226fa7e6161b8e6fae3bc3032307da2a70e9d759f6f", + "python/sglang/multimodal_gen/runtime/layers/attention/backends/xpu_backend.py": "d867b65b5c5fc3e63c34cc77a09afe7ae6830f12730cd31021c1566241cfe6d3", + "python/sglang/multimodal_gen/runtime/layers/attention/layer.py": "879b43077a22be735c53ebadd4e9be4e33219f8139d7380c8c50e788ede1d661", + "python/sglang/multimodal_gen/runtime/layers/attention/selector.py": "68f9b6763b8b65c1362cbd2ee7df5f72135050109b31c3dd165a2243d2c98e8a", + "python/sglang/multimodal_gen/runtime/layers/attention/turbo_layer.py": "a603a836ecdb581a83059803f270bfd22ed01829732ff4bc602b1c40b6b6d48e", + "python/sglang/multimodal_gen/runtime/layers/custom_op.py": "9388052a00baf625ffa358c489ce643d9fb49759ba04bcd46845f0cb55580ba0", + "python/sglang/multimodal_gen/runtime/layers/elementwise.py": "c76dc89bcecc70752756ee4d79f6aa64b28b8746098b65e2ec80113f0b583a8d", + "python/sglang/multimodal_gen/runtime/layers/fused_scale_shift_gate.py": "aae43a406f2c2a4488567a94ce6537258541aa96a8d91d6ddf4268f4b39b3f85", + "python/sglang/multimodal_gen/runtime/layers/kvcache/__init__.py": "33d037000a3b740f0573069e6fae5b713b2334185604f5a3ce430c1946c5a8d7", + "python/sglang/multimodal_gen/runtime/layers/kvcache/causal_attention_cache.py": "628728f98c5ad29f85d5ad29af706d092d21930aafc026599124c33efe9452f5", + "python/sglang/multimodal_gen/runtime/layers/kvcache/qvg_packed_cache.py": "cc41601d83644893f0413156d6f7478ab664283ad4fa5cb09945664e22e313e2", + "python/sglang/multimodal_gen/runtime/layers/layernorm.py": "42a000bb3a098d32b106d04977c5fc513d0a1f52d5f131fcc793774280ed7362", + "python/sglang/multimodal_gen/runtime/layers/linear.py": "a93ff5a04c74ffe1acacbd3438273044764f81ff53e41081cf5134c50b8fc0dc", + "python/sglang/multimodal_gen/runtime/layers/lora/linear.py": "4864a0a17d3f3c1d2cfe68531867d07ce78dad05faec87a39226583c3e43899b", + "python/sglang/multimodal_gen/runtime/layers/mlp.py": "7592e9c7449b607040ff5c17aa78463d158f138944835f8ce26d94307cddee6c", + "python/sglang/multimodal_gen/runtime/layers/moe.py": "a12ec5824b9d17862fd4808f6c19ca6340c1bd7d4c61f61ed919ed82fccda1c1", + "python/sglang/multimodal_gen/runtime/layers/parallel_conv.py": "f9a95097322e80990009252953337d5dbe6a8ae5ff33eeb768e38bcb13b7b527", + "python/sglang/multimodal_gen/runtime/layers/quantization/__init__.py": "ef37cd8cd28bd5554e58f918f13883cf59b5408e110a6d798145432d5632a292", + "python/sglang/multimodal_gen/runtime/layers/quantization/bitsandbytes.py": "00c19985ebc02708d4f9354cd0754ccac13e09af4bbca86b90f47d0bd635ab48", + "python/sglang/multimodal_gen/runtime/layers/quantization/configs/base_config.py": "56c3943c380fbe0584c4f8bd75f51ad2e87605697200fceae944117cd34db9a5", + "python/sglang/multimodal_gen/runtime/layers/quantization/configs/nunchaku_config.py": "637d795cf3b26829373caeed22a7074fad44e331c952873676562e3905db83c2", + "python/sglang/multimodal_gen/runtime/layers/quantization/fp8.py": "a9f129870a6ba8a3ee1f86d53775f04a2fa27d736b713cc51bf42122e4928449", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelopt_fp8.py": "0779107406b1508912e6f3b854a81a4157fb85dde0a6f91f5ebcf1ed100949df", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelopt_quant.py": "1a76af8fce37bdd2521d24e82c54c695c064074efcc83c3e6cd03c90fc939cef", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelslim.py": "6c3aa92b21ffd8a734869ec87d2e5809f9e85d9b00942ae3a1e13b6d7bcb0d67", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelslim_mxfp4_scheme.py": "19c68dd5db6908eca3a733c73d1767707b132f8cfbc5b6a13e87caffd1c7c1f8", + "python/sglang/multimodal_gen/runtime/layers/quantization/modelslim_mxfp8_scheme.py": "0d6fc7dc42e3765f07acddbb9444306dfd7fb64b4f859056a0e5d2f52e828a94", + "python/sglang/multimodal_gen/runtime/layers/quantization/mxfp4.py": "a59f4917982c88acae54f2e91b49ac9def4d0966bb0dc905f78b4ffe595fdffc", + "python/sglang/multimodal_gen/runtime/layers/quantization/mxfp4_npu.py": "5f2368d00347d7af10608b41c3ca737f8410dc7b1f53b19f993779a8bb9ec5a2", + "python/sglang/multimodal_gen/runtime/layers/quantization/mxfp8_npu.py": "1ab8788677b8e3bf5a39f5ea4234280f4df7d38558656980cf55874ba2bdae06", + "python/sglang/multimodal_gen/runtime/layers/quantization/nunchaku_linear.py": "d252165ceccc0d8fe728df9eb5fb8e02091878ef5df53dccf0bb160af10eecfb", + "python/sglang/multimodal_gen/runtime/layers/quantization/weight_only_fp8.py": "b92ea052c6fe113857f36f50541b40d6430cddee997f1189df05857b230016e8", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/__init__.py": "9af17cee919e0f0afb621e8e880df502cb7160590fabffcca5b64ff7cbef7c7a", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/base.py": "b590ca6cd7dc2cfb54357a19d49910ec0d5d975ec49d0874d992829ffd3d477c", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/factory.py": "1101cdfff76713a140c9b106e18705b56b5058535ca767082890a946a1e6de38", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/mrope.py": "2ac0f8d13ea663303095f8ecdb3d7a1520ab851a3534d29cdd9370f5184bbc74", + "python/sglang/multimodal_gen/runtime/layers/rotary_embedding/utils.py": "7d05ab83063740a79559b411c07cd4f2191ee7a8952b5c8d6a73a5709b44a51b", + "python/sglang/multimodal_gen/runtime/layers/usp.py": "0ace6e1c70d7d5fe925ec44d903aafeefe96535ed8bb0e38b69da95ca116be82", + "python/sglang/multimodal_gen/runtime/layers/utils.py": "a2dbc990916cdaef054dd201c61301edaa738ba1d330ecc7caf2b42fb639ef5b", + "python/sglang/multimodal_gen/runtime/layers/visual_embedding.py": "d9da8fd38234c5f5deeca7d210d06aad7dc686c5e506212a60d65d0882dc88f1", + "python/sglang/multimodal_gen/runtime/layers/vocab_parallel_embedding.py": "9314f9ba2c7ef50bbc1a9e61037af62cf459a3963a7fd81db3de072b3e13e74d", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/adapter_loader.py": "a9dec97c947d5a7bce46526edd05863c32d5a5ce0dd44ac0cb955b9c8b94453a", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/bridge_loader.py": "6691b945a9d7f5f1dd5c8b391ccc63e5cb4507d923461bfa54530f1afa09d6c1", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/component_loader.py": "e0786c2eba8b48a1a6389bd4a246695b827ec9b1115579be9cc378135f2f367a", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/diffusion_decoder_loader.py": "3957341edec37d5787c3dd3b11d11a9927d449a7428e1c17193926c1a9be02df", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/image_encoder_loader.py": "1cd07a83cc47eec407a9d9210f0ec7dec50a2432710f62040a82f9a91b00c0b7", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/pe_loader.py": "a20bba36f057558380c1a1631391292959559558289f469e002cfe60d685e9c4", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/scheduler_loader.py": "aba7c83504f654bc3498e5820a5bda855d9aacfd3a83b667fe1c8bf29603497e", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/sound_tokenizer_loader.py": "b1937d0e7fc4f5ac68c6c7c3ef7acdb3b46fc980a4b714a4cb18f02f5b9ea533", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/text_encoder_loader.py": "4528730cb89f0a6ece895926e989274d8f82051f0dbf5bd64448446d344f42a2", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/transformer_loader.py": "ee3e50d928fa91be176223bb6fcc0e9c3a32b6a6e9414957086b718b88e6980a", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/upsampler_loader.py": "8535017e1755420fd95b0ce35af63514120fdf3259824063f5992b8e123cad27", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/vae_loader.py": "6df64e4d08020c4ff97880b18ab4183cc172e3a92638984b95d7cc746591ab78", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/vl_encoder_loader.py": "8c5d44a51e09e42047bf98eb09291136feaf912aadd96ee4d71dea1d590108d0", + "python/sglang/multimodal_gen/runtime/loader/component_loaders/vocoder_loader.py": "999209b8c2987270ec45fe0a601d96da6d476f6c6d834f328a763f132b22c6e0", + "python/sglang/multimodal_gen/runtime/loader/fsdp_load.py": "5f08113b54f234f30ab1db404b730b97b58fd7ffde0792ee718eb99edb995b0f", + "python/sglang/multimodal_gen/runtime/loader/rank_local_checkpoint.py": "69988377a57733cecfb8b5b96f7e6ab9d208797edd9d61d2040cad25abafbff6", + "python/sglang/multimodal_gen/runtime/loader/transformer_load_utils.py": "d33c27f94139267ab733d9de0a6565faa0c6fd4dd34c6ece02dcb470b4a816dc", + "python/sglang/multimodal_gen/runtime/loader/utils.py": "dc426ac72030a31df4be048a762220ff909f43ee59a8c4d94bbfb25faeac65b2", + "python/sglang/multimodal_gen/runtime/loader/weight_load_plan.py": "c0fdc358f9c86507c613a11afc8af2725a2964c0799d5de640c87979dde146e3", + "python/sglang/multimodal_gen/runtime/loader/weight_utils.py": "9ed60494b361302297ad3b5c316a99a16cd0a6e30ac5a5b2c99cc554caa442fd", + "python/sglang/multimodal_gen/runtime/managers/cpu_worker.py": "9129530d59c1e112c93984a80f74a2d241434e4e93ee88edb7812ff5768ef18a", + "python/sglang/multimodal_gen/runtime/managers/dynamic_batch_admission.py": "a67970658b01e97a07208ca732f57923a51a170322cc20c56d05c09b6f136bff", + "python/sglang/multimodal_gen/runtime/managers/forward_context.py": "ec1d8deb655cbfd5d35a0cb5512728cab8a3290c92e81cb914453f855b7f53d0", + "python/sglang/multimodal_gen/runtime/managers/gpu_worker.py": "9360c8683df090e312e73b9fba6daf7fbceac0e64038f23ddb9050496b4e073e", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_loading_order.py": "b9475e14187a68a31d2788a4dbe9a169ae50dc0456191a3606fa066c6aa497c8", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_manager.py": "723abea1ae61d23b5e6af1819e7b582482a24f9900f83166a5b99c97331057dd", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_residency.py": "cd2cb0842d59f1e8b49325affca4e5d01551358d93c2afe6e19677b35ae1fc52", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/component_residency_strategies.py": "a541de018df77e94511bab2b758b657c47de114dcddb28a106726bf449ef25ad", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/layerwise_offload.py": "ddbea630f8eb6762a5107c2858003a1070f78f5d5618383bc2a87a8ca2070c47", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/layerwise_offload_components.py": "41ffa59ce3b01c95257dc6755a0dc0ec1a52c12378b349cff6ebe64b3dd68db9", + "python/sglang/multimodal_gen/runtime/managers/memory_managers/memory_occupation_controller.py": "a21bb65a9167df86b02a4513c9ecf6cae1bd0b2d74941585961d2c7d833e642a", + "python/sglang/multimodal_gen/runtime/managers/scheduler.py": "5941b8bf6b8bccdc90bb7b53ad506215a8eb8eafe4bb4fd96b1e835191616424", + "python/sglang/multimodal_gen/runtime/models/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/models/adapter/ltx_2_connector.py": "710f57417f28eb4a343b598436de4916206ea5f5ee923a103cca4553edc06452", + "python/sglang/multimodal_gen/runtime/models/adapter/ltx_2_duration_head.py": "b6410dbee092def590e27c24148d165dc37af5b7160f139b275ed1d38346e5f5", + "python/sglang/multimodal_gen/runtime/models/bridges/__init__.py": "a4752c5a87fe7199c2f200a41bf6beaed51103fb0c8bb220587945f8332b82e1", + "python/sglang/multimodal_gen/runtime/models/bridges/mova_dual_tower.py": "2d863267a53296ccab8b70639e38743d6825a929cdbb3eb9a3f8ec4b8127f49a", + "python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py": "09bfa5b29d65481cab0f73148a0b93e150d44915d6bb78a67127ee476e6a553c", + "python/sglang/multimodal_gen/runtime/models/dits/base.py": "a2b301251870b280b084e397c971cc943c366fa419d058ede417468a8ef0a22a", + "python/sglang/multimodal_gen/runtime/models/dits/causal_wanvideo.py": "3689266cadd01628396e31113158061fd44679415812c60e52b006ec574adf4c", + "python/sglang/multimodal_gen/runtime/models/dits/common.py": "ff49004f0cd0e2554a0d3cd20eef5fe781e12cea9bca1e6fb560bc07aaedb6aa", + "python/sglang/multimodal_gen/runtime/models/dits/cosmos3video.py": "4080aa3de0d00bdc084336cad6d2cef6cd729d537559ffe596f40aa8c6418e56", + "python/sglang/multimodal_gen/runtime/models/dits/ernie_image.py": "dce5f7a888245a70d1a2d7e95e2cdc094e7558f05aa26effd9b1063ba3e5ec8e", + "python/sglang/multimodal_gen/runtime/models/dits/flux.py": "bd54b552882016cd03762d5616f1b69b69c103b9c6259c397bd652dad04fe572", + "python/sglang/multimodal_gen/runtime/models/dits/flux_2.py": "a47e92a208084baf1884f87447361b3992cd3f7f01559482a68d70f64db44c80", + "python/sglang/multimodal_gen/runtime/models/dits/glm_image.py": "2cb1e8b15a8c2b8d127cab6d697aebc7e3fc3899944daa2cd7b5b87e3d30950c", + "python/sglang/multimodal_gen/runtime/models/dits/helios.py": "88b1db03ec90430f6f95c8ddd1bb5985fe6e0c5166f111cc7d8d2c24446a770c", + "python/sglang/multimodal_gen/runtime/models/dits/hunyuan3d.py": "2b6b93a40f98e6451ffcc91d15526a4c52eb98e57df8e203783c778a158d755a", + "python/sglang/multimodal_gen/runtime/models/dits/hunyuan3d_paint.py": "6459c735a0b1f8d857a9b92aa76c33bc6c6fb391b5a5efd07453b5263ecff8a8", + "python/sglang/multimodal_gen/runtime/models/dits/hunyuanvideo.py": "1a688c928e44e335ca7979e41d96fa41dd84fd44a378b24a4c9c1513ee024186", + "python/sglang/multimodal_gen/runtime/models/dits/ideogram.py": "fb4c039364b191663b4f71ffb11682b044ac67b04f8a2e184f59f70b5222f345", + "python/sglang/multimodal_gen/runtime/models/dits/joy_image.py": "abb18fdc282f7d671784c47275fae907a6a5bc3f3e6a74348bc131609d4001ac", + "python/sglang/multimodal_gen/runtime/models/dits/krea2.py": "b94f77b11e881bd4b9e910f7cf58f42d0c2e310e3e8493f2b320a5b1691ac6e5", + "python/sglang/multimodal_gen/runtime/models/dits/lingbot_video_moe.py": "20cf369807ed2c7c3815ad9160d601dc598ade9f6ddf2fd8fb875d21c89f706e", + "python/sglang/multimodal_gen/runtime/models/dits/lingbot_world.py": "c5d9d06cef80d52fe7e0439a9dcb018e30ed39d08d08b5e903b215c1810aa919", + "python/sglang/multimodal_gen/runtime/models/dits/longcat_image.py": "a4ebf8515b0a339ba7b8dc62ff4f2943819d623d0cd761e3280889c562dc29f3", + "python/sglang/multimodal_gen/runtime/models/dits/longlive2.py": "5c1e10078bee0e9653e954e918c28ed94e1060e322b4d5ae8a657f95e93b1727", + "python/sglang/multimodal_gen/runtime/models/dits/ltx_2.py": "0c70037aa7038466fd8d2917868378c44c0cc0a907ab6a054bf558a0c58f4ea6", + "python/sglang/multimodal_gen/runtime/models/dits/minimax_h3.py": "51ed02981c04e53ff72302a9d1dca03f9957e28032c96fca7bd92987abe1ac64", + "python/sglang/multimodal_gen/runtime/models/dits/mova_audio_dit.py": "777055d2c2f37b247a30c086db7e6baab066f106b38c2cc7ab4c431835048197", + "python/sglang/multimodal_gen/runtime/models/dits/mova_video_dit.py": "c579c625265bf38cecba49f2aea2a11a924bce2d741a4059cf96a48ae2206632", + "python/sglang/multimodal_gen/runtime/models/dits/qwen_image.py": "917b33ca0b65a60eb1d0e6a7fd25fdba9b37363b648ea1afe6987f922f7b2f6d", + "python/sglang/multimodal_gen/runtime/models/dits/sana.py": "65d8daddf53d76ae011070d3c03e52c934baa99ae89d7522e40be9ab29aac290", + "python/sglang/multimodal_gen/runtime/models/dits/sana_video.py": "53c0da351d964acb5cd9db5e9dc8318929c1ed0e05c49c565113b2c0694b1e0b", + "python/sglang/multimodal_gen/runtime/models/dits/sana_wm.py": "0fe643a28ea0c79a4b3304f6a8a5db9a6a61ee82b56a6897196f64b0d6dbc33d", + "python/sglang/multimodal_gen/runtime/models/dits/sana_wm_components.py": "ae1a2a84d01f9faa9fcb05a617fda7da096b441617906c3575f4fbcf42c15830", + "python/sglang/multimodal_gen/runtime/models/dits/sana_wm_refiner_transformer.py": "5e196be390a04c772dbed3b87a18dbc3064a5a5f4aa5ab6607a00463b859ac82", + "python/sglang/multimodal_gen/runtime/models/dits/stable_diffusion.py": "cb909dc609c8702988e3a15819df0ad2d442ca710d9db239c15bf87ec730fd68", + "python/sglang/multimodal_gen/runtime/models/dits/stablediffusion3.py": "5a4f9fdfddc5f2ba63459ac24208b5749e766220d9aefc2ba4ccbe7f2c2796e2", + "python/sglang/multimodal_gen/runtime/models/dits/wanvideo.py": "aefcde8becfd2d74903677bfbed25584b56ecf5de5e2a076134f38dcb6a667ef", + "python/sglang/multimodal_gen/runtime/models/dits/zimage.py": "d9edb95f3aa774f2c6a366e4748d0381a9df86d1dd7d462e865d073155feb519", + "python/sglang/multimodal_gen/runtime/models/encoders/base.py": "f51334e5f2bb3b7656895698681d6bb98afedbcdeb97e4ad1a9e0558a26408ab", + "python/sglang/multimodal_gen/runtime/models/encoders/clip.py": "1458c21535566211fafeaba75349cd79a50998935b63daf878c1867bd09d6e1f", + "python/sglang/multimodal_gen/runtime/models/encoders/gemma2.py": "dc1f2c13ef034da1548cdc388aabb1237bb5a4b7828457f8a5bf3a413fe4e4bc", + "python/sglang/multimodal_gen/runtime/models/encoders/gemma_3.py": "aa056089c52ce99ce8f295fe32075cbaa35ddc33809ffdedac30ca0041404ac0", + "python/sglang/multimodal_gen/runtime/models/encoders/hunyuan3d.py": "89a92d6a3069869bcd5b359250dd766e3a9604e6722c917d90d7652b2dfc47f4", + "python/sglang/multimodal_gen/runtime/models/encoders/ideogram.py": "c1cd89f67bcafed9e2ab898d23dced908d0ed29b9c10107d0a1468eb421caed3", + "python/sglang/multimodal_gen/runtime/models/encoders/llama.py": "8a7cc03778cdf5a2fd55a0be58dda4e25ddfd28aba07f4224ed0368a8d6cec85", + "python/sglang/multimodal_gen/runtime/models/encoders/minimax_h3_qwen3vl.py": "bfa90ff49574e0274603d8a4e276b8c1095914234faf212469702ae0d5485982", + "python/sglang/multimodal_gen/runtime/models/encoders/mistral_3.py": "1896da5c12f01c97debe8939eaf5bffc25a091203211969c5f3f20c350f76897", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen2_5vl.py": "7aed7402b44d4f9b966b39329a4bffd838bb3a6bebf876b51eb9e3101db50cb6", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen2_5vl_vision.py": "d6fbc38058dbebaf73023f38978dd94176ef800923b30af6b93140b912ed674f", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen3.py": "54e36f7b16ca68cfeeb93623501e2ded8126e429448698b8868b5b1b6c9ca55c", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen3vl.py": "6c2945e4afe9f44ebb054e99f66ac624610ce9d5e1d92f5f8a02abb4309408dd", + "python/sglang/multimodal_gen/runtime/models/encoders/qwen3vl_vision.py": "98aa9d4663426875b03127b9356e80b75d3c4eb1ff30fbfd52cdb07a4ab4a320", + "python/sglang/multimodal_gen/runtime/models/encoders/t5.py": "c40c16f5a23af923ba4f2aeb64fb7ec5db22cf537045fb323598846ac1ed0663", + "python/sglang/multimodal_gen/runtime/models/encoders/vision.py": "6a7d468c627b9723bf96345ee0cbb71089bf1114125aabcfcee785394fc8e2f6", + "python/sglang/multimodal_gen/runtime/models/parameter.py": "f0b76b8dd38967cac143f09fceb77759c13327c554ecc3721b71b1f7daf8dbc9", + "python/sglang/multimodal_gen/runtime/models/registry.py": "1db4e7402886571d1d2af74c47ca5f1f5eeafd33959e1faf6915536c5e877a97", + "python/sglang/multimodal_gen/runtime/models/schedulers/base.py": "91d08fbcf1717486863cc97c41aa3fe5a97f6254d0802cf8830b54c1ed530f60", + "python/sglang/multimodal_gen/runtime/models/schedulers/flow_match_pair.py": "0521c03ccd1c3b7b8c5d8d48365dfbcff6a6e6f465bc362fd9d6eb904759529c", + "python/sglang/multimodal_gen/runtime/models/schedulers/hunyuan3d_scheduler.py": "d8324bc70fef5d52f98604bbedabb492169daf4c41af1f085e46edb4cb76e8fe", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_comfyui_passthrough.py": "77401a8fff0a32cd1d8381c5219b194bf2d759c07881260fc70af4e6395b77ba", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_dpm_solver_multistep.py": "b51713e95535d2742bcd0248ea6880ca754d37ebbea37214136e7d91ec3c7755", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_flow_match_euler_discrete.py": "21d11e8b896f3f49973abc58e0dcab0bb342e9704282efa14c7b296fc0cf414b", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_flow_unipc_multistep.py": "c5993235bfebe894389d4b266a7f1b76b67c2506f34c05ed86c39c9087104d00", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_helios.py": "01b67c8ccc4ef199bb719e03c2e061e7c9e8a7e296270486eb027ade3ebd1a79", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_minimax_h3_euler_ancestral.py": "fbdb7faf8c3b29d5768562d523ad8a87ed4644ea7f322824dae7f9e246a661f4", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_self_forcing_flow_match.py": "872b8b9aa374f21841494ceba95add3637269821a0918bb8a4a57eddb954a4a5", + "python/sglang/multimodal_gen/runtime/models/schedulers/scheduling_unipc_multistep.py": "0239fa71456f0c80de99c83e6647e636a87287f1a68ef5185b47f1abbcb34e21", + "python/sglang/multimodal_gen/runtime/models/upsampler/__init__.py": "0cc18dc2663e115ac8b0934233260bd590df8d891bd48678188ebf7bdc1ef0fc", + "python/sglang/multimodal_gen/runtime/models/upsampler/latent_upsampler.py": "8a5007c84f245bb1a0080c565ff2c63404265432538a9ef10bb8115f4820ea9d", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder.py": "68bcdac692075fe5ce2303589fedb01d11cbb5ec47951e182af3944a0055d676", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder_dc.py": "297f9a3feb07ba887c111c56a3d1898d987fcb3066fd98efdeac6df1ff7a1aaa", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder_kl_flux2.py": "de46376e143caf2e00558c9743d5210e6be134a984c93a6f033caa926df9b896", + "python/sglang/multimodal_gen/runtime/models/vaes/autoencoder_kl_qwenimage.py": "1c61768b7218898b82a3a1921edbe82afe9455398bf8fad2ade196a57edffef4", + "python/sglang/multimodal_gen/runtime/models/vaes/common.py": "3226ddddbd99df8753739eea8d5f60a555a9c000c8108244f042f56a39b6f386", + "python/sglang/multimodal_gen/runtime/models/vaes/cosmos3_avae.py": "070f26818115908d537c16a02c069fced80168214ee74e7b5c71c3b879a23bc0", + "python/sglang/multimodal_gen/runtime/models/vaes/dac.py": "df0998731a1d40093a8e61d294ddcf45db21e5ca41310d9f09ef6ee955180827", + "python/sglang/multimodal_gen/runtime/models/vaes/fast_path_gate.py": "e6ab5ac51af6ed16a22cb6c8e700c56175fc628abf6b966ea5d6f1a29cf974a6", + "python/sglang/multimodal_gen/runtime/models/vaes/flux2_vae_cuda_opt.py": "0bcf90fa9b7eed89ebd546b2e000d720d7b7347e3f83e6c9ae52b5c2479c6823", + "python/sglang/multimodal_gen/runtime/models/vaes/hunyuan3d_vae.py": "9d9df7a0ade8810005380cf80c568f1de22de6ff934e955b2e9119b3c13e94cb", + "python/sglang/multimodal_gen/runtime/models/vaes/hunyuanvae.py": "4f0622e3eb8704cad079e840581eec94a3ca185b08a4cab021adc896994de69e", + "python/sglang/multimodal_gen/runtime/models/vaes/ltx_2_3_condition_encoder.py": "a14a1bc3a6a2e5ddb6daf9404f4927aa4c18555eff688a84407bd8c0b63a550b", + "python/sglang/multimodal_gen/runtime/models/vaes/ltx_2_audio.py": "b9df1d6f0500d35c726229694bef284518140b9fe87f4d9a83fdfdb97107ebb3", + "python/sglang/multimodal_gen/runtime/models/vaes/ltx_2_vae.py": "2b9919336dd8930bf827b3c2903a28ce2e5c8ae456a2c2f0493f1ec49c98012f", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3.py": "72b08543587f41a359242ff49b2b34bba6f69dc5595524bd7b823c1b3eaabc09", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/__init__.py": "89480a39dda098dc895d950f6b1c0607cc61b2ebdf42f6f7329e44aa587a751f", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/alias_free.py": "40d8899a8e345fac07b970b1d26844f9a94f59bf474931a3f5446e3f4a1f6a2a", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/audio_vae.py": "8bbac65410bea451e76c98705f565d884e8fe5008b5b4873a31fc466930d5969", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_audio_vae/bigvgan.py": "08be3944c69d68917f700e24425c59aa776dc14f422e69f0be58f7026cbd4af1", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/__init__.py": "e6796d027b97366ff48eeff25bfd04e31c4fd4a4f4b5f4ee4b740b9166a8068b", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/attention.py": "4a5fc609c226c50be275cde8d8301d3973a67e94f71896e43411c2d7f8780999", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/base_module.py": "50a9a75b936b40308189515076b1208fc1fc2c6b342082fb71ad0eb40a98fb0b", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/conv.py": "587259d276178f64b2f9002a6cd82e19f547e20deb54bc8e3fd7e2a4c5f030e4", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/klvae.py": "4e855a369668e951751484d63801f4ce74e35b664a63d5e6270261e4c2073e8d", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/norm.py": "efd4e3f61c9381489e2926947981c24c471f6a16e7c08156f6d01c7dc4221698", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/processor.py": "d1fbb4f3125c79e1564b21392d67e7101762a53121268ccb82d8092a878488d1", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/vae_cnn.py": "792ee2176878d0f8b64b42d7ec63a927509dddf6ad864771d43a744981de13eb", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/vae_vit.py": "7eea59b9f87559e0309f4708d52398c987294cef757e729ff825fa0ebe904977", + "python/sglang/multimodal_gen/runtime/models/vaes/minimax_h3_video_vae/vit_utils.py": "1709aa4cd8a3ce911f317f58ea326de9aa63ef733b5387b1a77864b3e24f7a6c", + "python/sglang/multimodal_gen/runtime/models/vaes/parallel/diffusers_spatial.py": "ab25a8a2eddb90f7a3b9c341169f7ed3edd8eb26dc14ad95430fe6585a05aa7a", + "python/sglang/multimodal_gen/runtime/models/vaes/wan_vae_cuda_opt.py": "e866f38ea36176e1b7bf6cce547ca2076f69606742f5cfad3ff05661538564a6", + "python/sglang/multimodal_gen/runtime/models/vaes/wanvae.py": "e7ea14d19146d4455c4a2f30e512c8cb9d81523f7ee8eed80de5c6f45e41b48e", + "python/sglang/multimodal_gen/runtime/models/vlas/__init__.py": "94a562aee42ecb588af893eee9528bb565336d3b5049142403eeabf1d2a8f068", + "python/sglang/multimodal_gen/runtime/models/vlas/pi05_core.py": "09f4a75d1ae50f60f60025a48dcf89841cc7c69846380cc2f2f48aacc67fec08", + "python/sglang/multimodal_gen/runtime/models/vlas/pi05_policy.py": "3be6ce3afe0d372fe6a39a576aa6988832a8c34eb5e50c2a8f124a8ed9a8d1fb", + "python/sglang/multimodal_gen/runtime/models/vocoder/ltx_2_vocoder.py": "443feb40733b76ea7d3c14acc6cc08e60ee6c8feaa7e9190d930d6adcb12e239", + "python/sglang/multimodal_gen/runtime/pipelines/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/runtime/pipelines/comfyui_flux_pipeline.py": "9beeb875241f9bf039adff48a877094d4311ebd8d98902a6b59b7dd79470cb06", + "python/sglang/multimodal_gen/runtime/pipelines/comfyui_qwen_image_pipeline.py": "ef7e2eb33a6c4b226dc0ee7a79176ef809e617e6e5e90ca8f1e85e9e9df74984", + "python/sglang/multimodal_gen/runtime/pipelines/comfyui_zimage_pipeline.py": "1bc6d205ebda69464fd0548a7f9d30b22cf8115a857a9b39520f53cfc024fb81", + "python/sglang/multimodal_gen/runtime/pipelines/cosmos3_pipeline.py": "a51e9b1060fdbcc8aa8938ccdc184485070284434ba048d554e25ce5aaf294c1", + "python/sglang/multimodal_gen/runtime/pipelines/diffusers_pipeline.py": "d227b82d195936f9efb550683ab2af59e44e453b51716c847d1012f8aaadc187", + "python/sglang/multimodal_gen/runtime/pipelines/ernie_image.py": "e4463bee580d472ae31077d8ffe2be3363bae4e924000eebf08a393dd011902d", + "python/sglang/multimodal_gen/runtime/pipelines/flux.py": "a548029fb75faa7a638b9bac33f1c7153c19a5385525762ae10a0cc50f1f6977", + "python/sglang/multimodal_gen/runtime/pipelines/flux_2.py": "51af080813cc0f667d874d9b255cb519c5fc66bde06138131948bfbc7ac534b1", + "python/sglang/multimodal_gen/runtime/pipelines/flux_2_klein.py": "03bab0d7a6572b29fb203f2aa41140a54f77fb3e3ff90489401cd5a90933fd58", + "python/sglang/multimodal_gen/runtime/pipelines/flux_2_nvfp4.py": "dd93b28b5dde6f54ede886801f15a02366d0fe63a3a320298322c84ee8e9055d", + "python/sglang/multimodal_gen/runtime/pipelines/glm_image.py": "a217b6a4dac5f5fd019dc29e1868ddc7a305458aa3e664cc8002b4613630aa7b", + "python/sglang/multimodal_gen/runtime/pipelines/helios_pipeline.py": "877431bbc32af7f505e9a66f294527da9f0c68747ab7679d6a1ef832cfae01d5", + "python/sglang/multimodal_gen/runtime/pipelines/hunyuan3d_pipeline.py": "904af91f67269d4dc42cd288d017a1df50946cad50575aa09b7f1c5261a3329d", + "python/sglang/multimodal_gen/runtime/pipelines/hunyuan_pipeline.py": "4c158534ccbe998b01cd8677c2853b4273a7db4a900b288752d2f8e519922dbd", + "python/sglang/multimodal_gen/runtime/pipelines/ideogram.py": "632a931e1f13a3f1a33797bfd035b070c30e5550b567f63d0101d7e6511c4ef9", + "python/sglang/multimodal_gen/runtime/pipelines/joy_echo_pipeline.py": "97af44fc188a60095195ef2534f11c03815176351fbf9df75d8328ac4b4ef8dc", + "python/sglang/multimodal_gen/runtime/pipelines/joy_image.py": "48f87dd0b95933c15c411df6bfaf99ddfe489c8e7ebdf7754f47d91f9a1ef2ec", + "python/sglang/multimodal_gen/runtime/pipelines/krea2.py": "96cd5d14224a3f46169679ffbeb2c2ec366519d64df6f99c63f8178f579fff12", + "python/sglang/multimodal_gen/runtime/pipelines/lingbot_video_moe.py": "1315c3d65ad0c2f76931ffbbc35b3d4ea02fabdb45be5dd7df63dbfafdd0db7c", + "python/sglang/multimodal_gen/runtime/pipelines/lingbot_world_causal_dmd_pipeline.py": "ddd7b330f42392d0e66882f222d0fe8787aa978fcdcca48caa137099bce716b3", + "python/sglang/multimodal_gen/runtime/pipelines/longcat_image.py": "a21cad85cbc1a589d7a6a2626444e07febdbf50d7c2ee39a3352f88c02791d63", + "python/sglang/multimodal_gen/runtime/pipelines/longlive2_pipeline.py": "545338044488b1525f3b2f75ec7bdcca819541cd42ee84d4d1efe7aababa6141", + "python/sglang/multimodal_gen/runtime/pipelines/ltx_2_pipeline.py": "be45a325b798ab1283861da8529cfcc863cccb5e66475f8d0c76a3a9fe5c1648", + "python/sglang/multimodal_gen/runtime/pipelines/minimax_h3_pipeline.py": "df9e4a8821d494ceb2ab9bcc9961267a0d5e904785d04e7408e2e35e837d7d5a", + "python/sglang/multimodal_gen/runtime/pipelines/mova_pipeline.py": "6e830f3f3f7f33a01f964f486bc94682c3f1579700ab6186613deec7da98de85", + "python/sglang/multimodal_gen/runtime/pipelines/pi05.py": "c63ccc8decb441e1787fc303302399c7c659b760aacd1b86cc9c90805161d044", + "python/sglang/multimodal_gen/runtime/pipelines/qwen_image.py": "3dc4c341833d90bddf3632f3d7efacbbbc56f678bc5abe57b46387659398a727", + "python/sglang/multimodal_gen/runtime/pipelines/sana.py": "75c789f401fc04e031185cf267a95d212f7c8ef7fad1c9baf6aebd317a58359e", + "python/sglang/multimodal_gen/runtime/pipelines/sana_video.py": "33bc780a46275475cc9fa63769cdfb8bccfd43f62acad3d08ecb8fb15a392ca6", + "python/sglang/multimodal_gen/runtime/pipelines/sana_wm_pipeline.py": "efd5775c75494a02226fe0f2120c648a3c71b8db991fedeb146fcd1dd827ef15", + "python/sglang/multimodal_gen/runtime/pipelines/sana_wm_realtime_pipeline.py": "a70910d5e11b17b850d4b706cdfff5663052de6e934e1cc12e099bb96a6525fa", + "python/sglang/multimodal_gen/runtime/pipelines/stable_diffusion_3.py": "73ad4dfe624e7622bebdda2c7900c08140ae0ae7dd01f8139f32d5a418794242", + "python/sglang/multimodal_gen/runtime/pipelines/wan_causal_dmd_pipeline.py": "b6dddbb4274c0d03bf5a29f0b93c0d4a3709c11d798e5c01266d5d395e7b1401", + "python/sglang/multimodal_gen/runtime/pipelines/wan_dmd_pipeline.py": "bcd1e9bf7bbc44fefc8836f67c4074f4eaad1de9d51b75943a3620d76b74227d", + "python/sglang/multimodal_gen/runtime/pipelines/wan_i2v_dmd_pipeline.py": "eff86c1eb694e6c6df56d5bb7ed18214f26525d66363a2d3fd93f9f8eaa00e5f", + "python/sglang/multimodal_gen/runtime/pipelines/wan_i2v_pipeline.py": "33eb376b983824ff5ea9a7200d47b9d6414c9b030e0efa734de0096ca5e02b83", + "python/sglang/multimodal_gen/runtime/pipelines/wan_pipeline.py": "8deec56d8aff8307e51a601caf52fec92e888aff38e4203940a8f9afd09eaed3", + "python/sglang/multimodal_gen/runtime/pipelines/zimage_pipeline.py": "9a916192482a2ead84aec5e26074c119986c49b5cf5fc04556824f5f07558fa7", + "python/sglang/multimodal_gen/runtime/pipelines_core/__init__.py": "7a915dad966148fac6ba6ef0e8a2ea7b8ab24364ad798651fde34e36105bb686", + "python/sglang/multimodal_gen/runtime/pipelines_core/composed_pipeline_base.py": "adeed9abfedb8aa03eabb6e7c17e1be4677d8fa8c3c07c97da0041c50545b15b", + "python/sglang/multimodal_gen/runtime/pipelines_core/diffusion_scheduler_utils.py": "4441eb11d7d9bd216abf4f092ae50e7e88c571600cd3f261ae638198d9d723dd", + "python/sglang/multimodal_gen/runtime/pipelines_core/executors/parallel_executor.py": "4e2279809f573c2bc97a7282aa19aeaaa904907d87c40965c440e64ec4a20c1f", + "python/sglang/multimodal_gen/runtime/pipelines_core/executors/pipeline_executor.py": "a611faa15b912209cdc31bf6e53e2f25c8921e161767d2a60108825b4de5c38b", + "python/sglang/multimodal_gen/runtime/pipelines_core/executors/sync_executor.py": "7b56b40f7a16f7668a046b7bf7cb5fede338865e9fab9e93ed6505ce4f365df5", + "python/sglang/multimodal_gen/runtime/pipelines_core/lora_format_adapter.py": "bd9cbafe43b461ce72f8c23916af0c225d8b93b6e8ed971ba7b9050da91b8b76", + "python/sglang/multimodal_gen/runtime/pipelines_core/lora_pipeline.py": "795b5e5643c5f409ac4d3c5ca9ecb949e0306624c9530a1889075e19ede4d9b6", + "python/sglang/multimodal_gen/runtime/pipelines_core/schedule_batch.py": "1f0316c81a5e78bcf4e517b9ebdf112781a0457795edb624acebcebff8104a01", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/__init__.py": "c625f68f3e66d4fb3c67cb61938e249c78d91ce8d0a0511d48f72d9ca275da0b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/base.py": "f241b98bdc302cd5166c865aab43578ab7bdb0192fedec9e3d72fa927b159c90", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/causal_denoising.py": "a9288d122f3570db0c1830479a11dcab45b81c54a3eef3af3ccabdb787bed7e5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/comfyui_latent_preparation.py": "2dda6124c913c7c136795f00f87291dbd2d26b1ff9d0a5aade1595c5dc1c1bc4", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/condition_encoding.py": "4e4ec28b2f34dbeb1b55a33bb03b271426882e2f45956af85553e67ecc71ab13", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/decoding.py": "366f19a971272faecd7593959252738255be7cd511844589622ccab1d8d56b7d", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/dedup.py": "74e5599aafc01f380a362135518a0738a818bf36f743beecc660065a6d4261db", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/denoising.py": "eddf4b7c56f8327dd32b3bae96f4c4bfc00a2a2c3130d51f8493457ea89af886", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/denoising_dmd.py": "2cabac8977c3cd85cb01e8115a06e289cbcdc50710c4a1b65b30905723ffa910", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/encoding.py": "c5b05e6fb51f89b9acc9bb8c3550b7a74d7d99160ea8159c9c19ee8d008defff", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/image_encoding.py": "0399e820f586e01b02ce7691c0e35787b70d8d945cf6f87688ff60254369bf1b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/input_validation.py": "98fbfba3712ab1c02693f45a8deb9be6deff5ac7fc69a55613e53cd271cc6ba5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/latent_preparation.py": "4a3e4e5969e6d5a94b3a7ab31e9d3ad41c115baa8578130a3c67c8f9f1fa8064", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/__init__.py": "ebd231430fdad47b9245706acb16104c53254e70509649f253b659be62f413d7", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/cosmos3.py": "9ca060ddc6dcf5a1b0c03d78bbcd05ac143b6ecd628d110b945a82dbe0e5542a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/cosmos3_action.py": "4cc1f9f7782b1c7e067f16abd42f30678a10c9e50ef3c74844733aaca22291d2", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/cosmos3_guardrails.py": "7f7287f0bae16ea441ca55f14973cffeeac9766f9721485cda2e937e34f94af5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ernie_image_pe.py": "97104d1be95cdcdda1f474eb9a02888fbd08779edb62ca62efc0c7725495dfdf", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/glm_image.py": "b9e09a44cadf9a21eda5e620db33a73d40fa3adde7a93351802d95ada27ec600", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/helios_decoding.py": "858260a1493175f56808a1de788da255469a4bd5db49ddc9366b172c7da4e448", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/helios_denoising.py": "e07ba169836ed182d502cb011e56543beba751f5baf40155dfc1211ee78b2f8c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/hunyuan3d/__init__.py": "f40587c9be218a7ccde841bc977de8d85c5e5b55c949a0d5e81c659488e67e13", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/hunyuan3d/paint.py": "bd40ee8797df95d2a58bf1cbd0108e7ef8f13222a9142b20f9c828d691d3c58f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/hunyuan3d/shape.py": "6a2104cc36081c94280333ec46052e4d0dc3b1237c3031ad3d3b67ba01448656", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ideogram.py": "df557487a415bbe227954a178c395c26fb99e102d72862d9d7dfa397b914ba9a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/__init__.py": "de8741eeb8db145fc04d02006b4a1cb2832f36187f7efb0612bb0b879a010347", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/denoising.py": "c634d859385927f4a4d02aeb88c03f53172202a290a71c76aa10c13d9b24b0cf", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/memory.py": "0fa134d57ed89a80b2495c682fbebf1a8a67fa527df9830bca0026f1251c1f4a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/joy_echo/setup.py": "7439f7996d73d6fd0760b27193676ff202de33ed632e73278ccc788d63a8f306", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/krea2.py": "b95b1aafeca065e81d7815f8e6ff37ab492ab49ba063c942d24a0535d5cd5ccb", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_video_moe/__init__.py": "f2a03b7a4cc32cc59d40d805052c29d18d090ef9c7d8d6fc5f58d74f4734c5a8", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_video_moe/text_encoding.py": "8110862fd7037db5bb7606fd403d4b557bd7772d09481bdf916b716a230c3153", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_world/__init__.py": "ee72d57db58de7d21d89553c80e262f3a3fe18a0dfad92085891838e191bd5ea", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_world/constants.py": "295fbcdd46ec9bfe7b8a2994c67ddcc66ad42a1441e9c0cab4f13dfdb059f326", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/lingbot_world/lingbot_world_causal_denoising.py": "d1dfc2f4901d31e6678152ba7f18105f15846b861a2068757372d73c45c5845f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/longcat_image.py": "f49d8ebea3a51c5970870c6bc093bf95586ddfb8338d96104ba58178f9eb6795", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/longlive2.py": "33512ab40646e6e517c82e99e8516d6608b26fd637539dc4e33e869d52e088b7", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/__init__.py": "4948a3b70126453c1dd13d3e2bfb29a31db3c84fb2bac601430363f2dfd7726a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/decoding_av.py": "0977369c7cd77b1e3c1c5251899d1f077153c7a91e46130a960aad76094acb6c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/denoising.py": "82ac9294fda80ceb56f7586e39b14cf92a04505911a5c70904fa7006c3ac0a16", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/denoising_av.py": "cf7db0a4378df0b3baa733924ff6b1af21688d65ceb3210295604b5a704b1c69", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/duration.py": "cb606e0b84ee08bd076de6c9786edf7098e7e45bd0449d5ea56e31f7026cf54a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/latent_preparation_av.py": "22f195152cb797198c270715ae168272d07d21fdf81b722cd44d493c2c365057", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/text_connector.py": "f45e4246aff0bebc5755940d00523538fdf94d32dcf8af9cf7bf2444accfd7fc", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/ltx_2/upsampling.py": "33284244363812abb74dafd626c27d8f2e4a5cda692190355a353551a6f77204", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/__init__.py": "763487795767fdf28fed18a6cd8f020fbf0647b6f8ecbde8dbf8c518cc19bafe", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/canvas.py": "e3b8513260bbe1d1d15cf8835f0146d9e958f4a6950826c30df23ded8d22d892", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/condition_noise.py": "4e2a4046ec6b3899e474a3352ef73c480d57e104f242c1e06c4819b2d1a221e6", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/constants.py": "583e94f14e3de084046af5218ed6456d1122d5e6051062d1372b35657235cabf", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/denoise_loop.py": "af19fcd37935da6193dc1329410edbdfaef25ca763db316f40bbc46fb6a48ba5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/keyframe_encoding.py": "c8aeeffcb0045402ce11dd3eed156df9188729e6bfee92f6a49ee95d27e93bec", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/material_io.py": "d75427ecbcf227a61f140ae45eccc73e30d001be0e70e90b6d2ca76bc8b4868e", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/packed_sequence.py": "8428954a3998429ff565b6a06e0c678ce0dd1b35ccf0492b26dbbee512f80a99", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/packed_tokens.py": "5441c9c3eb183a7694902f093c0ec5c9ffcf4351b4f8c64011cc75a85aff29da", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/prequeue.py": "91652d61cf0a7c552ccf166cbfcb9877f6f2ef2186ff078dd0b4b9fa105db4c1", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/presentation.py": "7c8e4d4a22c0933be79196b1c6b446191d020b55ba7de87be2781e81fd838f00", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/reference_encoding.py": "d0c8ae24984618c3f8b1f5a0eafdb077777784c1b94437c1f5e90b3e1e13a3e9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/release_metadata.py": "006910e9437a7250a7c72c7e7e1029e0b6a5e1a4be1a471fdf6c8fc199f2885f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/request_validation.py": "6fb8c16f336b24d9bd5abb52a7a1b822885b53fcb8a6d6398262718b62a99433", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/resolved_plan.py": "03d85dfb8819f6c52e6cc1a779adf9b515618f4dc6c97705b517d93ae972fad9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/__init__.py": "e0e3946d1e14a6190032baf047f920efc9cdd428efcd350bf9b58ba7ad7677aa", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/audio_encoding.py": "d50ee17293a1ac07e253ad259cc728f023c77ef56aac45289d4be057247f373f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/decoding.py": "a1ea299b0430c54ff0c7b26a338c168cc7ee9996fe748b08a2f73579728a7507", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/denoising.py": "c812008e49e42b762c1cea6f72e1df89574e905ee4de737f606afa205a0e8fec", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/latent_preparation.py": "8eef36d7a41665b80550c75a93566dddabf0ea3f15c6f66c3ed41262c135b368", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/replica_broadcast.py": "8c249dd8a295e1d3c989ddbc745258632a9017432230b362f85a215b13c24593", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/text_encoding.py": "f299b2f26598a04d5e70d8f5f659b9c45cc89abdb136cb466559c14a7ba17db5", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/timestep_preparation.py": "efc5ce8ef4f05af58c4e5079b8ec1232f8847c5aaec7dbe5299312e3ebbac3d8", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/stages/visual_encoding.py": "a52754f8c1ccb6370ac12c1fe8e98b2f28f76145540dce72c9a1d0e27d9946d9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/task_profiles.py": "0313922cc2d5e2b5af76583aaa96a114ccedf582de3eebfbc05abd79a84aec0d", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/time_request.py": "c63ae32bfc7e3fde5cdc7a791ceb5a62d9e72f30c9d08b6af773571c126bce90", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/minimax_h3/video_adapter.py": "637bb5c97fb12b1b347845df366f8d0239735dc43b1dbd998e0ace1018d2baee", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/mova.py": "79b1beb782edcfd1d72565f6924def1e676001b35b7dae41bf833c53d3e943ea", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/pi05_preprocess.py": "907722ab1b870f37380bef6ca018c9fb364143d3e6db3c9afe07de8d6dad5a9b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/qwen_image_layered.py": "4b50c4fe30b5c187f7820f5a7e71e30fa79bc6e2215a49fdb8eb24b4a4879c33", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/__init__.py": "d07dc00c83ef44d83f9b649b7efb4c750e23601a435fe5c5fc6b4ec4f6250016", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/base.py": "13757608aea15e1d4183d2be4b6f2c3341c0d336e0282624c3e4c6d7f3fef21f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/parity_probe.py": "5017dde841c6b3073983cc7877f1b55663ef20a8acd8acc274f2640c86d9917f", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/realtime_chain.py": "54ce38eee977a8fac6c12fcf89bb0d5b0b09c884a13c5511d07f1162078ac2e3", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/realtime_stage.py": "c4664d770fb65caedf02e1bc8d8458f3f67f711e347b240b2c94e3be789423d3", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/refiner.py": "41ec01eb88b0607164f953a53f5ad7fc9ace96e5d2ebead573d9684cbd80cb8b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/self_forcing.py": "52dbfb8187e6bdf72565a27f05c6724e360067f101b30458e03e6a92aefd377c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/streaming.py": "7556d57853d3a8880b3c7becd0f0342316e7a7c8a15c8c6347df60d8f451424e", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/sana_wm/streaming_refiner.py": "eee37cc2b25e637be9b1a5b41f021c21d53058d9123ca26e451bcb84dc63aa39", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/model_specific_stages/wan_ti2v.py": "1ef1e949e4281b4d66270ff1b46c0494e833b1e3057284a17e7fb079f483a42c", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/__init__.py": "6c6ec57de9f82ef42d82760f144a4571cb16b3cd6de33aaa7aa9fd65e8ab1fa1", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/denoising.py": "96a4afbe87e09b25b47936edf0d7a4a7f7595095103d35d57ee2bf7b1eb016c2", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/flux.py": "51445836cc46bdd17057fdc785a746a7ad1e6c20998c05d873b5d195358d7e82", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/flux_2.py": "90666826b8268bf1c220547e526b39ad916e091ef3c005e71a248fae283931a8", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/ideogram.py": "199950972f3d0320035a6448e435280f4afc9f2247af1be5bda38ff2a2183e72", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/qwen_image.py": "674b0f88531a624c24465a111b5da1bc2e088c17535d75dd54b230ba0250232b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/spectral_ops.py": "decd473c34592ad614f49eaaec1948860b89a30e188c60f63773de408e795f06", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/upsample.py": "67f79e1d35cf767c7d0893bba92554d10b46e74c35aa0b3601f1831673b55be9", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/wan.py": "01e20f8f4ad778a1cd63ca358830ec03c49438ec68d19fca398925b5d817c2e3", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/progressive_resolution/zimage.py": "02d7b39de22f513243b2ea38e691b12fba01ebe376dd893047eedcda15af99cb", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/__init__.py": "4e797ef67941ae4007d47b16fb2ae8690ebfa20e73c21a94cbcc6ec82c629b70", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/base.py": "5709aae23ec0677bf87f79de569fcc4a82cabdada048389084dbdf373e10a01d", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/input_validation.py": "4960abc43e241570e3b8821e5f1e1e7d02f5371cc099292a8b52d1627aeed676", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/latent_preparation.py": "b2e9913b190da21732267e61c7c2270818634e3c8efef99a17c20fabb11c338b", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/text_encoding.py": "c255839e213e174b3de65397f3e74decabdbaff33a9a77310496617b16bcaf97", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/realtime/vae.py": "c3d377fdd3ca540ba132a0b0f37d8379c7a87892ce68cd0e04801763729cc4fa", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/text_encoding.py": "db0622740e6d6ffdfad700cbe9ac5aebd79b9b7d4fca2585bc80670fe9c7567a", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/timestep_preparation.py": "1967429c4319b340f37598ba34602025d11b3bc331f1177d2d93d9a1b582b445", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/validators.py": "2c9cd061911c1bd701a2c10294ad081168a12d895f19cd0349c30936348812e2", + "python/sglang/multimodal_gen/runtime/pipelines_core/stages/vla.py": "e31a04dd06e3f5d5ff1f76d4c3f7b22e231033f92a41cc403c38dd7800b47d18", + "python/sglang/multimodal_gen/runtime/platforms/__init__.py": "5bb4932af140e12b2c3bb25df663b648d7dd31ca9caf0bc11ca1550549c6b65b", + "python/sglang/multimodal_gen/runtime/platforms/aiter.py": "7a49bc177acf80e4555090af7590dbed1e07cc34616b746ce9f1a92ed48e9509", + "python/sglang/multimodal_gen/runtime/platforms/cpu.py": "d8309690b0430ad0b2c24090dd98e2c9f8fec4e8621e06ffe6f4f291a9d37f6b", + "python/sglang/multimodal_gen/runtime/platforms/cuda.py": "75e193d697ed7c92eb56b57d255270b0e66cae1d07ed1beaeb34c2275502e2f4", + "python/sglang/multimodal_gen/runtime/platforms/interface.py": "c930fa459065ba6e0376f40fa79e901cab6fd88b1a9c614ecdf211ddb46aeb0c", + "python/sglang/multimodal_gen/runtime/platforms/mps.py": "104fe9a5c7cc645a56b0752d06107ef96053d856f19165872ef2f8ddf986dfd9", + "python/sglang/multimodal_gen/runtime/platforms/musa.py": "311867736d12a2577c791281290444c9dcaf1e0047eae804794e5802b94477b4", + "python/sglang/multimodal_gen/runtime/platforms/npu.py": "fdbbfc977a3136add00574f1859d9f2c3a43cf1cd6439f700c1ca0dc891f0172", + "python/sglang/multimodal_gen/runtime/platforms/rocm.py": "fe9cef509a49647a9f3cb8b65fa1d5cb2b86d4d7a0d6327989209899c592c06c", + "python/sglang/multimodal_gen/runtime/platforms/xpu.py": "ddc912e9062e44a2fe550a2d5d37b22534eaf2fe5fdf125206fb30d13b1a1371", + "python/sglang/multimodal_gen/runtime/post_training/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/multimodal_gen/runtime/post_training/gpu_worker_post_training_mixin.py": "e1aebeb72bef4c1ea5ba989952aa05e8bde09a5af3e0d5e9012433f783077e99", + "python/sglang/multimodal_gen/runtime/post_training/rl_dataclasses.py": "c4cfb89c970281779e76bd8121fac8492fe013b97166f62d0b88f851b4d9a066", + "python/sglang/multimodal_gen/runtime/post_training/rollout_denoising_mixin.py": "10305a821b163434eff8416bdccce16bddc5983526d8d300ebec6e4988d8447c", + "python/sglang/multimodal_gen/runtime/post_training/rollout_scheduler.py": "aa8f161c0fe0609be9e3de959e40df57c53b276575689f782a113fb1f317a4a2", + "python/sglang/multimodal_gen/runtime/post_training/scheduler_post_training_mixin.py": "095f61d7300510896007c403a88a6421e9c82aa2b294e6d48efc951afd3f3f2a", + "python/sglang/multimodal_gen/runtime/post_training/scheduler_rl_debug_mixin.py": "ceb15bac24baea41a718a4c538ba1a98f2d07d32a579ce4f70407386121df58a", + "python/sglang/multimodal_gen/runtime/post_training/scheduler_rl_mixin.py": "9ffa667d04fb58ed1f92339f8af3d13858ac942b026362e8dd94dfe420d0a6e3", + "python/sglang/multimodal_gen/runtime/post_training/sp_utils.py": "c24b4c63676632001857b19ba96aca5ede62c7e3e0c058c627dd472c12c51464", + "python/sglang/multimodal_gen/runtime/post_training/tensor_update_checker.py": "d848b68cf1a0998cdef6d5122bd6ede88bb191dc9625fd2b1d7584e2289549d3", + "python/sglang/multimodal_gen/runtime/post_training/weights_updater.py": "e186916d3a674d5fe63a37843617de10adf77728103062cbdb87c1832cebadfe", + "python/sglang/multimodal_gen/runtime/postprocess/__init__.py": "20ee20c21e544591bb88333128438e87c26a9a9abaa78f9547e131b67ac9d920", + "python/sglang/multimodal_gen/runtime/postprocess/realesrgan_upscaler.py": "a7181cdf15394b92ca5cde3b638fdb9430b21ffaab302e7b255556135b44e749", + "python/sglang/multimodal_gen/runtime/postprocess/rife_interpolator.py": "cdd703be5e99188602b2d7c00ff65e65742987b10fe9a42a50989a3f96c75242", + "python/sglang/multimodal_gen/runtime/realtime/__init__.py": "bb74a0238ddd0e18db8a608b28b0a95773af8976fa7411ec4cafed7c56233ab9", + "python/sglang/multimodal_gen/runtime/realtime/control_signals.py": "62ffad1ea2a6fdb326cb938972af040a77820f1a06d7e7f1a673a9e54a47a048", + "python/sglang/multimodal_gen/runtime/realtime/session.py": "c88d017f2bfcbf643ee8d58eaefb7ddfbdebcb91321567ef9489dde79141755a", + "python/sglang/multimodal_gen/runtime/realtime/states/__init__.py": "55e92a843e0c48d0cd42cb2ec58b5a276421d22e78b0b3bcad320cd0f6a678bf", + "python/sglang/multimodal_gen/runtime/realtime/states/camera_control.py": "07f930c494a88b588be5d19eeaa995e1e135b8994f2aadedd31591ee4b01951b", + "python/sglang/multimodal_gen/runtime/realtime/states/causal.py": "4cae131ae8996d587653a3f133e9635ab091b929704f797fd5fd31f9a3b0950f", + "python/sglang/multimodal_gen/runtime/scheduler_client.py": "840763aba125ad921e8110d3080a1b423dcbe7f15adc875997986d12ac96d18e", + "python/sglang/multimodal_gen/runtime/server_args/__init__.py": "ebdbb25077de0323534a461552a1fd35cd0bf37883f3af853ab31c6774cdc210", + "python/sglang/multimodal_gen/runtime/server_args/auto_tune.py": "e81265cf01d8118292a177bf142be1ad3ec0e6b101ba01e37e03983371c9507b", + "python/sglang/multimodal_gen/runtime/server_args/disagg.py": "42cd66c907417cb2f2ea6175fd730ac78110468877b41c72d8f01373b248d5f1", + "python/sglang/multimodal_gen/runtime/server_args/server_args.py": "7a9fb391c014b1f08c0a495d6f689f26ea554c61ca1680ee57d6e5f7b672f3e6", + "python/sglang/multimodal_gen/runtime/server_warmup.py": "01636abcac02acec198bcd97daf1610c5e93c90cdc8affb8034d10c6ce5b5f03", + "python/sglang/multimodal_gen/runtime/utils/camera_geometry.py": "1f83ee08bf6f55f3f59e07a6a0c01c4eef23f5f4a29bb307101c5727a086cd1c", + "python/sglang/multimodal_gen/runtime/utils/common.py": "3337dfa95b8821723c1d642b3f5dc4f00e24c19b7e739665a71705b6423894ff", + "python/sglang/multimodal_gen/runtime/utils/component_load.py": "b99183a600bd3fa8e9b9ce2dd569b8cf4b3f0e4aeb4a594cd562e4001ccbac9a", + "python/sglang/multimodal_gen/runtime/utils/condition_expansion.py": "577778dcf46e171f944747e7e583b67b3f413a4a09a0cebd9adf9610873bd1ee", + "python/sglang/multimodal_gen/runtime/utils/distributed.py": "22de4ef9e9c8beb9f18f3e938956d67bbf98f0ea75682712388a59a270f4cb85", + "python/sglang/multimodal_gen/runtime/utils/hf_diffusers_utils.py": "827f328740f0f6ea0b0760412ee615cc8aa9a51a9eb2eda509fee859327a0a1c", + "python/sglang/multimodal_gen/runtime/utils/image_io.py": "fdf1f4c36faee71bdda18a90b9eb7877d321fd382c4034a1e4e048b6af5adeb0", + "python/sglang/multimodal_gen/runtime/utils/logging_utils.py": "9b10037166b203ecaa859710481a5e1d6c1993ecdd3001d6804df0ff69c62385", + "python/sglang/multimodal_gen/runtime/utils/mesh3d_utils.py": "dcb94dac457c7e58782915115e5eaf4a012370363e8566d89ad29eebdbe82ba7", + "python/sglang/multimodal_gen/runtime/utils/model_overlay.py": "dc80fe7529e39587e5b3cbb9d76d4c6f74d0d8dc6f1f72e0c3e69926115540d7", + "python/sglang/multimodal_gen/runtime/utils/nvtx_pytorch_hooks.py": "0fd3943870f48e1b342c74c43d54713b89d0bc51b1c19c1c2777dbf9929f9cea", + "python/sglang/multimodal_gen/runtime/utils/perf_logger.py": "d5de095f14cfec2258d3f72b18f5754a1d0ec567736a6407ee14f76ad2dbe522", + "python/sglang/multimodal_gen/runtime/utils/precision.py": "2941476e01609abb128c4cd0fa1a7c554f575ba69ad16b558903c5cc8a3edb53", + "python/sglang/multimodal_gen/runtime/utils/precision_types.py": "c6ebacdf38bc674a57a95b31f4fd0bf7ef1025a2432a83030573383c27f5e6de", + "python/sglang/multimodal_gen/runtime/utils/profiler.py": "fb9935d1d4e22f2b4329dd247909c3a46c1aefa35a88f5645bcdc2fd708ba6d9", + "python/sglang/multimodal_gen/runtime/utils/quantization_utils.py": "d12d7cda40415371c406516ef911ed5e670b993cab25fdad30ec4827f5dc6246", + "python/sglang/multimodal_gen/runtime/utils/realtime_video.py": "dd337946b5039d47b896b2d665e0137dc703d89db4d7abe9ab3e50d714f90acd", + "python/sglang/multimodal_gen/runtime/utils/request_logger.py": "ece900b3123e8e6340a62bc7d10afc0cd35b8a62cd3315b421cee8ad48aabfbf", + "python/sglang/multimodal_gen/runtime/utils/torch_compile.py": "67f01e9dfec936624df2fe77232ce9af57fec1618f7b02c835a244266aebdfad", + "python/sglang/multimodal_gen/runtime/utils/trace_wrapper.py": "7811b8bc666cce8f1847c2cc4a009a3d4671eb34642fb61ea2cbb210acd2406c", + "python/sglang/multimodal_gen/runtime/utils/vision.py": "c731c2f579c3be880c4810e60883c3a0048bae6583dc05bd8e3318baa9b67e47", + "python/sglang/multimodal_gen/runtime/utils/weight_attrs.py": "a803a937c1bb2dddcb675213b7a75baad0d988ad79c62d31b35db3430463fb47", + "python/sglang/multimodal_gen/runtime/vla/__init__.py": "72611bc6b62a2a01eb7f593b973d90affc93ffb78885d3a23b36a6b2563737fd", + "python/sglang/multimodal_gen/runtime/vla/cuda_graph.py": "c9b6d3d07727dc53914b80f7311bee449cde52ff2748280d420702f361c2ecc9", + "python/sglang/multimodal_gen/runtime/vla/observation.py": "f05173db6fa20ae11929b32fbd4f895a8f94b1173d412098381f0d75ed46ed92", + "python/sglang/multimodal_gen/runtime/vla/parallel.py": "1bc23d893e8c9cb9887a4d8822dc45add7589fbb80324cbf72d6be4166891221", + "python/sglang/multimodal_gen/runtime/vla/prefix_cache.py": "40ace0b366e9673b6414695765b3f2aded8f2944779275ed73d9439cc5a5ccb1", + "python/sglang/multimodal_gen/runtime/warmup_request_builder.py": "9f63342e9453603a56786a93dd6ea3ff5b2d06b9ecfe6a901c9c51f1dcf45491", + "python/sglang/multimodal_gen/test/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/test/partitioning.py": "127c20a8b3301d5825e29932c28eb74ef129ec20d9c16e77b3a13d574940fbdb", + "python/sglang/multimodal_gen/test/run_suite.py": "5785b26c1a621cb7a8ba7b506a98ff07a239293310bc4f45a531cbceb5f74fd2", + "python/sglang/multimodal_gen/test/runner/__init__.py": "17587a799b45c0a19d8a9d2c1bd563ab2a1ef0ff62b4a79cabfbc1c8c2f8545a", + "python/sglang/multimodal_gen/test/runner/pytest_runner.py": "522b5141b729b12260723da698dcf82b75a3bee88320e6e9edaa02002b173bad", + "python/sglang/multimodal_gen/test/scripts/gen_diffusion_ci_outputs.py": "3067dd3d119780a9d86ff6709459e4658ae0f3d53e0e7d5e6555e01d07db5783", + "python/sglang/multimodal_gen/test/scripts/gen_perf_baselines.py": "adef171719472280f161d53eb72a5d43277fd6128cec9346c9300a2900095099", + "python/sglang/multimodal_gen/test/server/ascend/perf_baselines_npu.json": "4437ceb952fe205a1da70bbe6ea309895e6b951b674bf89b1d78f961a6cab18e", + "python/sglang/multimodal_gen/test/server/ascend/test_server_1_npu.py": "adedacdaf2f2d26439a30b18165a5e84b6b273521384012a0a6524956be0356d", + "python/sglang/multimodal_gen/test/server/ascend/test_server_2_npu.py": "d17e7a94ac9b712cb330d6d70f76aec3d93c1eaee783e9f5fdd4c2fab1eceebd", + "python/sglang/multimodal_gen/test/server/ascend/testcase_configs_npu.py": "add9064c389abdb21b274932bc5aff35164d18f7be9518d6bd1f413549fad2dd", + "python/sglang/multimodal_gen/test/server/common/__init__.py": "a33a6e1266b4ec92e3a20d365cac1bd96612545a5f5aaa1cda1309b6f741fb53", + "python/sglang/multimodal_gen/test/server/common/case_fixtures.py": "16b5e8d20a1e74f6efc0513cd6347343baa59fd249a44ef29e4e09fbba68fda3", + "python/sglang/multimodal_gen/test/server/common/slack.py": "ec3beb52a4e8c51f221b471b0eccf9a21a3259ecb3b5b95768e152da6bedd473", + "python/sglang/multimodal_gen/test/server/configs/cache_dit_scm_config.yaml": "7be6aaa922d1256c7eec2ea866433fef59b83eab5cce616e392dff412b12fc5d", + "python/sglang/multimodal_gen/test/server/conftest.py": "c0e7af08db1f33060e06be7b1b83b2b5238c57805a54434d7907de4f238b7a5b", + "python/sglang/multimodal_gen/test/server/consistency_thresholds/5090.json": "2f8dbf71209a5697c55e3c43093652612d05c1d883dd2a6924bc1de029e07218", + "python/sglang/multimodal_gen/test/server/consistency_thresholds/b200.json": "c19f6c9403ce1b2e8ff22311d16aa1e50ae310cce3242ca80d66c22ee3b651c9", + "python/sglang/multimodal_gen/test/server/consistency_thresholds/h100.json": "b39b85a3987e8a611a9fff1d61ddd70ca8843bcc4a1c6fa9623c6ef2862163d5", + "python/sglang/multimodal_gen/test/server/gpu_cases.py": "e78fc306fad631050a8d1e5f6b311dab17e1ced9e53e52aa657a6ec19b28aa55", + "python/sglang/multimodal_gen/test/server/musa/perf_baselines_musa.json": "76bb570e6005c4c9602c1c9998ed405f10e97752ae73e803bc133a16dea14967", + "python/sglang/multimodal_gen/test/server/musa/run_suite.py": "17da70de107c4250d1a52294e9fb7599756a402f731e24cfa8e06b8f2d360792", + "python/sglang/multimodal_gen/test/server/musa/test_server_1_gpu_musa.py": "77a53681073e5807c153b8c8d743cfb7fdaa2075a6c34e5a122c5a77594ecc4d", + "python/sglang/multimodal_gen/test/server/musa/test_server_1_gpu_musa_nightly.py": "5ef291bfc18c02f1ad701a8b1265a1c4f75440eeaa95d2c19619fe4306ec5225", + "python/sglang/multimodal_gen/test/server/musa/test_server_2_gpu_musa.py": "ce2456d248bdcfe601529bf320965120721cfbaa15cfcee3d202c46565b4d3a3", + "python/sglang/multimodal_gen/test/server/musa/testcase_configs_musa.py": "b8a993d183b288d23f45dc30e084b31d20be88004bf4cec8ee712962cdc23f0d", + "python/sglang/multimodal_gen/test/server/perf_baselines/5090.json": "9260040f51700f6e43e6ec6ce39b366b3090427516a54db4b625a9d1cc393ba2", + "python/sglang/multimodal_gen/test/server/perf_baselines/b200.json": "89f04a7307863fd2aedbb4070b1d70fcb436af644347ed57180922c25ac20f29", + "python/sglang/multimodal_gen/test/server/perf_baselines/h100.json": "a41e2d3ae76e4188f62a5043bc6e8f27dad53fa5950f388a0d2f84398673e997", + "python/sglang/multimodal_gen/test/server/realtime_consistency.py": "248069269b7a98d4a1581afff21c2637ee5fac06666243746041beec8977ebf3", + "python/sglang/multimodal_gen/test/server/test_request_logger.py": "806c3ecaf732740503bccbbfecc21e17eb6e93400cc0010bafb1c3ba729eb5e8", + "python/sglang/multimodal_gen/test/server/test_server_1_gpu.py": "8ece23a8aa163fa347966610f694950f69cac3b82f90adff377aa09a7b13a836", + "python/sglang/multimodal_gen/test/server/test_server_1_gpu_5090.py": "880a6e5b8857285f28917a3e737f77e049df5720d94ab2f6c00051cbfcc61db1", + "python/sglang/multimodal_gen/test/server/test_server_2_gpu.py": "3c3c48d0a91b4a8f6f7ad0bfa694ce2c025386d46a71c3c3156d648cb8cfdd9b", + "python/sglang/multimodal_gen/test/server/test_server_4_gpu_h100.py": "677aef54687fd5c5f498f562784e362763d5d885c1ab2309959ef4fbca418e94", + "python/sglang/multimodal_gen/test/server/test_server_b200.py": "a2fc33120d704e64e89d5c5713704ca52dc9106e5f89e563b19d454119a46e64", + "python/sglang/multimodal_gen/test/server/test_server_common.py": "c3d4e392b135f9dfa290a20fd42fd955739246ad433516875f45d38436a85785", + "python/sglang/multimodal_gen/test/server/test_server_utils.py": "cdfcac431a5e37553332f55a8649b023e8824e827a037cbbb59a231edf0368a9", + "python/sglang/multimodal_gen/test/server/testcase_configs.py": "02629a142a0ba96de2b628121e0bdabb3120f03e475f37284452eb832f8733a4", + "python/sglang/multimodal_gen/test/single_test_file/__init__.py": "24a42a7936cb2adb6b925e7751516cdc351ee72b4b7b9cb009da2018f5f587a8", + "python/sglang/multimodal_gen/test/single_test_file/cli_generate_common.py": "3f55cc9522e6612b2928a8ad1d73c067ec6a91c895d2b58dde54d2ecf6977eb8", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/__init__.py": "1c95aa916035e3af308a2fabd8fc9227325f85cef2560279e48db633f3702f70", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/config.py": "068e239a444766c3a8fdf561d92c203796629d2087b23a3ee6f228cdfa2086ee", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/engine.py": "f1fc4fb903fd56b4e33465b6faa61380925e3a0260e4a6b709270efe8893c155", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/hooks.py": "b66b3c788f840ecdd70ace046b282bf5bd51d15f8840b1539d0cecc6300f473e", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/test_component_accuracy_1_gpu.py": "1649af1159df0f358137e4a6101867154076d8120a2ba4d1ce6158901bd0f97b", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/test_component_accuracy_2_gpu.py": "97c9f6209dd47bc547f9678ce0101794160f9392dbc97c2d7a05902d7faa41fa", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/testcase_configs.py": "db538500a798acfeecd27c3151a918dce33c8552cae17684a21d5217e65c3dfc", + "python/sglang/multimodal_gen/test/single_test_file/component_accuracy/utils.py": "5c642f9dc49caa230728745a269a090241191bfc1c043dae54c3ad8fe0189926", + "python/sglang/multimodal_gen/test/single_test_file/test_ar_models.py": "a23638ce14d90e6986928cfcfc968af6eb2788dcb9b3195a995c01b1dc5e602b", + "python/sglang/multimodal_gen/test/single_test_file/test_diffusion_bcg_tp2_zimage_turbo.py": "a824db2c8d1c46e91f7109a7476424919ca09057fef12944ec0ac1cb08826e01", + "python/sglang/multimodal_gen/test/single_test_file/test_diffusion_bcg_zimage_turbo.py": "5b56b8c2e1a751c8405c267c4a40b3bbf39a84125e6b70f3527a0b91a800f899", + "python/sglang/multimodal_gen/test/single_test_file/test_disagg_server.py": "bfc41aef3576630bc0dc4d8cbc614b8dab337adc698d79ba0a060828c98ef694", + "python/sglang/multimodal_gen/test/single_test_file/test_dp_serving_2_gpu.py": "0485ac2be9f9b9538af9b4217b061e4dfd24d7fd87b28ab879ce20cf981e9018", + "python/sglang/multimodal_gen/test/single_test_file/test_generate_i2i.py": "ef65c19885923d141a3e62cef060ae2e5ea63ef31ec28db8d53f84535a3b4d34", + "python/sglang/multimodal_gen/test/single_test_file/test_generate_zimage_turbo_cli.py": "f0a66ddc1cae8b5451d6d4cc64afeeebe2ad745e0924c331d1f20cce4f4107af", + "python/sglang/multimodal_gen/test/single_test_file/test_ipc_a2a_2_gpu.py": "5676488aa36a01cb4465a94db240ea536439f484af282e26e9f2a0166c952f12", + "python/sglang/multimodal_gen/test/single_test_file/test_pi05_e2e.py": "6aee29b2a863dc63eb5e21b3a3050d3b36915b2f3106bb6557537a1046a40e1a", + "python/sglang/multimodal_gen/test/single_test_file/test_pynccl_a2a_capture_2_gpu.py": "00763779cdd7af3a94629b1da95a23a05371321cb88105d125ae40a00841f4ba", + "python/sglang/multimodal_gen/test/single_test_file/test_update_weights_from_disk.py": "b0e1468d6deb8a501f8fdce1ba625690eb1b2a0c476f157f015a2c12bebcff29", + "python/sglang/multimodal_gen/test/single_test_file/test_usp_replicated_parity_2_gpu.py": "7e0129fe1c081c55a471c4bebe17a737ba53362a2cbf90e2557fe2704fef43c2", + "python/sglang/multimodal_gen/test/test_utils.py": "17c3be6aaf3e392f6b6171cc976d06631b142a7483c588b840e2411c04c22b42", + "python/sglang/multimodal_gen/test/unit/conftest.py": "2ac87ea8d2fa630edbc3672ceda2e3837badb31dbe97e3d12d2ec8004a96fd8d", + "python/sglang/multimodal_gen/test/unit/manual/bench_patch_embed.py": "4525980fe6eeb24c3120724758bfb0f47020a56d92d4f7163095fd6f7c394596", + "python/sglang/multimodal_gen/test/unit/musa/layers/test_musa_rmsnorm.py": "79f8bc273acecea5107f4ae5bed7a949b6afcb3574c54356e25b780b75cc0044", + "python/sglang/multimodal_gen/test/unit/musa/layers/test_musa_silu_and_mul.py": "bd9dfab06e2d7279be68f4bab2722fc517e683f9c56c6fcd550b289a06e4ad45", + "python/sglang/multimodal_gen/test/unit/progressive_resolution/test_progressive.py": "a3501a5a78df433f78ce3e40e8c2885cc4ef16f85b64088ccf5abe55d003ca55", + "python/sglang/multimodal_gen/test/unit/realtime/test_causal_denoising.py": "1163d8ee78e4d6918aaf22f4b7d12132509073864d633c2152b1c336a499a5c5", + "python/sglang/multimodal_gen/test/unit/realtime/test_lingbot_causal_denoising.py": "a1e26a1d832b073f81c94b5fdb155997dfe3702bbc55461217559ecb8874b902", + "python/sglang/multimodal_gen/test/unit/realtime/test_output_materialization.py": "f31a490b9ae2fc0d908267455e1a889ac5de28f1c29b7ed94286ccf36ff67fb4", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_consistency_harness.py": "5dd4268658b93df53c0ff6f950da100ef6513b69abe15ede8b7740b5058373f6", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_control_signals.py": "ccd8038b430fe8f2773e9ed88d4dad3e1d309cf0c1da19faf8445be3c32245fd", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_output_transport.py": "72829e0c0d6931a520f5e7b0ab13740f9a2c058b26a2ca6d5add756cd8d993be", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_runtime.py": "5cb2f47955643016c3a046cf5afa64004a472ca57dfa9909b34c1e09a84fcc74", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_vae.py": "cc58da5a5bbbfbe9490a271d96a67be8a8200e28d888e396c569a3d78a69db12", + "python/sglang/multimodal_gen/test/unit/realtime/test_realtime_webui.py": "fa8e336bf234a0da55a939b8aed22368efc3348b8fef0d664c17e389779cfa04", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_pipeline_config.py": "6f6c7f7d054872b91ff6343d0f6adf23998c97bf42dda8c33258fd6565d0b2d5", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_realtime_chain.py": "1d6de8f81a1b7a5116daa5fab95d32aade85fdc403ec7f72cfc2954e79d8835e", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_cached.py": "a98e85518d66ada93f21e09e957f7cceaf38629c08b52657733a58ddb44e7327", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_forward_long.py": "6f6fe0a962a18dbe1421a71f677bd5053c2e6a09e49211dc4deefae7bb16b421", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_realtime_path.py": "8d2df2a9789005b200ff9c447028867d81cb639ce0547b1bdf4034bd4a001c9c", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_stage.py": "90a1af040050667c96c5a6617a2f2223a7d390cd08946263795bc69bbbfcf1cf", + "python/sglang/multimodal_gen/test/unit/sana_wm/test_streaming_vae.py": "5cf1d8883ebf87e1cbbcc2c2ff701676743eb51aef90e0ad05f1f54beff6e95c", + "python/sglang/multimodal_gen/test/unit/test_adapter_loader_offload_target.py": "578ebe6a29f8b283677e08ba928d52959a17e992e7402866d1b1ea1c5ce94a3c", + "python/sglang/multimodal_gen/test/unit/test_attention_backend_selector.py": "2513e4878d6db0ac403802fd5da6f2baa9e99a1d3293761e0c1212b09eb84c3f", + "python/sglang/multimodal_gen/test/unit/test_cache_dit_integration.py": "9fc9d62e39d14ec41463c90f475b3a718157f73f53f0aae6836c36bea1b8035c", + "python/sglang/multimodal_gen/test/unit/test_cfg_gating.py": "1e20054ec9ee3ec24cbe0a78c9c1932efb035659720a7a2e02a40c9a90e2b371", + "python/sglang/multimodal_gen/test/unit/test_cfg_parallel_warmup.py": "bb20413567e84e8a7a6154ff68d8987c2bab64f1043927e7ec34d79499c01cae", + "python/sglang/multimodal_gen/test/unit/test_cfg_policy.py": "7d24b78ba63d88bcd7bc36b3970f83aae0e8af83ec20c15176272cedbedf1437", + "python/sglang/multimodal_gen/test/unit/test_cli_generate_common.py": "1347c119117717ec3d49edd4f601ca2391b4f68544c0175648d8af68e3dd2bcc", + "python/sglang/multimodal_gen/test/unit/test_component_accuracy_inputs.py": "1acc11ecf4b244dde2577d3ac712af182849af7b7a131aef99139b7a6faae550", + "python/sglang/multimodal_gen/test/unit/test_component_accuracy_parallel_runtime.py": "3014e8a0499abc002aaa636a33893484aab81662ba7020fe53cec9ce9ab9182c", + "python/sglang/multimodal_gen/test/unit/test_component_loading_order.py": "8a7c6b214e32d4382e43cd8948ab97b21f3cd2d83741bed1f2e970afc9ff6202", + "python/sglang/multimodal_gen/test/unit/test_component_residency.py": "67fcb9b7640bc5ea5bf5c4ba08e0afefc296154a0fa2bf34d8a43776f570fe90", + "python/sglang/multimodal_gen/test/unit/test_consistency_metrics.py": "0be386f51a19b61c27e452fac37c60b25b4331f1bc451e52b490e52f09d0cd45", + "python/sglang/multimodal_gen/test/unit/test_cosmos3.py": "42e0b5a3799d999faf68e1c706ec79c854eddad99c85103d8c6129f44c141d91", + "python/sglang/multimodal_gen/test/unit/test_cuda_attention_backend.py": "f3f0ae523a8b4370330da57362e085f74174b8698925ecea52df02749ad96bd5", + "python/sglang/multimodal_gen/test/unit/test_decoding_stage_parallelism.py": "4fbdfbd05f5b3b7c6347b23881b72460c64567a2cb86f641077abf8225e38c7a", + "python/sglang/multimodal_gen/test/unit/test_diffusion_bcg_padding.py": "dd78c121383dcae2c165d3836322e83c4c6df763ce502767917a5d550424c0c9", + "python/sglang/multimodal_gen/test/unit/test_diffusion_bcg_tp_graph_capture.py": "19a636b99eb07712d9f97a59cd9a038837f8f5b2bf9556b50c6838bebcbf0691", + "python/sglang/multimodal_gen/test/unit/test_diffusion_generator_shutdown.py": "28cd08a46b5595daa5f1bdb39ad3317983d4896921c87ba906460614617d9810", + "python/sglang/multimodal_gen/test/unit/test_disagg_roles.py": "27102c5d53420519123ec89e85b5bd852f84ca57012d4035d12c93768c340022", + "python/sglang/multimodal_gen/test/unit/test_disagg_trace.py": "8c7142b84da8444091fec6db64f6da73fbf09503fdad472fb78b2d54d8740495", + "python/sglang/multimodal_gen/test/unit/test_dit_config_boundary.py": "ae7d407efa9399850a1435b98bcf1569e599d73cd6e3d42b89289c7cfbb0b4ee", + "python/sglang/multimodal_gen/test/unit/test_dp_routing.py": "076f2ee98e4e2690bfdd4fb85d0162500197a27819f859c4bbbbbe05174e5638", + "python/sglang/multimodal_gen/test/unit/test_encoder_world_folding.py": "cc5b26ea0db3e4041affbe497b8f4748eeb2b321cfbb2b36ea096ce8663e207a", + "python/sglang/multimodal_gen/test/unit/test_ernie_image_pipeline_config.py": "b352aaa77c5d10ab3b9f7a43c690f167372c770322c11edb2e9c74be4406d85f", + "python/sglang/multimodal_gen/test/unit/test_ernie_rope_geglu_fusion.py": "86d4931d5f99910610067c4d82dcd6813278f0482c817be23c237c8c13969854", + "python/sglang/multimodal_gen/test/unit/test_fp32_layernorm.py": "272897d7c62651e3f3a1edfc4b0f084b8464bdf182f459dafa665204167336fd", + "python/sglang/multimodal_gen/test/unit/test_fsdp_load.py": "b3afe1b8aa1e19d4365f5a73afc75bd054d361aacd640f708adae2f561442a53", + "python/sglang/multimodal_gen/test/unit/test_glm_image_ar.py": "a87d294fc4a4a3ab99fa2148d6f3f5bf7dd49855fa623fe29ffb354d3aad729a", + "python/sglang/multimodal_gen/test/unit/test_glm_image_multi_output.py": "2827c181edb5cb2b297160bb007212f530a047034a4c46d31e4914d19480505f", + "python/sglang/multimodal_gen/test/unit/test_gpu_worker_cpu_threads.py": "4f54f1054b81d715106ddb25090bd3b65665aa2680a63c5a22162d4d62dc02d0", + "python/sglang/multimodal_gen/test/unit/test_health_warmup_gate.py": "e327f6f299eb3470c03c0266f88ad958d7ecd54d3907ae60ce0dda9e1474089b", + "python/sglang/multimodal_gen/test/unit/test_helios_denoising_profiler.py": "fec0ad51a1d3af2ecef97242790cb5f1e0b49ecf9ee8c4c08852166a1aee663e", + "python/sglang/multimodal_gen/test/unit/test_hf_diffusers_utils.py": "a92df55b375b10163786a9d88495c0ec942c4433aed7ca6cea242e5156a635a9", + "python/sglang/multimodal_gen/test/unit/test_hunyuan3d_native_texture_models.py": "bf691073f61a320301720cc910c241851be0e7fc1b4e48129b7f7ce87a755a0f", + "python/sglang/multimodal_gen/test/unit/test_ideogram4.py": "13686014594d1ceef12f6668d43c3b0929dded27c918555d6bb66cac5f8a48f6", + "python/sglang/multimodal_gen/test/unit/test_ideogram_rope_swiglu_fusion.py": "1a580c0c600971e3f9af450f0d3cd13a5eef73230e983905fd2eedd92272cd52", + "python/sglang/multimodal_gen/test/unit/test_input_validation.py": "e2974f836d082e646826fb0cf2fa82d00e78c6a294330351676993e7e32553c9", + "python/sglang/multimodal_gen/test/unit/test_ipc_a2a_lifecycle.py": "6dd8d8bde7e0f3d75a2ad7db46e1a6c75a35ded5a3f3772fe51a9b297ddcc95b", + "python/sglang/multimodal_gen/test/unit/test_ipc_array.py": "48e111472631328dd37507c105ac937f877d201a9bf9e64fccf3e0068f49d7f6", + "python/sglang/multimodal_gen/test/unit/test_krea2_fp8.py": "6626ee3f00bf29c67b247be39c5b724f9d37a90bcb9b28a2ca723cd5cad1e5ae", + "python/sglang/multimodal_gen/test/unit/test_latent_upsampler_group_norm_silu.py": "cd3e5cca062518d6c03c9e9c43fc56259b30be20041cec5286b4d5a9846081f6", + "python/sglang/multimodal_gen/test/unit/test_launch_server_shutdown.py": "a1717d0b2473e40a95b15a3b2b755da9ac2d89667a581e0125073758de288a9c", + "python/sglang/multimodal_gen/test/unit/test_layernorm_cutedsl_dispatch.py": "44a9ba2a8805f68e4be49b83333a232a6665dc9b5ea193a5b4a481f615457ddb", + "python/sglang/multimodal_gen/test/unit/test_layerwise_offload.py": "a67b25e5d6503e03632d9ff4c26f2b1b6ad0b89202ca977c549bb23a2b2273f2", + "python/sglang/multimodal_gen/test/unit/test_lingbot_video_moe.py": "4f7aecf27ed3eb8c16e90ff18faf37ae57459d95d1fd4e19ae71073617625844", + "python/sglang/multimodal_gen/test/unit/test_logging_utils.py": "382884ea99823127654dc15792fcad74073a468651bad714560f87100b3b3e0b", + "python/sglang/multimodal_gen/test/unit/test_longlive2_pipeline_config.py": "553188dfc039669b9956a47daa5013b4c8c8fafd6d7f930fa3504d5de8cafb1b", + "python/sglang/multimodal_gen/test/unit/test_lora_commit_as_base.py": "363492884902832084a9bad92052ccaabe416bf4511929c3119108a6f6e676a6", + "python/sglang/multimodal_gen/test/unit/test_lora_format_adapter.py": "b2c1b2c0300b6b41f58029162768a29bc8fb019dfaa806bc86feca3b156f6740", + "python/sglang/multimodal_gen/test/unit/test_lora_inference_mode.py": "46d22617d42d50d2b6e12d765d27da90067bc33f22c042149cd560b0d400b8b9", + "python/sglang/multimodal_gen/test/unit/test_lora_pipeline.py": "3277b68c2c1437dc3f4898c9ea634418382e348937de6f9bbb07477203254148", + "python/sglang/multimodal_gen/test/unit/test_ltx2_5_config.py": "4228ae199153304dd967bc4d99ff33992bd604eb630ac96b4a05d879247f0caf", + "python/sglang/multimodal_gen/test/unit/test_ltx2_bcg_coords.py": "7a154db58df5e29e79c9121450f5e51c3c8a22fb479b15f6bc6add01b03bcedc", + "python/sglang/multimodal_gen/test/unit/test_ltx2_modulate_mount.py": "811f10ec75e86049beacda79e481fb5b44686e2fddfbd6fec1e391cb9040bbaa", + "python/sglang/multimodal_gen/test/unit/test_ltx2_vae_channels_last.py": "94bf38ce6c1ba11b34d212a84a1dae790a01f672ac21b21ae6f870728c6704c3", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_adaln_cache.py": "1257d2c83d72f22b28d23f6a73f176311185d5800ecb3c63b3c2691a3f8077ad", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_admission.py": "c1d7675c4cd36fae3f9c3218ddcff1dc11ddbc173dfe573ec80b32ebed3ae558", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_denoise_loop.py": "789fdba13794a31536874c77b271704f7920a2b7b3e597874ddf008496a4092c", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_dit_contract.py": "d1e0e39708c11ca25bdfdc6f55f15cc9a65118ee1464032b8fb7913b582caf67", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_encoder_device.py": "4279b1f78def8f649fe15ce37c44ebc289a777b86068bd5962e64bf3538104cb", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_media.py": "0e5b6fa5849891f82241e020b82f56f517f2ad3a7b1ae786b6910e6a13014b86", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_packed_sequence.py": "ac522c4b66cb122f1a20dc171a43c3163f859522c28dbb106f67c3dce4b7dd36", + "python/sglang/multimodal_gen/test/unit/test_minimax_h3_vae_parallel_modes.py": "c224d20e4fefc3fbc53985ee954a7ae96e0232f3e167dff006d2337e2f03fb0b", + "python/sglang/multimodal_gen/test/unit/test_ministral3_generation.py": "8a191b73b8913833c5ebc3bf055241c5b316de01a2c950e06093b5201698aad8", + "python/sglang/multimodal_gen/test/unit/test_multi_output_grouping.py": "5fa6a37a9cf253ea8293355ffd5d4c6b3bf62f2684f21e284cd5e7df3a38a4a7", + "python/sglang/multimodal_gen/test/unit/test_nvtx_pytorch_hooks.py": "570133cc614254a71e53c300c064e566b805f4146d1e0ba477c2ae3647d89266", + "python/sglang/multimodal_gen/test/unit/test_openai_image_api.py": "0b4fdafc55b8a37145df35bf3afe236aece05a2c3916bf1cf0787e3eceb53b20", + "python/sglang/multimodal_gen/test/unit/test_openai_utils.py": "1faa2497375fbafa513b06e3be292b40cd632a8573d34054eb531c575e1e8ed8", + "python/sglang/multimodal_gen/test/unit/test_output_saving.py": "44de3435b4a3b32b53aadc07e4c43e31f638268260d2499c8cd30b4c33fa02b2", + "python/sglang/multimodal_gen/test/unit/test_parallel_linear_weight_loading.py": "1078ab19b38d2a05d50d3cee3f7130b67de32183ef5e9e05d05adfbf8e17e069", + "python/sglang/multimodal_gen/test/unit/test_pi05_action_api.py": "ea32f5fbbdd93ef9c336e7f3dbf4e7d90829c0916fad49132a09336c27d88083", + "python/sglang/multimodal_gen/test/unit/test_pi05_prefix_cache.py": "63807e8798a896c1e9c0bf6a013dea53c06520df14f0347662602a39a814a420", + "python/sglang/multimodal_gen/test/unit/test_pi05_runtime_helpers.py": "2a37459d826e10db7f42346681f482f9bd3fb8b09819be7149159a6194f1f808", + "python/sglang/multimodal_gen/test/unit/test_pipeline_executor.py": "1982aab00c76005a0f620ce0f34960bbe0c27fa66053cca7d114d76a0c767e71", + "python/sglang/multimodal_gen/test/unit/test_pipeline_stage_profiling.py": "7c2b0f47030fb343c522ce209f746316c5c86d21d55546a362d747bc434dedfd", + "python/sglang/multimodal_gen/test/unit/test_platform_detection.py": "98cec8438a7fe11bd34c125ad74f483c460c0ea8a4fee364885292c528523f4b", + "python/sglang/multimodal_gen/test/unit/test_precision_consistency.py": "659d79f1395bd4713bce9041159387c996761d84d5464ff6fbc207caa8250f6b", + "python/sglang/multimodal_gen/test/unit/test_qvg_packed_kv.py": "fc70624be7a3bdd27265dd65db47de11428ff8ce42ce1fd79ce05fa1caf5a728", + "python/sglang/multimodal_gen/test/unit/test_qwen2_5vl_generation.py": "e422d7fecf3bf95c694321b879007107c4d0fccdf7b222356214d14a873252b5", + "python/sglang/multimodal_gen/test/unit/test_qwen3_encoder.py": "bc809d7348a5a85867f76503890d2205a2c10488e46e57fab5844086784bdbf9", + "python/sglang/multimodal_gen/test/unit/test_qwen3vl_vision.py": "3f70dfa66e018234987a65344e3ef4030425b602e784b41fcb3ad3cf9ffcce83", + "python/sglang/multimodal_gen/test/unit/test_qwen_image_layered.py": "5d12f06487dc2260186d53388a5b5dbddd20de6a9541943b8ae9c41c1d4f63f2", + "python/sglang/multimodal_gen/test/unit/test_regional_torch_compile.py": "fd9ae1eacaeb7ebe007b6be16fd0d74cb2450675e3bc7cc3249684d7d339903a", + "python/sglang/multimodal_gen/test/unit/test_request_manifest.py": "abb547707845f2c2b3c8259072be646f78e8ce1fc5cf1079568eddc89b02e2dd", + "python/sglang/multimodal_gen/test/unit/test_resolve_prompts.py": "86d83ef7c1a60b7b7595549fca6a6968ada97feac167669d8d5046f2077107b4", + "python/sglang/multimodal_gen/test/unit/test_ring_admission.py": "eb65b85e26d0bc109290a36b4e3d6f1e79296b8ef2883feb05f86467d8b9320d", + "python/sglang/multimodal_gen/test/unit/test_rollout_api.py": "230b4bfb1c36f1eade7eabbfc8f80eff5b527e192cdcc9384729de9b4556876a", + "python/sglang/multimodal_gen/test/unit/test_sampling_params.py": "572464bd87c88fb9e94bf2d5c60c95486245ed994b08286dd6e968a5932def60", + "python/sglang/multimodal_gen/test/unit/test_sana_video.py": "9b299bbb59f8bcab505731358b069f1f022f42b77959a062dfb8d10135b8af04", + "python/sglang/multimodal_gen/test/unit/test_scheduler_client.py": "0e0f89b7b436f92728ba6cfdec6aa04498076352533b512d714dbe54590ab325", + "python/sglang/multimodal_gen/test/unit/test_scheduler_rollout_unit.py": "45f0fea54e357584202c4ff576fd4d055db938eb7de2b8e7f769962885477c1e", + "python/sglang/multimodal_gen/test/unit/test_served_model_name.py": "640511a9bcbfcdb8fde83aa254840740e937af6fc46c0683ad99e0e99ace6bfd", + "python/sglang/multimodal_gen/test/unit/test_server_args.py": "7d43d677fac5c74597468e3a8c15943b99b5f8297463e37b1b9dfbf4271fcdbf", + "python/sglang/multimodal_gen/test/unit/test_server_warmup_progress.py": "34969836322f4605d1f130d70861e011f8632bbb3360f5fe2ea845ebd148547a", + "python/sglang/multimodal_gen/test/unit/test_sol_attn_backend.py": "60c62121cc51c11ce3e22e47826c041f794851537a65cb9e417ac332751220da", + "python/sglang/multimodal_gen/test/unit/test_sp_shard.py": "21260c6afd868f720beb75070e84c4a8ce9f8142d87d37d43e5ba8c165dd6205", + "python/sglang/multimodal_gen/test/unit/test_spectrum.py": "1ef56f3a12733299ecc05101a1be6fcbf17c4eb150c46eb75dd5499e588fc736", + "python/sglang/multimodal_gen/test/unit/test_storage.py": "432d4874dadf9e6efca474402935cac087536fed28f81c5bfce702c9a8b24fa4", + "python/sglang/multimodal_gen/test/unit/test_subblock_sparse_attention.py": "9639bcf0dd78d20092e8a6d75ef4d0adcfe69217a2531f8dff281c259516d407", + "python/sglang/multimodal_gen/test/unit/test_suite_partitioning.py": "d234973ac26244662524917c2d2a7d8086c0101f6c57d42d6f74dc0f4661c677", + "python/sglang/multimodal_gen/test/unit/test_text_encoder_loader.py": "a907c40435b3996ae022ddcf5160e3689227c538f9c4f1652db159714b061452", + "python/sglang/multimodal_gen/test/unit/test_text_encoding_cache.py": "f5911a1f91a27cc78f171deb1449d0ce7acf270b98550c6ba60db5543df74687", + "python/sglang/multimodal_gen/test/unit/test_transformer_quant.py": "dd81b12b3f01e27d03b4428bad4dad730e063537cdf20cf4a23d1927146cf37b", + "python/sglang/multimodal_gen/test/unit/test_turbo_wan_backend.py": "44ef6c562cdf022231b42c1fd74d3c67d05a01cec4cb3036d58ea9ebbd5f0c88", + "python/sglang/multimodal_gen/test/unit/test_usp_attention_kv_gather.py": "1922296471236f1d0a0c3a8332ff5c4424f406f8bad0877a55885e39b7b27204", + "python/sglang/multimodal_gen/test/unit/test_usp_attention_replicated_prefix.py": "325c9e94eccbb59fe573581ee7623a82e3da845c1f422be82691014cb0c8bed6", + "python/sglang/multimodal_gen/test/unit/test_usp_ipc_a2a_guard.py": "583a816b34ea8be2fd127dae3ee4c41e30c2474d2f60be99635e700847bfcfac", + "python/sglang/multimodal_gen/test/unit/test_usp_packed_qkv_a2a.py": "d2465417704b06b8cb1fbfea6da468d7ed1eddf424862986e264cd84ae5823ae", + "python/sglang/multimodal_gen/test/unit/test_usp_ring_replicated.py": "2728cd0df270cff9fbe030522a6ce313acf8e01ebbd2279fba50c7553dd6379d", + "python/sglang/multimodal_gen/test/unit/test_usp_ring_tail_pad.py": "f5c8e11db115f8c45b5a628372a59ec2ce4bc3e0a3ccb63a57d717007c0f8c43", + "python/sglang/multimodal_gen/test/unit/test_utils_parent_death.py": "cb6431dce85fbb346cb9fd87a56ead1ef4872732ee46f3392c3970c2ba028b3e", + "python/sglang/multimodal_gen/test/unit/test_vae_fast_path_gate.py": "539323a3a03f0fcecaae3c62005722d231e3646399dd32fa837e63f8e282634a", + "python/sglang/multimodal_gen/test/unit/test_vae_loader.py": "389d55dbcb259e58f9ee8cc613e7e42f1e7f1a8e37a6bff6ef5dd545076ec9be", + "python/sglang/multimodal_gen/test/unit/test_vae_spatial_parallel_decode.py": "0ab8f20f8c3c7736037b33295cf39f12c3762954e82102bb971d8069c6090702", + "python/sglang/multimodal_gen/test/unit/test_varlen_meta_host_build.py": "73e5a3cd4df4a2ebfd0ef6e287887274109120b2b17c2a7f63c3e139a45220d1", + "python/sglang/multimodal_gen/test/unit/test_video_api_profiling.py": "476abe2e34bc93da02e9b9645820339e75d4c33469272d01209725460b85a9ae", + "python/sglang/multimodal_gen/test/unit/test_video_job_lifecycle.py": "3abb207002925a08463a464f35e4836f2cca917d9ebcbc87f1babe60f3adce06", + "python/sglang/multimodal_gen/test/unit/test_video_sparse_attention.py": "8f77284fe1a7a77420e6bca8971d753eb1c9bb611e23725d2cc948e5ee6c5fa0", + "python/sglang/multimodal_gen/test/unit/test_wan_attention_backend.py": "f5b062daac1235fee733df482b165c719a6fda0c4097e4cd7f51be4abb851d51", + "python/sglang/multimodal_gen/test/unit/test_wan_pipeline_config.py": "8ee0a9d78dee527469bf9566a93990ececc3c97d8d25491eb40f31cb9a6a5419", + "python/sglang/multimodal_gen/test/unit/test_wan_temb_table_slices.py": "34262645c636b4e739371bb6244b3e9b3b8a7ffc03396c458e1989808f2a7b58", + "python/sglang/multimodal_gen/test/unit/test_wan_ti2v_helpers.py": "27d32547c702c450c8c1d4ccec8adb1fe80c24ec929012743acf96f5e071ed93", + "python/sglang/multimodal_gen/test/unit/test_weight_only_fp8_dequant_cache.py": "cef60ec2188bf588c91df47f95351ec909a019efa83631f5e01519b9e0c3f503", + "python/sglang/multimodal_gen/test/unit/test_weight_utils.py": "7a6ad15a3fa4d37eaaaf5e5a143c2c9a3383d5f610b9c4124deaa61c605b9140", + "python/sglang/multimodal_gen/test/unit/test_zimage_pipeline_config.py": "95fc4164eccf66b6434df6d80ff930bcf791d72f55b28b1a77127270324884ab", + "python/sglang/multimodal_gen/test/unit/test_zimage_qknorm_fusion.py": "c0ede506f9e2c1ed0585e8ebfa26508a8354ed91d031aa4a8a728d0605c1a64c", + "python/sglang/multimodal_gen/third_party/__init__.py": "a64a76d0d7c09a849e42795211f1156bff40d3e5b973a7e6255f321cf3162ff1", + "python/sglang/multimodal_gen/third_party/pynvml.py": "79ea49facf590fa182e0bf77c6855a845e4ab3141bcbfce6770ecc13a80da252", + "python/sglang/multimodal_gen/tools/build_minimax_h3_adaln_cache.py": "1116d5878e2255bade2b020a7c49618f691086cafd86f75870271b958de5773e", + "python/sglang/multimodal_gen/tools/build_modelopt_fp8_transformer.py": "c30c1acac5b2c6086498c81487bb8bf482cd1dd9b32a5b0829a553c1aac942b7", + "python/sglang/multimodal_gen/tools/build_modelopt_nvfp4_transformer.py": "1a43b877e0124b7f90242d7abcf6054eb9606387b9509bf3af83ce9116be506f", + "python/sglang/multimodal_gen/tools/compare_diffusion_trajectory_similarity.py": "0140a3da68ba10cbee834f0a96d9d163a6b519ed151048fe67c179302e18377d", + "python/sglang/multimodal_gen/tools/convert_hf_to_fp8.py": "911372836e00b7f34e9b757d68531c0420cfb5b77e13a3a2c850d5d0a1c153ea", + "python/sglang/multimodal_gen/tools/wan_repack.py": "a64a833bf6c573a1bb837c59089916d96ae617186c2cc656a8bbf2d0d3cb2d97", + "python/sglang/multimodal_gen/utils.py": "05642a8530529531bd17bc047014ea7e7d1b1843a5cad0546d7ea06e1e7f1bf6", + "python/sglang/profiler.py": "976f4b38ef11112ed5334a3c4920026a44ead0bfcc16a105c142bb061ef1bace", + "python/sglang/srt/arg_groups/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/arg_groups/arg_utils.py": "6abaa9be570c10b0d9e17ab1a324a07902aadffad5cb9c9b737ee885132b1eb0", + "python/sglang/srt/arg_groups/argparse_actions.py": "455a006dad5caa73ff089e705e5a217c1b56e78c405c4c284e8ea8a5cd55ab38", + "python/sglang/srt/arg_groups/deepseek_v4_hook.py": "b5c7090cba19eb8613a5a2b2440911c92e6e60040fafb6a68104f3540bbdd7b3", + "python/sglang/srt/arg_groups/hisparse_hook.py": "c23d69f90cbaba4459ebaaf5089a4a18b9e82fa749fdb5394bfd495068b7fc2b", + "python/sglang/srt/arg_groups/kimi_k3_hook.py": "28edb2663343894cc7bd7a5d3782ce5b871841f7203c61e1070a7312122cfd82", + "python/sglang/srt/arg_groups/overrides.py": "d3a1ccc96359d544b124ca9d666e161f2de4cdbfa649b8f0239bcdb6fe3f8692", + "python/sglang/srt/arg_groups/pd_disaggregation_hook.py": "5d4b5330a5375828179ed50f2708d68de90ecdde804832b252919b6a05a2a17e", + "python/sglang/srt/arg_groups/speculative_hook.py": "a97e3a7b427328559fa99e2078d2fec38d8380a6c8c17bfea898cb4eee2e8123", + "python/sglang/srt/batch_invariant_ops/__init__.py": "e277fb7cc6addb8f34f40a7692db170d4fe2e3474ec740fd6aa2b89415748ff0", + "python/sglang/srt/batch_invariant_ops/batch_invariant_ops.py": "9a9fdb89d84f8c392ae9a46f46c0a846b332e78f4ae77c24f240f8db55e6a6e4", + "python/sglang/srt/batch_overlap/operations.py": "4fa10e000917528813f53ec522a9bf61b90cfaa47f90436a2ec62c59821d271c", + "python/sglang/srt/batch_overlap/operations_strategy.py": "a9c4b5cbe65975058a68982f9d40a9a6afeff34daeff3bc162a91ec617dea47b", + "python/sglang/srt/batch_overlap/single_batch_overlap.py": "3c23bcfe109466ca63b46a925ac1ae1711c8d0703683673b3982c41b732f56df", + "python/sglang/srt/batch_overlap/two_batch_overlap.py": "ee395ac23f7722b9fc42ae05d4a64d23b2dc5d118ac90a3a8ffc48f3e8352a37", + "python/sglang/srt/checkpoint_engine/__init__.py": "15a5b6328c26066c089ec2e09e1f8278d2cb3f9b4f9155eda44ba3b4e6f25bd0", + "python/sglang/srt/checkpoint_engine/checkpoint_engine_worker.py": "67c1b669a4a36c56b0bbb1d7297014e55638c157b6ca5ec15b617a045f6dc187", + "python/sglang/srt/checkpoint_engine/update.py": "222774bdb2b632b4a9165c9609b445630053da8a549d478f9a4e6d60391901d4", + "python/sglang/srt/compilation/backend.py": "7c51043151a1050c0b870a4eb04a5ed477a2620c6c19b6f52766735968636fae", + "python/sglang/srt/compilation/compilation_config.py": "0eb0d6586ad6d28a194ffa084e5d4b326caa317cbd09d0d8dd809219d75aac41", + "python/sglang/srt/compilation/compilation_counter.py": "168ddfa11af24e4650290321ee9d1085412c57023a0976b592fa7101490dc1ec", + "python/sglang/srt/compilation/compile.py": "e80a9f13f23cfd073fc0a1d6075e8c8593dc26be9c7f2362611fa8937b5983f7", + "python/sglang/srt/compilation/compile_phase.py": "969248e4cd4a86b922bb2b09d429691b19c6a4333a86198a9388c445b88d5a7f", + "python/sglang/srt/compilation/compiler_interface.py": "8c66f1f363c9c76d7a4e74aa0985fee6506a24f3dc8678b5a62e3a9485f6c17e", + "python/sglang/srt/compilation/cuda_piecewise_backend.py": "1d7258fa1773fba3d0355a54f92a9f11cd866b37c618e9f45e0123462145b9b1", + "python/sglang/srt/compilation/fix_functionalization.py": "14c65bb9aac87a6046279ca22abdfbaead820dfe7f2f16e171588563e63a6be2", + "python/sglang/srt/compilation/fx_utils.py": "abf64f0e11f3d9243cd706c95d338559c3979c7d1e88a529949aefb905e29714", + "python/sglang/srt/compilation/inductor_pass.py": "8a54a6c65cd352c2b2fbd49107b10c8cb0587d90de3c45aa4e5f8cdc6c2fac74", + "python/sglang/srt/compilation/npu_piecewise_backend.py": "47bf1f91e134235867e954ee1c7a04ef25c36c5dc38ec4bae31c425a022f7497", + "python/sglang/srt/compilation/pass_manager.py": "8d36e29702bb5cecd1d666e9ef6e79ddbff11bdadbdc4a0dda1b7a16bba11744", + "python/sglang/srt/compilation/torch_compile_decoration.py": "86c7a5c495632bc42d22719f87f0ad0c8fadd52f189994243eec41d80b47ed28", + "python/sglang/srt/compilation/weak_ref_tensor.py": "3085290d6076f83aea4cbcccd221adbb55636367da1b9721be31946c68934cb4", + "python/sglang/srt/compilation/xpu_piecewise_backend.py": "ad31b9caceebb23503a5bdc093c4c14b278fcea505ba2688d94f049bf85428cf", + "python/sglang/srt/configs/__init__.py": "388f9df4bb3078eba0f03048b4a8bdc72325c1f2a1c7ac16720beb4012cdd1e5", + "python/sglang/srt/configs/afmoe.py": "7ab65afe8a3afb6934916907313ba8aadc3db3b733bbb5447399c69ad8e98cec", + "python/sglang/srt/configs/bailing_hybrid.py": "95fab0e74aadb9927a92c09d345beabf941228f2b8317110e4db2707873a3a9a", + "python/sglang/srt/configs/chatglm.py": "a1b9af316a8cad3ebcffc83103e3d1a748cae081ca3364f0ab73c5b2089526ee", + "python/sglang/srt/configs/cohere2_moe.py": "e62e7ae6f6a851ff94900b8f106600575e08768862f2dbe97c502aaf0222c36f", + "python/sglang/srt/configs/dbrx.py": "b5d848917010975cabd0cc6a166b031b51347b6a6e4534ca9ba513c803412da7", + "python/sglang/srt/configs/deepseek_ocr.py": "49d86bde31f77bdbadfa81b161fd32ee77834768819baa446dbc9da2c385426e", + "python/sglang/srt/configs/deepseek_v4.py": "9adf7030a4f6a39459934d28bdd3e7fb8def1f524bb91ce786212f4d404c326f", + "python/sglang/srt/configs/deepseekvl2.py": "d75a2c667ecfe3c591b5c2eb67aa20ab4d9386a9f504f85c98d29c97f334d059", + "python/sglang/srt/configs/device_config.py": "141b372d33a2f0aa3a7059f2f8bf0b1c30eda6032c69bad30f87b7c47a6af1cd", + "python/sglang/srt/configs/dots_ocr.py": "23093622e7984d04cec4fc3a4479b4c525fd850579f62de805a4dc8c6061c134", + "python/sglang/srt/configs/dots_vlm.py": "436a9a3fae6c6022869a0fdbbdce20e726fea5ab1d64dc78c679e5ceee847755", + "python/sglang/srt/configs/embedding_model_spec.py": "0fa197fbb5cec16b4bc6a0a02088fdd672a01ab77044ec68251fa74ba7177b32", + "python/sglang/srt/configs/exaone.py": "a25dd4679414f075e5edd34af38945f451138d4c51d2d0937ecee477f66f98e7", + "python/sglang/srt/configs/falcon_h1.py": "b3530c0499b64677ec0602d9d2c334421a6e9e2bb31265bbad55894f652e1622", + "python/sglang/srt/configs/granitemoehybrid.py": "1c5628293eeabcfa742dddbd9f29835dc698aecb0e9df9ab954c7af2af99cc0b", + "python/sglang/srt/configs/hybrid_arch.py": "48b4bcf47cffb2cd71b835588979edd3b80c6539a3328567f35f36f550a8b7ce", + "python/sglang/srt/configs/inkling.py": "cb0fd450818a2c0667bfd387423f7a46b97a976616d3fddfd933dd049ad62c6f", + "python/sglang/srt/configs/interns2_mobius.py": "a8dd86da6d06667293918acf21315f6d41500ac1f23ada810cfbc8a7c62dd41b", + "python/sglang/srt/configs/interns2preview.py": "988c6190727a5a3fae89184dacb8c0670e0a3a0eaf7cd6e05d6372ff8db34940", + "python/sglang/srt/configs/internvl.py": "1bd0d64b0414ae1bd48486ffe46dff08c9041ae93adcebc58caf6c2ffb925733", + "python/sglang/srt/configs/janus_pro.py": "3575df5c35a1ffc9d0a885d578b0f29343575311972a780a4e111107531e4e10", + "python/sglang/srt/configs/jet_nemotron.py": "832c015209fc1a2f5003781b730a0fca5782e942c98a0c13fbc1a4eba4586522", + "python/sglang/srt/configs/jet_vlm.py": "503e645fa2ae2940aa619addeb6c8f6ea8752d9bf8138674c9f2f75762efb3fb", + "python/sglang/srt/configs/kimi_k25.py": "30210e7ef5c728c69ee4ce6975903e82a22216ff896c63f2758468cc753e7af6", + "python/sglang/srt/configs/kimi_k3.py": "e4e9adeccb746c358880e1734a98073ceea58acc21353dde2a33107ae76896ce", + "python/sglang/srt/configs/kimi_linear.py": "25d7c7fa629626e49a07cb78daf63aab5f7f32456a652ece2813bc24c2491685", + "python/sglang/srt/configs/kimi_vl.py": "6049ff02df4d0ce0e816622c1c6f33dc8092b5c7f991412feae895b63a70e737", + "python/sglang/srt/configs/kimi_vl_moonvit.py": "871d91b7825215bbf2d8751378b8c1a607bcee6f0ce884c086ab2074d7ff25de", + "python/sglang/srt/configs/laguna.py": "f4c9139ec09cc1ea1fb92174453c003b8998d0a0a8717b34aa51653cd6d080f1", + "python/sglang/srt/configs/lfm2.py": "0763b5bb25964872d4c6833f401b2baab08425612b5b75fd7253d643789c936a", + "python/sglang/srt/configs/lfm2_moe.py": "a948fc589dea7a31d54102f1186fb31783b18afd7ec09e7dfa2a85567ffbf1d8", + "python/sglang/srt/configs/lfm2_vl.py": "9ca6f220a548849f04109a215bd8bfd17a98a35d58febea044046d5d90b5be7c", + "python/sglang/srt/configs/linear_attn_model_registry.py": "34478d80112b8ef8ebda86b8b85b5a7ce04359fa2baf013cf19432b7e7980606", + "python/sglang/srt/configs/load_config.py": "b404a18d3f0153f43dc24b6c28c6a8932ac76e19dd7b710efe755ec96e2b6117", + "python/sglang/srt/configs/locate_anything.py": "30223f8d0865ac98815ec9967fb6ed8abe3f5af47ddb547df86e84aa7f742042", + "python/sglang/srt/configs/longcat_flash.py": "b791b526e912b4c43660912ab5e8dc642575ea2416942c366e2bab2d041be8bd", + "python/sglang/srt/configs/mamba_utils.py": "820627a476130e36e8c9aeec2f1ded01d0c068369149e014cc0ef074f1e90808", + "python/sglang/srt/configs/minicpmv4_6.py": "4ff4f19844846a36feb303042ef257e6ebffdff0173f74fd3ec449e4336f226d", + "python/sglang/srt/configs/minimax_vl.py": "85528b038441724e90aea555d9e8d28575810b9f078889fe4c9fbb7ad4a8a915", + "python/sglang/srt/configs/model_config.py": "f3c7f7648bb80ba1ed07f839376779136d98f04cdd389f80112883720b741712", + "python/sglang/srt/configs/model_config_parser_registry.py": "4f11ddb4ecde882e267f96eaceb6e61efc4b38f72f9f977d91fb8d113c45c2e9", + "python/sglang/srt/configs/modelopt_config.py": "a6be10fc9e06d457fec32db805847359a374508df8aeb78679fecdb7a7745f73", + "python/sglang/srt/configs/muse_glimmer.py": "c814216a3470abb67abea26bf82bfc2fd2963980e43527a1188741650ad3607b", + "python/sglang/srt/configs/muse_glimmer_processing.py": "e822f8d7fb526e6ab8188ed47702044b24782da062327a08ef10581f9a8ac59e", + "python/sglang/srt/configs/nano_nemotron_vl.py": "b7ac0cb5eee99f39cf744d8ef98a0c98311bcb371d01e5c6d9638d3104c31a35", + "python/sglang/srt/configs/nemotron_h.py": "9b6c4a801032da1b5404fe5f04e5aee1c9d60252d0d650734d9eefe2eb304889", + "python/sglang/srt/configs/olmo3.py": "1d000a323ca4883ea4cd80af01885b7a874d56a82a34ea1e1bfb6f9bbe3c3313", + "python/sglang/srt/configs/parakeet.py": "09efe3620d488685e1a11c2236028642ceef182ff152aed3520e70f3f44d6141", + "python/sglang/srt/configs/points_v15_chat.py": "a9a9dded631cdcbf7ac20fb0cc0f58aa7ccccfb65433aaae02e4e18ced6b7ccf", + "python/sglang/srt/configs/qwen3_5.py": "72592dde421a945050b7f3e16ac0ffc9836dfadba16fcbccc473bf1ee9e9f1a8", + "python/sglang/srt/configs/qwen3_asr.py": "3ce79252169d974a777a3c7226d6a4186696143c0d1fd039f19249b10cd1d719", + "python/sglang/srt/configs/qwen3_next.py": "071ce509469c3d3320a7c7dcdb58702a53045fa9856d1c858501e2740b9c5df2", + "python/sglang/srt/configs/qwen3_omni.py": "843096226e123f12de5d1ba6dc62c3f0080787ab57da54bd7b094d0f638fbdcf", + "python/sglang/srt/configs/qwen3_vl.py": "3d5d16958d65d7de6d3268ccdc30b8f7508853f1ff0bba9606c0ef5be7b426fe", + "python/sglang/srt/configs/qwen4_exp.py": "ad2a5a26bb76b8df281b4c27271b827eaa9d0df3e6561a5e593f3f3095acaa0a", + "python/sglang/srt/configs/radio.py": "bc6557ca461e83c76b938949eda17d65cc8d0596a93e7ee54a94bd1d85660966", + "python/sglang/srt/configs/step3_vl.py": "fceb609f29b9ec356007f919ffff1cd7f62ce6049a940fcad19b958dc1b9d53d", + "python/sglang/srt/configs/step3p5.py": "3c816182ede55d65fd9200be63fb1cddb55c2eaf54fde830d5e0da1ac46eee91", + "python/sglang/srt/configs/step3p7.py": "5f2e2f3a538f38ea1b4d67ff4cd2ff72233b00519765df9c4a67dec332c1958c", + "python/sglang/srt/configs/unlimited_ocr.py": "12897bcb503f2f5e7ddfdff85323aab335d58734aac87cfcb4ae6828bc03bdad", + "python/sglang/srt/configs/update_config.py": "31a2609836edd20659c5876687e75bc4b42f1ed44c647ad2920005f722a406fe", + "python/sglang/srt/configs/utils.py": "25ffe3de229612d00dde2dbb96a0f7c945ea77f7f0ab6700dca16972dbd1f5dc", + "python/sglang/srt/configs/zaya.py": "16935923c2cf235182682fa6d78618e1f44513a7266ccbfbfa3737112ac0174a", + "python/sglang/srt/connector/__init__.py": "704cb5da6e56637690e5716243bf910e72f963c4dd83f7a3a253a5c18af05a8d", + "python/sglang/srt/connector/azure.py": "3242adcc7b713499b0e2bc0bc47aeca55c2bb2b53fb8f2ed767b69a7de5f8208", + "python/sglang/srt/connector/base_connector.py": "2c22ac4d7ff25877253ebccd341d5f2f054237cac80ca65a661a87439e01f4c5", + "python/sglang/srt/connector/redis.py": "2b77c94a6dab66c77447f2a42025778c858ab6bc315c4d6d624b569e8bcb6f3e", + "python/sglang/srt/connector/remote_instance.py": "42f3ad17a899487ffcda88dca0464cf5eb01420909a8baa20098e06ca84b8042", + "python/sglang/srt/connector/s3.py": "867e4ec3d63a22d4bc44c243c274d07b941a890ec728c822c20804f509d47b03", + "python/sglang/srt/connector/serde/__init__.py": "cee95ec9837e8eb0f288f8978d36d0280dbb9656f81fb1ee0d365c070acb9355", + "python/sglang/srt/connector/serde/safe_serde.py": "5d28dbf6646fd47a9e1ba262c3adf710e41896b708db7436d5496e62a3d96960", + "python/sglang/srt/connector/serde/serde.py": "9f9f48d8c5cb6bb582c8dffca4477c2feb1c264ee53219845fe18e508845d190", + "python/sglang/srt/connector/utils.py": "8ac4efc5abb3d7ff27a39316ea9f01c23d87f66424c1e6913bf452c003c0ed1f", + "python/sglang/srt/constants.py": "763bc7110ea28b1454768f722f10b58065618d3d160b2c5b9746fd95f6595008", + "python/sglang/srt/constrained/base_grammar_backend.py": "6bf74add13594e0f7bd26f069be39c734e0edc01cf480d4f601df7c76806434f", + "python/sglang/srt/constrained/grammar_manager.py": "dc4c94674191877a689c671713c739ab4693675f4fd26f68331a4751ecbc1903", + "python/sglang/srt/constrained/llguidance_backend.py": "34150debf617586cadbd3aab921cc151118c99d088e09c1beed71f4940cd2fd6", + "python/sglang/srt/constrained/outlines_backend.py": "ffef75513c79b201136730343165a9ee7444e159faa50d4c7f77bbbb95470dda", + "python/sglang/srt/constrained/outlines_jump_forward.py": "766dcf56cc31da813f25f02ffad3ddee2acc23de550aae1c653f8017e3a1c77b", + "python/sglang/srt/constrained/reasoner_grammar_backend.py": "6087173aaf0434665bdb57a4c8105407a44a7dc31fab4f9e66a19ed6666c1374", + "python/sglang/srt/constrained/torch_ops/token_filter_torch_ops.py": "019bb1e4b1c1f9d133f4fcd3849c81f58677e6b6fe21c697828c8e3e71753041", + "python/sglang/srt/constrained/utils.py": "6435eec8a8c66077cfa37661720c597bba64fd06f8fe29415765a36c34572837", + "python/sglang/srt/constrained/xgrammar_backend.py": "841651917a3a302c7a08ce1743aa284b3914e96b95c20cdfbf61df84125b21f2", + "python/sglang/srt/cuda_vmm_utils.py": "51b28fa463a48d89834efb7001fb10f86d7246e02d886479f9b51b2f80041562", + "python/sglang/srt/debug_utils/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/__init__.py": "ba899925697e772004b7006a273ba4b921c355042b6c7ea774b4ac582c8a3904", + "python/sglang/srt/debug_utils/comparator/__main__.py": "03c35164c976258d62a689631670a8708950e892904587c5f434406ae6a21238", + "python/sglang/srt/debug_utils/comparator/aligner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/axis_aligner.py": "5bd5cb33219bc892935ea5dec5f1c76dfec5bcb083f2027c55fa859a1e35e574", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/executor.py": "6357cc1ec00fd970650582d5b9e67354bab72be3b4b3e8e9e3f004b8af1405da", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/planner.py": "5a2ebf4b06c3d3b873ac557f0ceb88ea3607ea88c6395a0f9b741eb5dfed5bae", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/traced_types.py": "1b726e91f716ffe5619e5cb24c66ec51943ee222cd496dc3322c38614c66273d", + "python/sglang/srt/debug_utils/comparator/aligner/entrypoint/types.py": "e7b05cacd428ef416cb1ec841742f9407980c23dec611ef2ed395ed9134d708c", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/executor.py": "d5358363b28da93650eed8ab53d08759064db776114cd062ec0656ef3e7acf43", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/planner.py": "706bdd7b9ad08ba66229438196cf430d7e981c9454b2f82414c66acd978cdfd2", + "python/sglang/srt/debug_utils/comparator/aligner/reorderer/types.py": "07b9f9ff535aa2a0784dcb3da9e73ab325c5a81cb896992866f782a86bc37737", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/concat_steps/__init__.py": "7fe61fc5a08193360663da64a88b72ef8fcc3f65b0158f6bc669a6cfda0c7a72", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/concat_steps/executor.py": "8dc2c35d646be7e17bb51f4d1489f881251923dbdfa3fb6e0b1dcf21ce0b925e", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/concat_steps/thd_seq_lens_loader.py": "83856e6b531064768ac1acc07f70ba9ff60187976795de390fedc57cf1674aff", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/entrypoint.py": "4b3bac51cf0d92517c72bc0a24f9bb96673bbb11a37c3a209ebbe9524b4d3e36", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/aux_loader.py": "16aba02f0575409def056b015df45d8721e4a2c95884e6ea373f634dad1a0909", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/aux_plugins.py": "928733bcb4f435bf3ac4cde31ef52ef92703f151806fb261bab70c75acde46a0", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/executor.py": "5385ad7e3ba6dbcab9ec4e7f11184b5e965e298925ad2e016ea035c941a35089", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/planner.py": "4b7a26f545265817541d0092beb8003da2ca358c0677134d6d231f2636e75dc8", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/seq_info_builder.py": "f7255824a0e700cb6fc189afa4c33f75d4aa841c4a5aae379bf6c2b89f89dac7", + "python/sglang/srt/debug_utils/comparator/aligner/token_aligner/smart/types.py": "52fc9981a45d10033b41df08b962032da6b0f8b18a999f5e4649ec6d0c166669", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/executor.py": "3d675494348bbd827361e6dd16fa8409b516991ca29cf8cfd141c070074ffd1f", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/parallel_info.py": "b329865a2dc4b496a6909a08b25f0d95aeb0c19dc963cce9fa3286f0ddc875b0", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/planner.py": "d9dd33cf4fa77c633d44b6ef0d86557d0dbf12f4c817088e36d7882282179f04", + "python/sglang/srt/debug_utils/comparator/aligner/unsharder/types.py": "4d496ecf4478a23a85bb10094f383c762aa7a84998ba36bda157077f4affb5ae", + "python/sglang/srt/debug_utils/comparator/bundle_comparator.py": "8fc478891082c0fb26910d4e1a7d04120e7f11cb95172279d6774be561398b4f", + "python/sglang/srt/debug_utils/comparator/bundle_matcher.py": "0d76a932b2d8c3fe645764aefcdbcc786680db752f3b33cfef43e1a7928a7ae5", + "python/sglang/srt/debug_utils/comparator/dims_spec/__init__.py": "56c9da9703564fa42dbcfb01543a5e7f5e2b1acc0df035667edd731b44575cf6", + "python/sglang/srt/debug_utils/comparator/dims_spec/comment_parser.py": "6483ebf41a165e05c68d3e0562328a15cd947e5ec43cab12e6d6acc65af9e57b", + "python/sglang/srt/debug_utils/comparator/dims_spec/dim_parser.py": "b0520f348fc496a2a30dbecc9fc17162691626ef43912bf293e7c088f3099408", + "python/sglang/srt/debug_utils/comparator/dims_spec/dims_parser.py": "be475e593f7047b5c20ccf1dabbd71016ad946990c18ed884b5fef7ae75986c9", + "python/sglang/srt/debug_utils/comparator/dims_spec/modifier_parser.py": "532b1c1d6322f0cf91fea7d0e3410a1110064107df4448cc13faccfc5c7bdffd", + "python/sglang/srt/debug_utils/comparator/dims_spec/tensor_naming.py": "529602f555d92b3742ae643c4da4d50e338b09cbef8de3f3429f72d530184b3f", + "python/sglang/srt/debug_utils/comparator/dims_spec/types.py": "382ae1758d94e30f30c8f479213300e37b483fef2b7021613548c8c504bb463d", + "python/sglang/srt/debug_utils/comparator/display.py": "77408d505b99430652a9e7d4011a116dc31848c205765a030291e9ca3e7ce916", + "python/sglang/srt/debug_utils/comparator/dp_utils.py": "84400e5e24870b45bb571df3ec368807f9ab1a8581e814e210ba6303c9b968c8", + "python/sglang/srt/debug_utils/comparator/entrypoint.py": "9ab81ec2b9dac39036af50ed9fccfe5e3b5b6470e707b76539364c574c845ba4", + "python/sglang/srt/debug_utils/comparator/log_sink.py": "1ac2c147568fc654f15c4873021fce2caff54f739dcde1821baf0286bf4aea97", + "python/sglang/srt/debug_utils/comparator/meta_overrider.py": "401f7d4046dac7ec8ce37dc5db0159de9c7a9e52608b9083eedac86852630a60", + "python/sglang/srt/debug_utils/comparator/output_formatter.py": "3467b9dd45ad860149e8b3fd28f5b6b75e10123641373d1bf06945727837b222", + "python/sglang/srt/debug_utils/comparator/output_types.py": "e44d68b341983720d47ad2837ddad20e107b6dedc95ed2aabba0e3c004b03927", + "python/sglang/srt/debug_utils/comparator/per_token_visualizer.py": "5cb7281c5a069ec59683ddc235bd25f734583d60ddb4ba72886ab44092389708", + "python/sglang/srt/debug_utils/comparator/preset.py": "6c3e37ff7740c70fb107568ee052183da9ba9f81524e843eef8d1e7da19a9eb6", + "python/sglang/srt/debug_utils/comparator/report_sink.py": "a99936f8c3f16d96fac1cfa21daab1855302ae66128c8671122cc238d9097911", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/__init__.py": "cd2a1d53637ade9e059e68f035b9cfe128cd818e04aca67c34d7a28232c5aeb9", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/comparator.py": "9145cf7268a7d62d229774838743c8903902d53834ad6ddf1c877430841dd986", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/formatter.py": "29103f1001727bc9c76f9da509cbab3bf061da9d6294c289ffc9a2b5d685bd3f", + "python/sglang/srt/debug_utils/comparator/tensor_comparator/types.py": "75ab76c25508b582f692a0b7cb1f3671b38407251e22e0d2e5126f497310170c", + "python/sglang/srt/debug_utils/comparator/threshold_dsl.py": "12f8d64c54531eba8dff66c82b5c94f7cd5eaa19cdf3a490b6b43c035c9015f3", + "python/sglang/srt/debug_utils/comparator/utils.py": "f4fcca8b10e2800d5ceccca1ac7835f79c4a98cc6be3cd6a3945f80127c40681", + "python/sglang/srt/debug_utils/comparator/visualizer/__init__.py": "44943a29e99fe88b4581f4b5bf6297f70d0a2240964d6401f8d4664dc4eed897", + "python/sglang/srt/debug_utils/comparator/visualizer/figure.py": "4868cc81a725f1173204c74ac3fb9565c487a641a73b02d0f85b97c74a10712e", + "python/sglang/srt/debug_utils/comparator/visualizer/panels.py": "7d7f11aecd0b88149f95efb7cad0a28e4c2cf136d6256b7e7cae5a7d66a90a13", + "python/sglang/srt/debug_utils/comparator/visualizer/preprocessing.py": "8c95090499deeddfe00ba4c4374f2b9342b6b95825637c49a6e7c956d75442eb", + "python/sglang/srt/debug_utils/cuda_coredump.py": "3c988b25ce932682ed7107187597eebd0b9ac507d6fb8f164bbb3caa32808ff2", + "python/sglang/srt/debug_utils/dump_comparator.py": "85d69da52a5df9f1cd03f77da52675e34172378f3c6a6dd9595ecfe9ec97955a", + "python/sglang/srt/debug_utils/dump_loader.py": "1b362653debc9b64028cb470ba5b4154a4c9ced321ce2e28e430b0dae41b45be", + "python/sglang/srt/debug_utils/dumper.py": "57d9bafc9dea9d42e8abb7576c6010f070a065655f07ad66456b49113e261f86", + "python/sglang/srt/debug_utils/log_parser.py": "5dbfc6315d4d785bf3159749c6fced6008c75aea1aa8cf8a00b85c8817cbe409", + "python/sglang/srt/debug_utils/model_truncator.py": "23b64417aa8f9aa8c5c18e24cb813816da16af1a079fa81e5513ac14b1516a0e", + "python/sglang/srt/debug_utils/pr_fix_toggle.py": "4127ecac4471b48749d7396d77be1599169906d425b88c47642b1bdfad6a042a", + "python/sglang/srt/debug_utils/schedule_simulator/__init__.py": "be50bbf5e92de060a8cfecc831bcdb8609bd0f490db225f8802fa3d1a8eefb2a", + "python/sglang/srt/debug_utils/schedule_simulator/__main__.py": "6a22701f5fa52c27ffba46d8ed6f00c6588cee1189cac2b6eac09fd7d63d13e4", + "python/sglang/srt/debug_utils/schedule_simulator/data_source/__init__.py": "0053b87e19565964b92f4034281183dc8658cf1965aa6622cd5bfba9a5e5d22a", + "python/sglang/srt/debug_utils/schedule_simulator/data_source/data_loader.py": "8b0145833ddf087466c7bd52f43ca6570c265ccdffcfd9f58650761f37622a60", + "python/sglang/srt/debug_utils/schedule_simulator/data_source/data_synthesis.py": "2db55c12bdeb311fc836b26d697b5f20a323bd49bdc279cd56f33efe71b2d1b7", + "python/sglang/srt/debug_utils/schedule_simulator/entrypoint.py": "cc9efd82716dc6af909257b54bbf0b34496c797ebd1aa8c47f2bb86b2569f4d6", + "python/sglang/srt/debug_utils/schedule_simulator/gpu_state.py": "14b3a6961c92dbd7e12c7378e8fb3cb271f1d656d9691e2c5e2cee6fc8148f6f", + "python/sglang/srt/debug_utils/schedule_simulator/metrics.py": "6924f565b7a383a0d3ab535bf5b7db06b862adc7f08b24d7ed8f3c9e741c5ea1", + "python/sglang/srt/debug_utils/schedule_simulator/request.py": "4c131bdf9ce5ad0a1fee449ad75b8149d7d56fa917567cbe483ca000af43d6da", + "python/sglang/srt/debug_utils/schedule_simulator/routers/__init__.py": "7dd9829746d315b52eace6e42de74235f7bc4e14b78e8599ecd332eb3347f3dd", + "python/sglang/srt/debug_utils/schedule_simulator/routers/base.py": "130391a3c01b4a0b171029460c689071f883c3072d891c8adae4828f56322e1a", + "python/sglang/srt/debug_utils/schedule_simulator/routers/random_router.py": "b8b249cd5e5f39ab41b9e7f2e09f8ba4d65cdac86d61054e1aaae427c24a3651", + "python/sglang/srt/debug_utils/schedule_simulator/routers/round_robin_router.py": "01f001ae738dfcc4827efaec81812ffc0d5876519dfac2f7d6bc88b3c9760ef3", + "python/sglang/srt/debug_utils/schedule_simulator/routers/sticky_router.py": "641f0cea9d16f4f1ac3a8532acdc0a612fdcaee452caf723a9d1f6a72c065b07", + "python/sglang/srt/debug_utils/schedule_simulator/schedulers/__init__.py": "db56bc0e85b416a109523bf79df4d75dcc5867fa9e9876d4df1a275852a93b2f", + "python/sglang/srt/debug_utils/schedule_simulator/schedulers/base.py": "3d6045e82080d978fa3d4b5d25f856b98c9a0fff019b93982c99d50c88e8c97a", + "python/sglang/srt/debug_utils/schedule_simulator/schedulers/fifo_scheduler.py": "77b9cc73f537206969673037837310cd74c76633e28c9d8c25cf0aae59a287e9", + "python/sglang/srt/debug_utils/schedule_simulator/simulator.py": "8ca17b8189bc2607f859b64da6d48b3d04367b972b5f37197cbce5aa90b2f9f3", + "python/sglang/srt/debug_utils/source_patcher/__init__.py": "ee249b365a88fa36dd5d6ef0640f67514e96a2acb960b7931b471d931d3844b7", + "python/sglang/srt/debug_utils/source_patcher/code_patcher.py": "5e77ac348627d6e8356d5f31171daf83760a3d102717f1c7f827236f33d82d7d", + "python/sglang/srt/debug_utils/source_patcher/source_editor.py": "32d4c2da0ce8084b62a08e98111c22a7439bf5c0bf8508a5ec18a6d993b7425f", + "python/sglang/srt/debug_utils/source_patcher/types.py": "4bfdb4296d54f9a845a717502f41c292e7f0b6cc0c5c35971197e89d55a4b975", + "python/sglang/srt/debug_utils/tensor_dump_forward_hook.py": "bd5e33a56fec09580c4e97e09b8c64cf9201692ed08478d10fd73bac688a1c13", + "python/sglang/srt/debug_utils/text_comparator.py": "34b25d8d48a45bef9b5a719058878525eb32baf6765678b64b9ddf2040fe9bcb", + "python/sglang/srt/disaggregation/ascend/__init__.py": "fa5c6789c6ba7d962660da4ac2613cc84494a50e52c5fd83899a011f36e829cf", + "python/sglang/srt/disaggregation/ascend/conn.py": "fd2545df9bbf4d35d1e09217c5652781e1249f5c8ca25a700865b7dfb8c58e70", + "python/sglang/srt/disaggregation/ascend/transfer_engine.py": "f51f8e1476bbbfb219e41e75e768d5afc73d5ba84612ca9c31795480e347be4d", + "python/sglang/srt/disaggregation/base/__init__.py": "e15c14bf4696c709952f5d38f572bcd9a2d33719add1663944fcbd962fb0c959", + "python/sglang/srt/disaggregation/base/conn.py": "c3d84c421281ed0c5c4da6309a1efaafc5f66a802ce8a778c63c01903cfeec0b", + "python/sglang/srt/disaggregation/common/__init__.py": "ef297e1062cc54a46905468617fee5c00b30d89fe6aa9459574db7f151b10fda", + "python/sglang/srt/disaggregation/common/conn.py": "dc28d75e40b63163334b78e097b5eaa07ed768d596ce4c3903297cd20a3debf3", + "python/sglang/srt/disaggregation/common/staging_buffer.py": "85eef58786fc4132772b378a712600d1ae23834d4d8b1bfef553cb26e730d739", + "python/sglang/srt/disaggregation/common/staging_handler.py": "501a6476d345a1c795b2bc5cd56bfbb54e66e1696f882172602b74899982908e", + "python/sglang/srt/disaggregation/common/utils.py": "257f4d3df55e6eb3e1368186a410a6f73380f03444faab9af5f6966ceb986c5f", + "python/sglang/srt/disaggregation/decode.py": "28b8406736abc1601ccac6e1e73ee5827bc3eb7527c3e34ea824ba91a132bc52", + "python/sglang/srt/disaggregation/decode_hicache_mixin.py": "9c7775030f97c542024e48da95af001a392f52ee589658a38635ea0303f171b2", + "python/sglang/srt/disaggregation/decode_kvcache_offload_manager.py": "fb202374c211c3cad7a6ca39bbf00dee4877268e9e3c14dba9f506a3d190502f", + "python/sglang/srt/disaggregation/decode_schedule_batch_mixin.py": "c9bce6e98d54c415794eee6c75eeda96e168c64a8bc526c06e2f3960c01bb40a", + "python/sglang/srt/disaggregation/encode_grpc_server.py": "e48a34147806d9a66904b43fef34766c34355c213acef5356309bda8ef6ade4a", + "python/sglang/srt/disaggregation/encode_receiver.py": "54f11034ba24bc73ed50b7b5b44186feb371e7a005ac18885c2d0444f8d87ef1", + "python/sglang/srt/disaggregation/encode_server.py": "f990cc97fd1ba474828993f16a3455b25d21bc570ced5c39e3751221956c06f0", + "python/sglang/srt/disaggregation/fake/__init__.py": "9513a6c428234978b619d68e1eb1cdfb3d6c9ca4c075c3f56ddc2da0b48d612b", + "python/sglang/srt/disaggregation/fake/conn.py": "b0d6a7889317b68308bc258a56bf2b72b8feae7b4ad37a272f9372904d204375", + "python/sglang/srt/disaggregation/kv_events.py": "656a6340cbccb758720b3c63517c078f943f5a438a7129d12a545d0d292ff8fc", + "python/sglang/srt/disaggregation/mooncake/__init__.py": "d1382a9007502356329db1d8e9cd10212bd5a0e4a4fb44b0088ab9ae33d29a01", + "python/sglang/srt/disaggregation/mooncake/conn.py": "5bfac4cc28ee29368d4f73e317be2c2bcf637738f28f03aa5ee81017bb9d45db", + "python/sglang/srt/disaggregation/mooncake/utils.py": "485af0e04627b3c9924c140791365e334d8320d004808c8abf228dec7240f65c", + "python/sglang/srt/disaggregation/mori/__init__.py": "0420a96d3e9123efc762c340b0024959679de25e95c997b8e72e2eac030a0800", + "python/sglang/srt/disaggregation/mori/conn.py": "8f540fb0a31fa521764cc63da0e794a6707fa77684703ae2ea029ebdd2b4a385", + "python/sglang/srt/disaggregation/nixl/__init__.py": "a8e0d53c8196517297ab8cec44870c62802801e83a9c120df6f7503a554c00d1", + "python/sglang/srt/disaggregation/nixl/conn.py": "b682bc4f567d08734ea1c97de69c2356fa3045c84365503d8c138c0f7c7660d9", + "python/sglang/srt/disaggregation/prefill.py": "fb3bbb73be9c15900d06fa0a35ba4404d0942b86532e1456a61a00fc58a8b1d6", + "python/sglang/srt/disaggregation/utils.py": "b10628773d806f4b36afa25ad58f37390fe3d230392842e0f8c749e95bf84c4a", + "python/sglang/srt/distributed/__init__.py": "8c539ccadfb01403cc05401ff739196a535096dfb8aea993ea908a073d44e2aa", + "python/sglang/srt/distributed/bootstrap.py": "7516a5dfd3850a561fbccc272bf8762fbb293ce3f9101c662dd1d3cb28033ebb", + "python/sglang/srt/distributed/communication_op.py": "cd887fe137e5af7a7d52a8c6005abf82ce374717445259996306ca9b8a5eb0c4", + "python/sglang/srt/distributed/communication_tags.py": "b7d784c0f7d7f780b58097e9dbc81d6d99348c1241416fc55ebf0192edc00539", + "python/sglang/srt/distributed/device_communicators/all_reduce_utils.py": "df4c56d0dc1293c41caa3bc27779bc58eb2823f89aef70b21911a90a259864e4", + "python/sglang/srt/distributed/device_communicators/configs/__init__.py": "c6ee6b29d0caf265aff5dc0d03fc7cffbf8a0c855064c2b053cbb86ba0cad85b", + "python/sglang/srt/distributed/device_communicators/configs/custom_all_reduce_v2.py": "45d3ca8df482cb66363498e3d8fd80821adf2adb3f37f6ad083aa7263e655b7b", + "python/sglang/srt/distributed/device_communicators/cuda_wrapper.py": "a04c2ccd99745529e937479d5ebc6e1c71f6b24837572711e1c60af27f3e01ab", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce.py": "fe4ef6eee5003f0422accd49db00e2b4523e516645aeba2a2a63d545cfbb8de5", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce_ops.py": "f184bca25226c0f50faa293cff0e5014ffd38037631c614c86fee28827278ce3", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce_utils.py": "92445ac35010cbad04da7777d0b4f7d83f941845a1a527535de5337671030a38", + "python/sglang/srt/distributed/device_communicators/custom_all_reduce_v2.py": "73c91972c29b06bade34438dcab21b21db70bee65722f264bf907118f223131a", + "python/sglang/srt/distributed/device_communicators/hpu_communicator.py": "9bb3dd5f928a696cd54daac574ac3e07ab62de2266adf2040721162bcdb90144", + "python/sglang/srt/distributed/device_communicators/mooncake_transfer_engine.py": "14b672668a09728ad09afbe826780657db40641d06a0e0c645c8a70fd5be3054", + "python/sglang/srt/distributed/device_communicators/npu_communicator.py": "379821f6244ef5eedc22fe732a214223a45a2a0f4d62e5c097f6609cd3889f46", + "python/sglang/srt/distributed/device_communicators/pymscclpp.py": "acf231612b176dd5c9775ab02d00b00ecb11cb521b238e6ee160164453c73c03", + "python/sglang/srt/distributed/device_communicators/pynccl.py": "54552a59dca74451e5553d8684a0ab112a7c8abf5b7b4c6ad524322f30a1e6ac", + "python/sglang/srt/distributed/device_communicators/pynccl_allocator.py": "f48992132d2c46396e201ec0d8aa8375d9e50b20aa7460f1421cb000e9cd99e1", + "python/sglang/srt/distributed/device_communicators/pynccl_wrapper.py": "e1d5df28ee32a5fe19238834107c6b2c9b2b33b28e8300d7fa337e28d4ecb4b5", + "python/sglang/srt/distributed/device_communicators/quick_all_reduce.py": "67e08aec7f57047e8d0158507cb1501b87809c1469b71740f630a9077d10d427", + "python/sglang/srt/distributed/device_communicators/shm_broadcast.py": "c7c43695929f1c89e42c7913b00b7c18a0edb9016604cb823d46ca4d9ed8554a", + "python/sglang/srt/distributed/device_communicators/torch_symm_mem.py": "e014a5da40b1ccba8595e583591afaf600d425043035f1f8f24067267ff9b87c", + "python/sglang/srt/distributed/device_communicators/triton_symm_mem_ag.py": "9dc59d39cd9cec94b29fcb430876a1f4ec1b6672812e1087cb230eddaf508184", + "python/sglang/srt/distributed/device_communicators/xpu_communicator.py": "10a5cca32a8927562ff45d3c8ea40f9089222c56055ae909134fb05d321ffba7", + "python/sglang/srt/distributed/naive_distributed.py": "197ec21e151bf6b210b9a20f5f84d89b4d52ed741d057bdda9a2683ddc45c802", + "python/sglang/srt/distributed/parallel_state.py": "2ac5574bb2eb79c7f2c5db31f1ad8f98d45f7cf97356019b2e1d5a80ad2c2997", + "python/sglang/srt/distributed/parallel_state_wrapper.py": "910ac5af01eb34f2c2a5abf4699f5a40f637989d727bb3beb657e68e7ed72e8b", + "python/sglang/srt/distributed/utils.py": "4a77a5f0b658e3917524c608ab6671e7802ca317593238c24c3572340632dc87", + "python/sglang/srt/dllm/algorithm/__init__.py": "d82c8387e0e9273285b1af703124ac82559103dade001a6d5ce539250091e63d", + "python/sglang/srt/dllm/algorithm/base.py": "897aa76dbb78e5788bd3498832b852153042bc7afa65aa81ee935a981144af66", + "python/sglang/srt/dllm/algorithm/joint_threshold.py": "6737b59f5c15413de1cac22d1097ee53dae854406dff61d58a6fb18d826c14e4", + "python/sglang/srt/dllm/algorithm/low_confidence.py": "a26bd3ef20ca6d930b775289f72faac1ed1f8e9e2ccdbdb850378eee9a43746b", + "python/sglang/srt/dllm/config.py": "ce954cf0983ebb9ff3503f00e2fc2dc423c21b0c530ae23dd56856038a6fd057", + "python/sglang/srt/dllm/mixin/req.py": "e226b29777fded0e6748416d93c08f34cb6513f0ed77a696f4422253b9f659fa", + "python/sglang/srt/dllm/mixin/scheduler.py": "6886f4c1420ad256d796bf7f3f5fd31c1a2fbada26ed8cf985a30edfad1e6d7d", + "python/sglang/srt/elastic_ep/elastic_ep.py": "b6c63a9ff106bc957ce75bc2152e7d847e5360d4dc88cc8d82faba48273578ea", + "python/sglang/srt/elastic_ep/expert_backup_client.py": "66efd9f51210cc2aaef5b68eec866a72d5c60e41223b4917b55aaae3fe2adde5", + "python/sglang/srt/elastic_ep/expert_backup_manager.py": "683e33cf46ef9ba7a87950c4b6dc04cc2cd6a78df6f7069c491a348e769be0f1", + "python/sglang/srt/entrypoints/EngineBase.py": "e9cdddf9e4a9e74663d445b69458ebd24f69a43f63e42979fe0923cf96140473", + "python/sglang/srt/entrypoints/anthropic/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/entrypoints/anthropic/protocol.py": "ca5ee76a2f4fa02fbeb4f2bd43cab2914a36137a0f0c622aeefed81cef16b2dd", + "python/sglang/srt/entrypoints/anthropic/serving.py": "4ed918fefb7fe9fe3906faea105ff8b67fac15d987aedfb39e33f305f94dee6f", + "python/sglang/srt/entrypoints/context.py": "cb408e9626344f07a572dbaed8ce88d51a979be07725f4adacff41e33478ddb3", + "python/sglang/srt/entrypoints/elastic_ep.py": "1f86efb98f7b364f56d41c784226bac6ff6d05809086bc8bcfed8025ae0d5590", + "python/sglang/srt/entrypoints/engine.py": "50aba0ce9763a3ff574ccc4be9ebaaa5d3e741045ed1d42a10f6a906c8b4b773", + "python/sglang/srt/entrypoints/engine_info_bootstrap_server.py": "42d58f530ec46f50f88e09d8e5c42d9b014e51ca023343fbb042758d854b2c6f", + "python/sglang/srt/entrypoints/engine_score_mixin.py": "904b711fa54795a19cd3ab0691205ba373ca9fdfee0a8c6b4a1e07f670253789", + "python/sglang/srt/entrypoints/grpc_bridge.py": "cb30520b01dd46e51c79c3812f54014b2f3376e96167e6916137396828a67d94", + "python/sglang/srt/entrypoints/grpc_server.py": "4b62f049035c16f717974ddb8145201f205bf06dddcffe4eebead7c7a7e71e28", + "python/sglang/srt/entrypoints/harmony_utils.py": "68b50da39f22701e1046b18f539faaee3ce26d8684ca1d213ab7abb7facc39c5", + "python/sglang/srt/entrypoints/http_request_decompression.py": "69442d129fe79f4449268c3804f0203af9a86dc616f997fbd729ab66f43c0e9c", + "python/sglang/srt/entrypoints/http_server.py": "5dbb62c787b120d70ca62241400705d34c4b7cb3e3100e1032c25989638e1f2a", + "python/sglang/srt/entrypoints/http_server_engine.py": "57b03db3ebff5207daafbbefa20c1138a8efaf00e6c8c0cbb843ccab448c5bbe", + "python/sglang/srt/entrypoints/ollama/README.md": "25ac552829f224e0fb0100d8c9391a7e028b89a975ff58170230fa9a5438f35b", + "python/sglang/srt/entrypoints/ollama/__init__.py": "786b829e3671aa72305b1948175314c7f631609b2ca3973bbe74790149eff0b4", + "python/sglang/srt/entrypoints/ollama/protocol.py": "08f1e67f0ea75fdba42cba0230bfdeb8fca46fff0b6226088d97ae70609e51c8", + "python/sglang/srt/entrypoints/ollama/serving.py": "b9b23646ef92565e02354b9c2599aab2acfccc57eabc3f53e0e25043230a95af", + "python/sglang/srt/entrypoints/ollama/smart_router.py": "6e83e521aa3ef6c98c74e82a1336594099531e106687e68b60f8ddf87d0bd968", + "python/sglang/srt/entrypoints/openai/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/entrypoints/openai/audio_chunking.py": "1786fe94d17c4e4ae07311b4d2f8a772e556832847dfc0f7c80a1297b48612a5", + "python/sglang/srt/entrypoints/openai/chat_encoding.py": "4cc93655ba72dabc45b40a23a107c76c2208cb7c5c612193f6832388fe2c624c", + "python/sglang/srt/entrypoints/openai/encoding_dsv32.py": "67ddda353a0026f4e3268255041e473934359ab7b8513e527821eea06ceb4e91", + "python/sglang/srt/entrypoints/openai/encoding_dsv4.py": "764dcfb28a57c3196975475747cb525ccacb4110556e3d9d35f038d6283ca527", + "python/sglang/srt/entrypoints/openai/protocol.py": "0d4ab08ef507764b1a477d12ff63ca6a70c48151b1464881c29928a87e392165", + "python/sglang/srt/entrypoints/openai/realtime/__init__.py": "6f1c7f2781cd8ad335bfb2cfe7cd29d040595b4ac86c972ca31d336e8438b597", + "python/sglang/srt/entrypoints/openai/realtime/handler.py": "d847da4ddba5c26fe01533aaf36a41778dc0fe28cb7f3f35fd6b5d27dd8ffd04", + "python/sglang/srt/entrypoints/openai/realtime/protocol.py": "6e1f9ea317f4c20bbe8ab8fcfa89aad849317115df619a179c0e8737a0071b1f", + "python/sglang/srt/entrypoints/openai/realtime/session.py": "3689c4b302059606ca144e782dd171f14a173881fb58365adc66021d8e17ce87", + "python/sglang/srt/entrypoints/openai/responses_compat.py": "72bfe1e5e45073d57f09dc90ba7b2ea6b87df932cfbcb67ed8116f25c5830037", + "python/sglang/srt/entrypoints/openai/serving_base.py": "3d0613b92abae51e8566a11ae80a2369a46422b49bd63c4cd6aa593d8a4bdbc2", + "python/sglang/srt/entrypoints/openai/serving_chat.py": "e36c887507fe94aa13cd2fc97930f253fd129339959cd846d3ec7ad4274b2824", + "python/sglang/srt/entrypoints/openai/serving_classify.py": "b05079d8e3930397653a4ddcdef560250d6d7cf3a3af0cd749a9e7ed7c679005", + "python/sglang/srt/entrypoints/openai/serving_completions.py": "0d21d557ef38d0639e4030bff764ecca8a266ef6d60284cf959c56d9dec751a1", + "python/sglang/srt/entrypoints/openai/serving_embedding.py": "cf1b283df88e1286b7f803f2173bf89499c65e25c93462bc299b2c64539d77b8", + "python/sglang/srt/entrypoints/openai/serving_rerank.py": "5242cd42c8ccba74fbdf13e2c7eee63b5551e3d6bef09933aba213d690cb3329", + "python/sglang/srt/entrypoints/openai/serving_responses.py": "a30b96b8b1393e8d1cf53fb180e602eeae07bd160bb88a3146eaafdf0ef0f4e7", + "python/sglang/srt/entrypoints/openai/serving_score.py": "203748c564cd979d03d54dee44140c63caef59490d1ca508ccb1aca3f69ffccd", + "python/sglang/srt/entrypoints/openai/serving_tokenize.py": "f1791dbe89245cf80f2ae3c3f052e944c0b602deaf45909a31d2e4aabfc95711", + "python/sglang/srt/entrypoints/openai/serving_transcription.py": "0f15eac62ea22d5cd531f19e9419a5db61f6a3109a25f0e6d87e84d215c4128d", + "python/sglang/srt/entrypoints/openai/sse_utils.py": "a04b5b4548067c8932466aa99f9758d7a87d547f6a1843f9d104bbbfe3ea2ac4", + "python/sglang/srt/entrypoints/openai/streaming_asr.py": "2cacd66732a167beb72521e614ff1b704c6e09471fc9795c2baaf2a139aa2a19", + "python/sglang/srt/entrypoints/openai/tool_server.py": "910ad836c563cdc4a27412f9fefae9febad1cb1f095b2d7108a8e993e14d846b", + "python/sglang/srt/entrypoints/openai/transcription_adapters/__init__.py": "058c8a2dde5657747cc591f0933d986fc7b99f6cbcec761aaa611ea692bd2ddf", + "python/sglang/srt/entrypoints/openai/transcription_adapters/base.py": "5a9cf360b2dd1f8991094b3653a571e12f688d3e04d5740df51516ad86f7554a", + "python/sglang/srt/entrypoints/openai/transcription_adapters/mimo_v2_asr.py": "41db26f4d8b2f2485b95e17c15c289c0c9d2c9d27d8279ada178da4721834c35", + "python/sglang/srt/entrypoints/openai/transcription_adapters/qwen3_asr.py": "6095a17613e443f06060ff2a4536fd5aa0894293e554435060d9e2c4c6445b47", + "python/sglang/srt/entrypoints/openai/transcription_adapters/whisper.py": "3569731f715a293275cc11aa8ccd237d1431c2102efab8843b289ce25040000f", + "python/sglang/srt/entrypoints/openai/usage_processor.py": "883c4c3ba95eb52fa57d5bf732d128063bac0b032f484776331220f61b7498a5", + "python/sglang/srt/entrypoints/openai/utils.py": "6057816db2a0851dada70399266f4c678b0a56c576e145d3dfd442e2b2300624", + "python/sglang/srt/entrypoints/request_headers.py": "dcf5b40b22cfb44e56041a329b80abcc6eb420de369d40bbefc0830d99ae5c55", + "python/sglang/srt/entrypoints/search/__init__.py": "f6993cc104837ed956524568f6bdce8cba587aec7acc5be478b2027834223ad9", + "python/sglang/srt/entrypoints/search/exa_client.py": "4ce2e0c3dabdf567757664030c1960617e3e94921ab514d106b7aac68ceb3deb", + "python/sglang/srt/entrypoints/sidecar.py": "3c1426b338f234b3806862ad298132fbaf8c7c2e2c6e1b7a361a70568d7c421b", + "python/sglang/srt/entrypoints/ssl_utils.py": "3f56a50ac45d549fcbbdd670d8a456593a66ed07203007dafe8c80fe86416342", + "python/sglang/srt/entrypoints/tool.py": "2867140746cfde17ba0e7b82da4bad255226fd97df376c40922cd4fb704575b3", + "python/sglang/srt/entrypoints/v1_loads.py": "528deeb3210d8ea9039b9e20fbeff28d326d8efe49d16c55ef662e8091c22bd2", + "python/sglang/srt/entrypoints/warmup.py": "39213d17c3435842a715ee46502f2a664ecf5bd3d1efa829ba721052938f2f06", + "python/sglang/srt/environ.py": "aa2cfbe7c61e27607ef443aaab7988e1fce58d995711e4b2f4f3ac9bb86583ca", + "python/sglang/srt/eplb/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/eplb/eplb_algorithms/__init__.py": "69f58f4c8c7e6eb9dc70dd124cc9b3564dbabfda6318d1b66d658822ccbdf323", + "python/sglang/srt/eplb/eplb_algorithms/deepseek.py": "7c42cd0cb0f03da5dc68d13d38833f2986625ac96813dae4853521341cc5219c", + "python/sglang/srt/eplb/eplb_algorithms/deepseek_vec.py": "573cb921aaee6b5560547ce304d65a555fefb752d8d412ed273ecf9b307bd359", + "python/sglang/srt/eplb/eplb_algorithms/elasticity_aware.py": "c7a69bf06fc209a5279050e623a25dcd0a9a3485f21135b5a02b02c783cfc4a6", + "python/sglang/srt/eplb/eplb_manager.py": "d0d4a739edc70f2f7972a361cbbd6b72f31233539bd56024e96f22ac5fa8b019", + "python/sglang/srt/eplb/eplb_simulator/__init__.py": "1c865a5eab2fb0e08c309f35752b3569f4866791ba3a239912d1e996dcb3ce36", + "python/sglang/srt/eplb/eplb_simulator/reader.py": "3a5b16aacb97a95418ecf7efbeb3febec9765b0d8a838bc3fcaf4196d33f407a", + "python/sglang/srt/eplb/expert_distribution.py": "74ae213a2295777d56208d5f593bc603782c7992bf91e60a3f1395ceb6d7442c", + "python/sglang/srt/eplb/expert_location.py": "879172c5669cd1a7950a37440698393b4419c073d826fe3bce39d5854bca2ed5", + "python/sglang/srt/eplb/expert_location_dispatch.py": "c7f6b68fb9c6262ab781de8c31514580f36046732ecf75868e3fdc0c6a9e11b0", + "python/sglang/srt/eplb/expert_location_updater.py": "b1e03dd4a8dc42d3987c16e3b0fa6dafa40e21f1f0363763bb673cf67a03199c", + "python/sglang/srt/eplb/lplb_solver.py": "3201e927a9513f92f6410fc25fa10e7804e21a05156f7c124ce936b2d3abc3a1", + "python/sglang/srt/function_call/apertus2509_detector.py": "10b776d3364f3bce87d8564903ae0b7f266e7cee2912f610f64299862f855b15", + "python/sglang/srt/function_call/base_format_detector.py": "0e56a1402b1d27dd92c5299f4bdeed3bc4499660df3c910c473a9691ba23265a", + "python/sglang/srt/function_call/cohere_command4_detector.py": "008deb2e5c078d5371a571479988c1b001f8b162287ce225b041484f0498b1a0", + "python/sglang/srt/function_call/core_types.py": "c0b52c5bc99403e8be212cf94140cbec48eaef65be2b51c88456bd5a6fbfa00f", + "python/sglang/srt/function_call/deepseekv31_detector.py": "ec6374c040a86dd2021b7ea7b989300299dea623fdaa3c71d6d9aa3f18e845d7", + "python/sglang/srt/function_call/deepseekv32_detector.py": "a7d6263b1e9d5ec3742ca399d1df2f7d4ff91a8d8c079d953035a976b6090a4f", + "python/sglang/srt/function_call/deepseekv3_detector.py": "a555137527cd524f51a888ee49224d4761856f5b4a9d93d3ca77abfb755c06d5", + "python/sglang/srt/function_call/deepseekv4_detector.py": "d826876e0b6229ff5d363da16b6c954c3211a080d72edb81cd56b0fd477487ba", + "python/sglang/srt/function_call/function_call_parser.py": "578defd8404b88a6dd4786a19fad9777e889898b4211a7bdde2f6ac7c11a4531", + "python/sglang/srt/function_call/gemma4_detector.py": "712146a24e1873fe5d2872253a1688399a8929f7d5c04094e2027428ff767d99", + "python/sglang/srt/function_call/gigachat3_detector.py": "f544d3bf51e1afaf9c8fe62878c5ec9e929c1db2eb9b1e4040daeb0be81c413a", + "python/sglang/srt/function_call/glm47_moe_detector.py": "93c882d0d3d5613c792a4a20da22a9e54d4f36ebb828846dce05a1acb81d83cb", + "python/sglang/srt/function_call/glm4_moe_detector.py": "a8daa4f4ef6d45aaf612b0e0fd3f922e5b52a406ac85abcf7c2cc2e39857ed81", + "python/sglang/srt/function_call/gpt_oss_detector.py": "5c81fe623acd20c19106ce946d8d902a285769babba43e8ddc4c181a5a9da3e7", + "python/sglang/srt/function_call/hermes_detector.py": "5dc30e64c7ccd453f3b5fc50be0321c3bb404dac3e689ad4cc384ab2c45de27c", + "python/sglang/srt/function_call/hunyuan_detector.py": "546cf13fa2951d89641b02394fb4da0913baae82d5f5e4db7e2f48f76126b329", + "python/sglang/srt/function_call/inkling_detector.py": "52273f962e652026e86324d2e6320225e10cd24cf1b002674d1d7e1659680d99", + "python/sglang/srt/function_call/internlm_detector.py": "a2339f334c5bcc7fe36d7cb7cb3b7621918eed857397df47e6f3ecee28b38133", + "python/sglang/srt/function_call/json_array_parser.py": "7ebbff7e8ad4fd1ca0f227b9edc345715d637387301710fb8ab619286a31b934", + "python/sglang/srt/function_call/kimik2_detector.py": "92d6dd3751ba1bdcc5ef64eca0db87c1e341d0f81bbd764664ac6ff38f08f839", + "python/sglang/srt/function_call/kimik3_detector.py": "423aaa042a963f7b3c091991c9a356d23e2f161c05d0e3d4dfa07da17be87838", + "python/sglang/srt/function_call/kimik3_format.py": "65b893bb3314c02ef2537cc4a8c85b3d798101a5cebebb548a2cac1caa5a3a63", + "python/sglang/srt/function_call/kimik3_structural_tag.py": "bd00d77898be7f6231f165eaf716f0c0cb71cff66036495e261fffd39f462aa1", + "python/sglang/srt/function_call/lfm2_detector.py": "2d2307a9c62a48ca553735b4018d0b02471f08e8ef2eaa0a53cf82b18a1ca534", + "python/sglang/srt/function_call/llama32_detector.py": "e83ee75917cc1921c21ce899e0103af4b94bc492195f87843364580dac73eb5b", + "python/sglang/srt/function_call/mimo_detector.py": "2b4ca63e1de0b232c69cf26609e87d0da9a8a3be9c4acd29f0db62e2dbb0db45", + "python/sglang/srt/function_call/minicpm5_detector.py": "12fc0378e86b337706ee1e64e3b3c96b8550eaefda74a97e8dde54dee954c1e0", + "python/sglang/srt/function_call/minimax_m2.py": "fe1dba10e3d9a76c3549a20c2b8ba1b609eefa4a817197abba8175b725a724fc", + "python/sglang/srt/function_call/minimax_m3.py": "cbd83122df28c1ef6d6ab34007bd7d64eb56f902614fa3bd74e5c681f2fd0e65", + "python/sglang/srt/function_call/mistral_detector.py": "ecb2637d1766f096c698b6b8eaadeb6e772aa3487d6566f61f665c145dd73336", + "python/sglang/srt/function_call/muse_glimmer_detector.py": "c7becee4831996d4b3bab24659ed45c10980b1d341ac4f05ffd567bc76a5935f", + "python/sglang/srt/function_call/muse_glimmer_format.py": "91126a99c959c98e287db819411b099a6db3fa0d9060bb736694e33d8b89e8e6", + "python/sglang/srt/function_call/poolside_v1_detector.py": "3bc52645891d5c9bf97c3796f5dcabdf1bfcdcac0f4483aa5786da5bf950d295", + "python/sglang/srt/function_call/pythonic_detector.py": "47e6f58b88db14870864985f51e18965b39332cfd5df293de3d26be7e778c6ec", + "python/sglang/srt/function_call/qwen25_detector.py": "e4ebe052024b4236819932ee3d54941fe2db9bb9107711ec33514d1d68c3c9e4", + "python/sglang/srt/function_call/qwen3_coder_detector.py": "4cea43b633e46ca164492ebd3a26892dbc602e29856024eaa05be65551ce4541", + "python/sglang/srt/function_call/step3_detector.py": "7ece8be2b2f8dcf9285d405baffdf69ba3632cf799ef5a1a942a73b2ae1d1cb6", + "python/sglang/srt/function_call/trinity_detector.py": "868f345fb3129456073497949c913457cdc2d54ec90885d71e302bc85114fca8", + "python/sglang/srt/function_call/utils.py": "fc55c1b3d63a3631841aa1b6b5979cb0647e6ba27a4f5a1f1a1573f46eca8c25", + "python/sglang/srt/hardware_backend/cpu/quantization/awq_kernels.py": "6ab92cf54daa765c6cf55e9f2daba16698f41821abf43a455697dc075d7d79ae", + "python/sglang/srt/hardware_backend/cpu/quantization/gptq_kernels.py": "e0c95772981e9927040988cf41c4e17fc563fe49d45d165da6b600f39bf8bf0e", + "python/sglang/srt/hardware_backend/gpu/quantization/awq_kernels.py": "055053ba8cb17a66a6b86feba08cf9abd0ffe9c01b8be71c2a9e0a990a53d83b", + "python/sglang/srt/hardware_backend/gpu/quantization/gptq_kernels.py": "375085abdd2f4abca3d5831045d5f11d012c1877e0a19f79ebe89593b5568370", + "python/sglang/srt/hardware_backend/mlx/aot.py": "01860d8645b7ea869508430728a97378d657cc2ad1d3589f8bfc244d9d7f832b", + "python/sglang/srt/hardware_backend/mlx/kv_cache/__init__.py": "be7e9e48cb7e6128073c59633331b702c824e7663247988be2c1fddc2678a19b", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_contract.py": "ae36edbde00e162f81bac8b58d9d57081c7606b0204e4d949e7b2345030aaed5", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_kv_cache.py": "b356b0fe2b6c9669a0b531a83cd40fbbe8f7920ba04f4bc8ff127fdeadb40885", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_kv_pool.py": "d4235abf8d7e899e58eee3cc432840549227329aec7524b7721c97846291626b", + "python/sglang/srt/hardware_backend/mlx/kv_cache/attention_wrapper.py": "c8485033ce1a3363cd6288bb3f7717a3be6e27a7278a9e6a451c0bec22ef7105", + "python/sglang/srt/hardware_backend/mlx/kv_cache/auxiliary_state.py": "31bb2cf55d87f0493658d4a83ec621a2bed590ed47f272534c603d4e62bbeb7a", + "python/sglang/srt/hardware_backend/mlx/kv_cache/layout.py": "e4f3b27e74eb8118c928479e8c1fcc880b3798331b2bd5088bc648af0b25399f", + "python/sglang/srt/hardware_backend/mlx/kv_cache/model_patching.py": "fbdac75437d50d7837c755d7e8950412f49f018e06c2a03c0d982d5bb793285e", + "python/sglang/srt/hardware_backend/mlx/model_runner.py": "48495702c5f080f2e8c063e1ec4d39d93ed7172c6c3eab5480dc7d8d30e46fac", + "python/sglang/srt/hardware_backend/mlx/model_runner_stub.py": "9bad79c3ab1910673856f71d51226bde7c43091cfed4bbf4ad3367ec31ff69d3", + "python/sglang/srt/hardware_backend/mlx/models/muse_glimmer_mlx.py": "e9e2d4dd21a92e0747f6db685bf0518e3d50ea489c52e7f56ef28833d9469339", + "python/sglang/srt/hardware_backend/mlx/moe/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/hardware_backend/mlx/moe/fused_swiglu.py": "7af9920968fbd7186909fd6af144b5233cdb43897f3d446f59e4e77d713569b4", + "python/sglang/srt/hardware_backend/mlx/parent_watchdog.py": "73280296edd1c553cc0df6ed963cd6a17e293291fad1bba300600095be870c31", + "python/sglang/srt/hardware_backend/mlx/profiler.py": "6d344b577c9905922daab260320b936a2ff05a1e0191667a493f48a1f17a2f0f", + "python/sglang/srt/hardware_backend/mlx/remote_code_gate.py": "2fca7faf07b67d8d336e216369562fb3001e21d7366b1dd7799bedc0893f2cd5", + "python/sglang/srt/hardware_backend/mlx/sampling.py": "e9dd918cf5a1bf3fdec697371e393f0335fa333d2eef415047314e4407e9dec8", + "python/sglang/srt/hardware_backend/mlx/scheduler_mixin.py": "61fb35e2492e80a9907fb3e2683e5598d2afd2eff25a0570f41416424ec68288", + "python/sglang/srt/hardware_backend/mlx/tp_worker.py": "b069bad13eb10965c0a4cc3790085d661fcf921b1c301cea12f2738c0c472927", + "python/sglang/srt/hardware_backend/musa/__init__.py": "98c2f352233b032b0a4192efaefb25f2ec3fa153d996dc78c327253723069897", + "python/sglang/srt/hardware_backend/musa/attention/__init__.py": "98adf994f3345c498e7477f82245508600e3f5ded2205e2e6af5c0c80eac616b", + "python/sglang/srt/hardware_backend/musa/attention/flashattention_backend.py": "e95f13b232edbcc785ea63164b186cca3b05b4a64b12adccf14ad19f2e856282", + "python/sglang/srt/hardware_backend/musa/kernels/topk.py": "d9ea6fbfa6c362d419d75b47ca12e1e4a01c01db8d8ccc474e45ccc8eb732496", + "python/sglang/srt/hardware_backend/musa/layers/utils/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/hardware_backend/musa/layers/utils/cp_utils.py": "b63615113b1142ee6667e182a0fad19507eefafb88161f4eea877d41789e126a", + "python/sglang/srt/hardware_backend/musa/utils/patch_torch.py": "d5c2492e9c3389f33cb7ad75ee0f1fc3f62853436911d17962b1f380d2662536", + "python/sglang/srt/hardware_backend/npu/allocator_npu.py": "7c96bdbe2812af59e8f7dd77a085774520ee152d4b051c8e41fb2b87570fa568", + "python/sglang/srt/hardware_backend/npu/attention/ascend_backend.py": "97cba7e5b180bc767998e6150ab89565e16da3180aa666463029b04162e10b4f", + "python/sglang/srt/hardware_backend/npu/attention/ascend_dsv4_backend.py": "b4e74210398435aaee4d9a107649780bb65d3e4ded7e548882d4065a9f06368e", + "python/sglang/srt/hardware_backend/npu/attention/ascend_gdn_backend.py": "b62bf1c59130a56567613206da62a3ffb77333c6943f703267b79c3f1f829337", + "python/sglang/srt/hardware_backend/npu/attention/ascend_hybrid_linear_attn_backend.py": "b2796ba9128da3666433cbaf4ca74d2dfdae63682444abcddfaa1c8255fefaf3", + "python/sglang/srt/hardware_backend/npu/attention/ascend_kda_backend.py": "7fa11a8f05da1b2cbc61d849f50ed23077b5c76d81b25fabc71c05ce8c57f19e", + "python/sglang/srt/hardware_backend/npu/attention/ascend_torch_native_backend.py": "980526716059fb4ffe6eff2a64e6b7e068fcd10f5b2c6075a87e52b04e541e4d", + "python/sglang/srt/hardware_backend/npu/attention/mla_preprocess.py": "b74303957f7b04b20dd17f5830ac5619aa60e1cbb49b2984100922b9ea42c05f", + "python/sglang/srt/hardware_backend/npu/batch_invariant_ops/npu_batch_invariant_ops.py": "594866569d8461e8fca6cb10f86c0200a9afa30a49c22009a3a320d5d5352f73", + "python/sglang/srt/hardware_backend/npu/cmo.py": "2d92b479bfbe32f61c4e6fd3f8a90029917721e7242933bdb7bcf8c43ec17200", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_allocator.py": "de50d12a6c3ee42cbc3ef70078c50d9ddf3ce6fe81044a8da2ab3dca006cd0e2", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_common_hooks.py": "912a18d6e6cfa1da8be500338261df2023d61c1caa43ccd0230e5016388098f4", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_memory_pool.py": "27720a07a169a7ae33cde62f50e73b9c00c3bc365c89b9531a10ffc646b2bc89", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_req_to_token_pool.py": "b08f5e7a7731d64a3bce64f2914789ade1b6a6785deab997792ff80bd2f07efb", + "python/sglang/srt/hardware_backend/npu/dsv4/dsv4_rope.py": "dcc1e6845a6020ed6f8c38379bd2bb987cd3889223fc669d83bcaa5b492323ed", + "python/sglang/srt/hardware_backend/npu/graph_runner/eagle_draft_extend_npu_graph_runner.py": "158d5c2e4bf741280fdfacea70880877c90aa4810c01f7d5a46f2d4aec57cd91", + "python/sglang/srt/hardware_backend/npu/graph_runner/eagle_draft_npu_graph_runner.py": "5948b09510d88f528819f5c85d1537dae396e9f3cf0634a0a107768a629622e5", + "python/sglang/srt/hardware_backend/npu/graph_runner/multi_layer_eagle_draft_extend_npu_graph_runner.py": "6e4bc0551977692c7905555a78c9899b4bd9d38d4c012ca28f92d3a6b89ee864", + "python/sglang/srt/hardware_backend/npu/graph_runner/npu_cudagraph_backend.py": "4c2a2a4aa41d5076ca2618f259697f5d4e2a18b362d891b43a63afd0445f391d", + "python/sglang/srt/hardware_backend/npu/graph_runner/npu_graph_runner.py": "b664301658e30e0e59607210babf3f47f000c812f8abb0af416bc710ed7d9c83", + "python/sglang/srt/hardware_backend/npu/graph_runner/vit_npu_graph_runner.py": "d602034909d74454a32caa39c57f5498d5bba0b53ca84e33ffba1b4546dbfc37", + "python/sglang/srt/hardware_backend/npu/memory_pool_npu.py": "c2c1d711601d380dbaa0cd19106bd201f1183f30fada4fe10b5b4309a0cf9537", + "python/sglang/srt/hardware_backend/npu/modules/deepseek_v2_attention_mla_npu.py": "7fa76db72e593a8ba108a28d6a6377fb5e2be5da6b005c1ee2f78397965ea9aa", + "python/sglang/srt/hardware_backend/npu/modules/glm46v_processor.py": "d8c17bdf2fe74cfb5981625c99a7532cc3fe442058fd89d31499b49b401ed8f1", + "python/sglang/srt/hardware_backend/npu/modules/minimax_m3_processor.py": "b29ac8d4bd93cb84041c2c9151f4cd190757d0ab5c6956a53e79252da6da111c", + "python/sglang/srt/hardware_backend/npu/modules/qwen_vl_processor.py": "41f6cb1020b188c412b698e80e957cf6b72ffaeca758d5efe9a838b61beb5186", + "python/sglang/srt/hardware_backend/npu/moe/activation.py": "6332eee502bcb38461bf7fec9808860b86063b115b931903a952060e95b259be", + "python/sglang/srt/hardware_backend/npu/moe/finalize_routing.py": "5f405ae3f69794eb21e6fa3a9a72c0c6e3abc954b69bc5895233359b1b341426", + "python/sglang/srt/hardware_backend/npu/moe/fuseep.py": "4f38387bbf29b9ecd8fbca4bbd24643c83476f70980489132e75230064336545", + "python/sglang/srt/hardware_backend/npu/moe/init_routing.py": "7259a3276000c15b0cb9db37905590889c02b0367b45f7aa6444af76738559c7", + "python/sglang/srt/hardware_backend/npu/moe/matmul.py": "103ee3efc3fb7472f123caa90f6bbee78ad54b539ea4c6029728292449343bca", + "python/sglang/srt/hardware_backend/npu/moe/quant.py": "f257a11a9d84899a4bdaec4d50f8851ea00c990304605ce87e03eaa8d2c3e21f", + "python/sglang/srt/hardware_backend/npu/moe/topk.py": "f82f25bb343892b7b8b1eb833a4e6ca376a510ac74a3a935e0a1997dbd072f75", + "python/sglang/srt/hardware_backend/npu/quantization/awq_kernels.py": "fb7e61a875fb16733bad79bb369470c0811b16297538a0096ee99db085ed0ab2", + "python/sglang/srt/hardware_backend/npu/quantization/gptq_kernels.py": "bbe88891a5cce8fa4384ccd792ff8051e57a8c464834066794cf4080a3213ce6", + "python/sglang/srt/hardware_backend/npu/quantization/linear_method_npu.py": "fb048862fa9bb1bfe1082571ce3801c0a67cd706972b9410df01b2d719d56b90", + "python/sglang/srt/hardware_backend/npu/quantization/moe_methods.py": "a2f19e4447754aae0d4c8298006f7bc4f4fe42ffe87d71c08364e90f26924c66", + "python/sglang/srt/hardware_backend/npu/quantization/online_moe_methods.py": "a58fefd0f600f928e639dd8efc3ac20bdf5819af63e447db40e123aa5667a657", + "python/sglang/srt/hardware_backend/npu/utils.py": "eaf2a13ecef1ceaa2871e1ceabe0d39d89d4f32f934a696684acc5f9734deb93", + "python/sglang/srt/hardware_backend/xpu/__init__.py": "64e0d0c737f4e4502cc9ba8f9eeb132f5cff859758e0ce996f84f85a8177c01e", + "python/sglang/srt/hardware_backend/xpu/graph_runner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/hardware_backend/xpu/graph_runner/xpu_full_graph_backend.py": "9f9c31cd0444afd50e806e32163f5e87d200ebcdbe60e382449891063f130d89", + "python/sglang/srt/hardware_backend/xpu/graph_runner/xpu_graph_runner.py": "e46764c9549d4fc90df488e8f87a9d513e3d2c48c7afc58daf5088713f09f4da", + "python/sglang/srt/hardware_backend/xpu/kernels/fla/chunk_delta_h.py": "89bcc1275bf8f3e5f90b8a451060bb720c90f2ab640c75830ee65b59839b45e9", + "python/sglang/srt/hardware_backend/xpu/kernels/fla/chunk_fwd.py": "1a83fb1671688d5cd995007dfcf1d85519a45b9ec8ba1fcc354431e62a851a5b", + "python/sglang/srt/hardware_backend/xpu/kernels/fla/fused_sigmoid_gating_recurrent.py": "f7920b6429af284d909324e43ac29d344bffed456465d52625384a4e7f42fe34", + "python/sglang/srt/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/api.py": "9b52a98d05f5143ad647e67b8aa66cf6fd5d5945153bf6f3e004713cf07cabe8", + "python/sglang/srt/kv_canary/buffer_group.py": "a694b2fd65132e06143a0dac2da636a2880019d7e0c98ab772cf51a2a088d1b3", + "python/sglang/srt/kv_canary/capacities.py": "e4861f85c69f748f36373ecf187750210becef2b33297b8e9141c6b9546f71cc", + "python/sglang/srt/kv_canary/config.py": "b265fe49344de6ba64d8364b128bc59a52ced91dab799c34af65b9e8d7f8b762", + "python/sglang/srt/kv_canary/endpoint.py": "373c89fade17867c597021a7f478757406084b591ad2faf4ad5295ce46c07534", + "python/sglang/srt/kv_canary/expected_inputs.py": "4dce033c1edd272845732099081d9b879eee44bdb642ba4cf20c8e333796e36c", + "python/sglang/srt/kv_canary/perturb/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/perturb/config.py": "7a74803a65a39024bdb9a768b23fd996e233c4f664f6cc0cbfaab78778418837", + "python/sglang/srt/kv_canary/perturb/manager.py": "ab779cf17fa7a651105f5c85166801158203a0c514139d086a830bdb52b8b7e5", + "python/sglang/srt/kv_canary/perturb/next_token_swap.py": "dc755f51b7e5d3a60eaab6eea025298cc547a3042e15bd647e5d543a4e3735fe", + "python/sglang/srt/kv_canary/perturb/real_kv_post_forward.py": "be8863ee30a6f61a8679f0e9243931b89a3d4385b54dc53a967827ef2b19c062", + "python/sglang/srt/kv_canary/perturb/real_kv_unused_cache.py": "b88f803a7763e7d6da908a083cf17219d39f51d2a294c47148cf63c9c7e2183f", + "python/sglang/srt/kv_canary/perturb/real_kv_used.py": "8b8e7e4017e5677f073e03fa40c5c1d879fea249ea019c926d2d334e93c5c12f", + "python/sglang/srt/kv_canary/perturb/req_to_token.py": "edc06725ff16248633bc2240b035179a0d8033e0af788683c94da046a9c3ea18", + "python/sglang/srt/kv_canary/perturb/slot_picker.py": "50eea89b054013310474da5988f8a5dbde694081c9abadec9dfc69b26382bc75", + "python/sglang/srt/kv_canary/perturb/utils.py": "87ed6650884067c64c329a80b589ddc492b21f18e7a26ef8e017681855f1fef2", + "python/sglang/srt/kv_canary/plan_input.py": "c1eec88772e932286e4f85dc74fe52839f4e6cf8f1a4344f5a609766653e64f7", + "python/sglang/srt/kv_canary/pool_patcher/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/pool_patcher/adapters/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/pool_patcher/adapters/dsv4.py": "d2a7114b620c66650242d189cd4106a6e2dfc2cd75df60102b092b44d83cecca", + "python/sglang/srt/kv_canary/pool_patcher/adapters/mha.py": "107fadcc284058e68e915870e66f33796b111875165568810b938d393dd4bf97", + "python/sglang/srt/kv_canary/pool_patcher/adapters/swa.py": "89c39c8b621743e4b131052d3a2d0306ebe46c0e3ce4d0b32302b644a30d1b42", + "python/sglang/srt/kv_canary/pool_patcher/api.py": "efa0c95a02c535b7bd2216656f724de73d0ae4af628761fd2feb89f97dbf675e", + "python/sglang/srt/kv_canary/pool_patcher/buf_info_splice.py": "1c2b42261111c6bee904b3862744ee469512937ddbf73a2c08ca48ded6c6f2e8", + "python/sglang/srt/kv_canary/pool_patcher/buffer_alloc.py": "bdf7540a0877f38a50e48aa50c680b1382ec81d763415e3043097be27cd6e6df", + "python/sglang/srt/kv_canary/pool_patcher/utils.py": "b932bf4ae79a34ffa0296fd3f7155eab5008576e38f5f787fac30f11ce3c0f04", + "python/sglang/srt/kv_canary/radix_cache_walker.py": "0336c58e3f009d6eacfec49edabd431dffe556b6766a17e24cdec15e9d6834d4", + "python/sglang/srt/kv_canary/req_to_expected_token_ids_manager.py": "dd236499cf61f30cbe4c7d314ed023f0a69c3927dc259a41aa836be19818fecc", + "python/sglang/srt/kv_canary/runner/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/runner/canary_manager.py": "5665f0be8884203de55a1481c0c7af7c05290942302671b2124eff20f4f00e50", + "python/sglang/srt/kv_canary/runner/enable_warner.py": "9a48cbfd97b5a094883b6e0b02772992d930e9986083e129ab94914825601d26", + "python/sglang/srt/kv_canary/runner/future_tensor.py": "3d1258cf36cf05d2b37ac6e864d9e0ed7234d0435876a54bcf63948ba3ac7369", + "python/sglang/srt/kv_canary/runner/health_checker.py": "d05fea43777d02c2d0d5b9f3c118a5cd0a6b853ac0e6278cf9a8d8c05a25c547", + "python/sglang/srt/kv_canary/runner/kernel_launcher.py": "6c9ebd784e03b0e6a043e9318a32df3fb99dc98c25ec2bfb959a9b3a80b79dfe", + "python/sglang/srt/kv_canary/runner/stats_logger.py": "c2d88687b3787f11533f3a0ef14c8a25a7364c96b01c4b1b24912246750acdd8", + "python/sglang/srt/kv_canary/runner/swa_divergence.py": "3a784d1f0ac1f2e1ecc6b403ee66388dfea02c291ada39c92384f2f22d258fe5", + "python/sglang/srt/kv_canary/runner/sweep.py": "af59c8347380be88809f7ff0bd988467a2ab290a20a761a5c623d7e0c45bc5ae", + "python/sglang/srt/kv_canary/runner/violation_manager.py": "c75633a08c50717d4a5854fb7160e6dc05ed41dc2f919bf51eadf24c9f47a8bf", + "python/sglang/srt/kv_canary/runner/violation_reporter.py": "f2b8c04bf46207a0bd87f5fe3f4859b35e2fd76e2f440a20809d0bf95e63d5de", + "python/sglang/srt/kv_canary/single_forward_manager/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/single_forward_manager/data.py": "79fdf8e6cb67568d44976d10c197c2b9e2687ac9fe7915fc382e14a4e83ecd45", + "python/sglang/srt/kv_canary/single_forward_manager/manager.py": "f70e97b30fa57069e56b8c93c771ac4861178a5ab894250e7aae14d87edcae46", + "python/sglang/srt/kv_canary/state.py": "ae3cb8dfebda81c613bc798861921f883391cd637c89bbf466be3d68c1f997e0", + "python/sglang/srt/kv_canary/sweep_plan_builder.py": "6dd007f700dbd11580a068a4a387dddb98d88c8853bba8bc56b9a2de829cf2a6", + "python/sglang/srt/kv_canary/token_oracle/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/kv_canary/token_oracle/install.py": "09fa6834e431be696baa7a0ce3bd1fabf443618d395117607ee84d657b2b1489", + "python/sglang/srt/kv_canary/token_oracle/oracle.py": "9ef15e40f81a4f788827a172e2e50105ab5dcd07f8593448c77b48ca09b900d2", + "python/sglang/srt/kv_canary/token_oracle/oracle_manager.py": "7e434aa530009bbfe7ee6baf038626591e51bc5a520e3911c0bf61e5e8660500", + "python/sglang/srt/kv_canary/token_oracle/sampler.py": "3fc753a2a89c9bbaeb4d6b0405a83fc705a53b62c2999daeeab3997c4a0fe4bb", + "python/sglang/srt/layers/activation.py": "231a49e1f2f3f2237415e77d85d36c159c2ea3424f0197100f469252164bab7e", + "python/sglang/srt/layers/amx_utils.py": "9c78243b97eda52b7771219c373b50a46c498fc2ddb86caae2dfc2f96b130c48", + "python/sglang/srt/layers/attention/aiter_backend.py": "5a08325b94695eb0426fcfe78f08639eb1a849060917c601d6831e780112dce9", + "python/sglang/srt/layers/attention/aiter_utils.py": "11028c3388212e570c192f999fb43de4c161e2fd5f72f99eacef91a02a530f25", + "python/sglang/srt/layers/attention/attention_registry.py": "b2700564bbbe536d81ee76775449bd12e835e7b02e94a23d9545aeedc52b095e", + "python/sglang/srt/layers/attention/base_attn_backend.py": "21ef3e25c65b6921434a88e625b72b1442709a411a89e04e7f4f8dcabc7531b4", + "python/sglang/srt/layers/attention/cutedsl_mla_backend.py": "f5d6a8c062b8c1a6c86549a077aac62b7452993bd6635c62d46012dce70bf41f", + "python/sglang/srt/layers/attention/cutlass_mla_backend.py": "c6c5048e67b3fdd127115227341623bab0cdb6dbfc54e5d89cfa455c508b63dd", + "python/sglang/srt/layers/attention/deepseek_v4_backend.py": "e2b38050e44768e9da10a801979b3b29d9ed80437b4e9c3b277b0d40e6305e85", + "python/sglang/srt/layers/attention/deepseek_v4_backend_hip_radix.py": "9f7ee5f88ca8a31e486797155a365fd6908461405024290a52882ddbe9d33083", + "python/sglang/srt/layers/attention/dsa/dsa_backend_mtp_precompute.py": "0c77157e78272940485f93b1058603b687fb218299e6b6f503df6fb0fb2ac730", + "python/sglang/srt/layers/attention/dsa/dsa_indexer.py": "3404c9b83452d73f156b742ae32e4085a17d0b166d4d5e45afbd31cfa499b686", + "python/sglang/srt/layers/attention/dsa/dsa_indexer_metadata.py": "0661937fa064fc2788b3e23d73bdb4767c344a2cd18d3a217eea74aa0b921881", + "python/sglang/srt/layers/attention/dsa/dsa_npu_indexer.py": "8dec4f5ccf57f1e25e2b673a987406cef71202515141a18e94c1a2c802413bf2", + "python/sglang/srt/layers/attention/dsa/dsa_prefill_cuda_graph.py": "a1e8af9d8e5e4d58bffdec9b7a8e163c2a89e21e5dd7b21cbc86dc479e55c45b", + "python/sglang/srt/layers/attention/dsa/dsa_topk_backend.py": "dc6ebb07bc3551ced77fe5700ea650c072f13a6e703401152e0962c754b62e9f", + "python/sglang/srt/layers/attention/dsa/paged_mqa_logits_backend.py": "211de1eaab2273cd9c84daca4a189b10450b3cedd8fcbdabfb02d0d51d166d33", + "python/sglang/srt/layers/attention/dsa/utils.py": "debec7e26cb978283ee73cdd0d98004a08f157f6e7e9e2f10a620f8f78d67d5a", + "python/sglang/srt/layers/attention/dsa_backend.py": "b58944c0951217301baca28b73e0222fb1b635040c475d550658b2538dd0d06b", + "python/sglang/srt/layers/attention/dsv4/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/attention/dsv4/compress_hip.py": "420eecb061bbbefea41c905b05e152d1894db72016499564b9fc1bc1df338746", + "python/sglang/srt/layers/attention/dsv4/compressor.py": "6eb018051441c42004512ebb0da27e4b5c4df7b01e037127c50b97a2a27303f1", + "python/sglang/srt/layers/attention/dsv4/compressor_v2.py": "b41377aabe59a03041e5ab46ded60bb4d7e77beac2b14d4acebde2299793db3f", + "python/sglang/srt/layers/attention/dsv4/indexer.py": "1718bad546998d9b54fa7bf97256ee36dd3f7a7008406d8870f1efc447ffc7f9", + "python/sglang/srt/layers/attention/dsv4/metadata.py": "c6aa330d5b5b0fa10e8f09de6c758453763d131cfb1787fa0b8f4f17d01beae8", + "python/sglang/srt/layers/attention/dsv4/sparse_prefill_utils.py": "babef988e67b28f37f8706f2e49a99af0bf9669ab0f8922d80bf565db9dc518d", + "python/sglang/srt/layers/attention/dual_chunk_flashattention_backend.py": "b1b6d9053e1dc6528f083f9c019d3b7d5e74b8d580ebd1349ec6942af95aca07", + "python/sglang/srt/layers/attention/flashattention_backend.py": "e29fc321d99239e3002351e93f3d918b593540fa69ef8097a4104ace7409fa9d", + "python/sglang/srt/layers/attention/flashinfer_backend.py": "3487eb51ab3106350a2dfaaaee5f00223d678fc9dc16267c2aca9e90500efb61", + "python/sglang/srt/layers/attention/flashinfer_mla_backend.py": "ec61e3e093e66a9e79ff6a866c0d81d8b4eaed9b3bad74e8e40e4f3491dd401e", + "python/sglang/srt/layers/attention/flashmla_backend.py": "4a6775bfe75163c69158c4058ce81f56f0c689969122059f9b0e41e22b707afd", + "python/sglang/srt/layers/attention/hip_flash_mla.py": "23f450adfcf65f8962973f0e966bbaa759e59de78e1471c334ccacbed50f43ef", + "python/sglang/srt/layers/attention/hpc_ops_backend.py": "a22f4bbcfc90969c7e8c5dcd3cf071daebbf97e8f1c78c16be7fa627951c517f", + "python/sglang/srt/layers/attention/hybrid_attn_backend.py": "7d52b731a8ba2a33a6fde6f82cfef026d6dea4e938e35c2791869a2994d81cc3", + "python/sglang/srt/layers/attention/hybrid_linear_attn_backend.py": "6815a76bdc1ab6d299cbfe6b7abc57e2f6328645d1d7a3ca3c47ac1f14269623", + "python/sglang/srt/layers/attention/index_topk_share.py": "8659afff39a7db8187a6ab101b501bbe65d2e45856d73117ada9ecb6e760c4d4", + "python/sglang/srt/layers/attention/intel_amx_backend.py": "9b9dc0e75a51c3941e0fa805abbb06ad940c5e7b3f3c48b9ffd653b3e4c3face", + "python/sglang/srt/layers/attention/linear/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/attention/linear/gdn_backend.py": "dff629b87777feed0411414d66c096725267b4f8c8433226e0dd36399d440e00", + "python/sglang/srt/layers/attention/linear/inkling_sconv_backend.py": "276f0fa8f6fa80aee897e30f55e8bfbcd5cde8bf589c19307d5d024b39213fdb", + "python/sglang/srt/layers/attention/linear/kda_backend.py": "a1a06b3f5e6c13aac4c43aaed2a53581f384896769175e52975b68119a467025", + "python/sglang/srt/layers/attention/linear/kernels/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/attention/linear/kernels/gdn_cutedsl.py": "282e33bd8c60a77d8687a9bd11d3e13dd75774442967e3a6097476086346901d", + "python/sglang/srt/layers/attention/linear/kernels/gdn_flashinfer.py": "abfe7172239d3477ec5a14d4f2ce0fca1ee6d6dfa958b9e5041c98fbf27f4942", + "python/sglang/srt/layers/attention/linear/kernels/gdn_triton.py": "c3dfaf1eb04c035df2c7374a6714aeaa66c8a49b6573f8f28b100b9e7e063c82", + "python/sglang/srt/layers/attention/linear/kernels/kda_cutedsl.py": "df11b5d8b44644602f3c0ee361e47ee856048185b318ac409250091b4bf490b5", + "python/sglang/srt/layers/attention/linear/kernels/kda_flashinfer.py": "3188204bf8dba01dd462525be0c0266e3b9d240d4f9a5cb0d4c51485b8dfc367", + "python/sglang/srt/layers/attention/linear/kernels/kda_flashkda.py": "efabe373997983415159a3763472f4a1b1b3cdeb752d375a2b6898e2263f5842", + "python/sglang/srt/layers/attention/linear/kernels/kda_helion.py": "e67d3d430992ab425fc5c55db04b2f413c0b82546ea1b1dc1e52aad8199ae292", + "python/sglang/srt/layers/attention/linear/kernels/kda_nvidia.py": "41976cf93d43e2e36da084ed9e138b37cc6a86e5683201fa02dea38b2090bee3", + "python/sglang/srt/layers/attention/linear/kernels/kda_ptx.py": "78bd59a4a5be7ff48d292ce43590b60e73384f5b0838107e11f6ed4f43b57a6a", + "python/sglang/srt/layers/attention/linear/kernels/kda_triton.py": "176b0caff60ce5c26cf97b0c5b45098896a4856f85d588ed7dccfc13848b9b07", + "python/sglang/srt/layers/attention/linear/kernels/kernel_backend.py": "09921e483c106beedb9d3349079e75767bec8d8a0cb2fa900afa9980ea94ca58", + "python/sglang/srt/layers/attention/linear/lightning_backend.py": "0a19f17b4f1276ee16f0802399ef87c5479f0efd2bb757a8a2e43352a4caf25e", + "python/sglang/srt/layers/attention/linear/linear_metadata.py": "281621826248a9650fad6ef1189c7f1857cf154e73e6e6fecec3e5f393e48daf", + "python/sglang/srt/layers/attention/linear/short_conv_backend.py": "c65a74cca0ff0000bb368116eb4c13ff5489c8f86ac414765b84e287964dbbd4", + "python/sglang/srt/layers/attention/linear/utils.py": "77fb6031e34489ac38848d7d4f5995f9a0f1c47c1d4ad777bd978a05a21c7978", + "python/sglang/srt/layers/attention/mamba/causal_conv1d.py": "fccf7b947ef601038d867434f5a774fa3f169c356ba80e71eb255fd5ef249ef4", + "python/sglang/srt/layers/attention/mamba/mamba.py": "81c8860fd634e83977eb1ba2388a370448d9f7226d159a1b7a437f74f1a79196", + "python/sglang/srt/layers/attention/mamba/mamba2_metadata.py": "b4e7187faf88cfaeaf3de16835bec2b78b635db97fdfb2b9abf58e889dd7fdf5", + "python/sglang/srt/layers/attention/mamba/mixer2_rms_norm_gated.py": "3e5bc6cb1d60ac6312e0a408877faff7df7c2e46d787dc2a626bfdc3a470ec9c", + "python/sglang/srt/layers/attention/merge_state.py": "024522ddc38f7e493b937bbf30a5ad7474befd3908053db301a3a32e07bf33cb", + "python/sglang/srt/layers/attention/minimax_sparse_backend.py": "a9741fd74c16e94b8f8f200cdd5dec8df45617cfb3851d0f70b7e518fe431184", + "python/sglang/srt/layers/attention/minimax_sparse_ops/minimax_sparse.py": "630dbf65874310a89b5c7be7493ed75a7ff5add39c526925ffe569df6d4011cd", + "python/sglang/srt/layers/attention/minimax_sparse_ops/msa.py": "b9f1264b195dd49267fe8931b2e201806abcf05e55b0ab33bb1811bb6eb8a9b5", + "python/sglang/srt/layers/attention/minimax_sparse_ops/naive/flash_with_topk_idx.py": "b7bade9994f045b3ce8c494b1d2aa764cf0f9826e1d1bfd83925de7a6d29ac82", + "python/sglang/srt/layers/attention/minimax_sparse_ops/naive/topk_sparse.py": "3f990aa3544ff631d523efa82faae1ca836d0c1156dc3028c73a71eef0753395", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_flash_with_topk_idx.py": "3da8218bb7768b23bb0b7d1c07114c9015ca92e41a8fa4ac85e507508040a0a9", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_fp8_attn_gemm.py": "aa63ce50c88b5dc1351ecd3c59902babb66ce2576b5532aee8e3ae464bdaca89", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_msa_fp8_parity.py": "77d413b73eaf8552541d4402523965d8d45d96bd8dd89aeac96f87f151ce39f1", + "python/sglang/srt/layers/attention/minimax_sparse_ops/tests/test_sparse_gqa.py": "cbfe7e55e752ba6d0d9f4cd50b5b18b1e6b455e3c1b4a62a5c43165cf725f339", + "python/sglang/srt/layers/attention/nsa/__init__.py": "d495b896a7c369016e9c5a87f4d3b6bd5a9ff2b60447332ee3b691d5fe525758", + "python/sglang/srt/layers/attention/nsa/dequant_k_cache.py": "ec1360d017a0c03fcdf7ad7edeacc11f4373c67401ba451f8e51b9cc46691b96", + "python/sglang/srt/layers/attention/nsa/index_buf_accessor.py": "b1085dff188766111ed109f602d0544911af598d4cfda4d710404de04c8c34f7", + "python/sglang/srt/layers/attention/nsa/nsa_backend_mtp_precompute.py": "e74ca1e0b174c219f9aae462140f16d339903ead6e62988d6cd63ffce24d0547", + "python/sglang/srt/layers/attention/nsa/nsa_indexer.py": "db51e44afa68cff2be1220416999539e850d1347e2aba74e4882d8fbf81223af", + "python/sglang/srt/layers/attention/nsa/quant_k_cache.py": "b6b29464ad973cdc408cff9698262893a45bd967cc1f24d3349d78d45d797d15", + "python/sglang/srt/layers/attention/nsa/tilelang_kernel.py": "7a5b7eb629245d5cb699ef3becbf2595053d7406971aafdc7b72afc2deec84f4", + "python/sglang/srt/layers/attention/nsa/transform_index.py": "593131a485a3e9c39e07bd733d27bb905de16634118e5d562d09088df7e88bcb", + "python/sglang/srt/layers/attention/nsa/triton_kernel.py": "19133e5a120257e73bc2ecbe255b656d7efc743374b899df13c577aba814ee94", + "python/sglang/srt/layers/attention/nsa/utils.py": "1abd4021f8ba49eb793faa3984dfb41fa5f40a32479066d8e26af258fbee8358", + "python/sglang/srt/layers/attention/nsa_backend.py": "6cb122eb32ad5c07d42dfc2bfb2ae43cb3111befa32ae95d03b09fc732bc2de6", + "python/sglang/srt/layers/attention/qsa/__init__.py": "89d2d232717eba289190f9f6eb95b6984a4db3eb213cb709569d76ed6c56142d", + "python/sglang/srt/layers/attention/qsa/config.py": "71a34e48c672480472e2040cc99955f7b7878a14c4ffa61493f290bb61fd1ad8", + "python/sglang/srt/layers/attention/qsa/dsa_indexer.py": "46fed29d13f11e2fc12f7117999969ca8f3564cc1ff3afaff93da29513bbe41c", + "python/sglang/srt/layers/attention/qsa/glue.py": "cb8064f4fb56e76e9f04d03ac12be23b76ebcad1eb1662f91a97c7a3a0f4c2d8", + "python/sglang/srt/layers/attention/qsa/graph_metadata.py": "9dcb66dffb079ca775677c3294ff45c945461fd8893200fc5d6ed26cc9f6d5f6", + "python/sglang/srt/layers/attention/qsa/kernel.py": "5482e38d30bfaf1624ec0625b4896cbb395a1637f75c183c8ca723c9f6055ff8", + "python/sglang/srt/layers/attention/qsa/metadata.py": "c529169cb0e9887a8d52fdbaa6312963747cb48be0a8058445d4de4aedb8f391", + "python/sglang/srt/layers/attention/qsa/mqa.py": "af36d5c8f4fbda5b0e82b7f31046a95c9a709fcc57b3600c6473c49e87b7629f", + "python/sglang/srt/layers/attention/qsa/qsa_indexer.py": "bb57ce1e9abc4fbfcba2c9aaaf125b9e625983966497df57165b6d4c6461afe2", + "python/sglang/srt/layers/attention/qsa/sparse_attn.py": "c7052125569f3c0fa9a0a4d62d2f57433faec636ad82a1d99c3b39e267b7904c", + "python/sglang/srt/layers/attention/qwen_sparse_attn_backend.py": "12c4d4d34774e5592c3a3ba3956d19a280606007e0161598e4e108bb6caa479b", + "python/sglang/srt/layers/attention/tbo_backend.py": "c19db2433ca43a07b36c48de12a69e4fadd846a6b6e991d985a17f613606564f", + "python/sglang/srt/layers/attention/tokenspeed_mla_backend.py": "429c55fa3284e94002ff18a86b7389c1c0376c504d877df8ac48046bc4a9e031", + "python/sglang/srt/layers/attention/torch_flex_backend.py": "12876a0fbede05168a9e8f997385ec1b4f009783ce7bf9c98516f19476ad3480", + "python/sglang/srt/layers/attention/torch_native_backend.py": "5da07edadf56f4f4e4b8319ed48216b5a8ddb989224d3e95011b76800bf9926b", + "python/sglang/srt/layers/attention/triton_backend.py": "0ae50e5eb33ed9bd951fc11f7754932f0b1589b604ac9d2f86b2a80823b58871", + "python/sglang/srt/layers/attention/trtllm_mha_backend.py": "8790ae6905f9d4450f31a6d63299599bcdf65519b93582ff83468da1f09e5054", + "python/sglang/srt/layers/attention/trtllm_mla_backend.py": "a085dc46dd51e832da65a5a8a0d4339ee7c342bdaf7beec781ed7704bcf2133d", + "python/sglang/srt/layers/attention/unified_mem_hooks.py": "a28e90da52dc0c018eb463486abe61509e40460fe85617b3baecfb44a9fe3013", + "python/sglang/srt/layers/attention/verify_mask.py": "e1117a20ca18ab58fe2246a8a29a37fa722d29f797be4658ccf5bfcc1de6e822", + "python/sglang/srt/layers/attention/vision.py": "db8a8d1b81e6274bc71ec96730799031be9cbbda4d33d565ebcb7131e3d044e5", + "python/sglang/srt/layers/attention/vision_utils.py": "13f18a790d2a6c6b9c4b595fa21aad72e9a61ca69d040835d89e600e8d5b9c64", + "python/sglang/srt/layers/attention/wave_backend.py": "a8abae555ead59fe9ecc2ceee687f64d81b74cf068c7816a283b07da908ff23b", + "python/sglang/srt/layers/attention/wave_ops/decode_attention.py": "a093411b9edcc92831b6625ed4c484b1928e2103979c7d225407053ba0d45af6", + "python/sglang/srt/layers/attention/wave_ops/extend_attention.py": "2f2650408bc561f70870e6e0cbfb444cae49c512e0024398945f8a8467061280", + "python/sglang/srt/layers/attention/wave_ops/prefill_attention.py": "76864c1a71632a4ba6629817b204e0eace71fbb90964ea891f0a9e73b4b0c33a", + "python/sglang/srt/layers/attention/xpu_backend.py": "23dd825db34a51db6135992ac4aeabd916ede09b7fef3f8a3b418fe6cbd34a29", + "python/sglang/srt/layers/attn_residual.py": "bd88b41dce435afbd16c230c2365b6fd7f5f5b2669a5cc8fb8976373dc7e6213", + "python/sglang/srt/layers/aux_hidden_states.py": "a3e5218d5d3dd04703385fa8b9dc52ae753731185925d597b2c2a84f69a18fd2", + "python/sglang/srt/layers/clippable_linear.py": "d1d39d6260ec27aff5ca270e8971853f9eb63bddfbca4baad36ce6d9a739d44d", + "python/sglang/srt/layers/communicator.py": "7305647bba46a6cfac7b1eef10a0c4f4ca89e802cd4a1d045774e8e47db0481f", + "python/sglang/srt/layers/communicator_dsa_cp.py": "b1c011dce9ec8b7d2811d5a9e36aac1cf95cbcee064faa4e98b82e5c75c1b1ae", + "python/sglang/srt/layers/conv.py": "f29a48009e55941c23612d3cf3be2114772d56c052fba70f812b06fe6b61d03f", + "python/sglang/srt/layers/cp/__init__.py": "fef93024570eebcfb78444c297d309267fbc830ea9f6d5bd9838c63641bda1b2", + "python/sglang/srt/layers/cp/base.py": "81ac37624ecdbbfc8de587a51fff1c7274e1dc250c167a68c8f37f98d343dd91", + "python/sglang/srt/layers/cp/bcg.py": "cf2c17500ceac68af2dedf0faa841cd1c58d7f44f0441ca818149b95de201b9b", + "python/sglang/srt/layers/cp/cp_decode_attn_tp.py": "779c506f8c7a5e7f862d94808ab8a3b3ab74555cff86cc7201b787de19f538c0", + "python/sglang/srt/layers/cp/interleave.py": "58b03b4361bdb71cf8e85ee9f6f4d07b6c1d51abb52e01e0ce6e20ba1ea8a2d0", + "python/sglang/srt/layers/cp/padding.py": "9aea07f3de7ded66d7a53c78d6574db4e80eb12be7700cea3bad33edeef7220b", + "python/sglang/srt/layers/cp/utils.py": "7cf1c1d05c999fe570fe297f899a147ef20b118f052df49ec530de27d8facb25", + "python/sglang/srt/layers/cp/zigzag.py": "2dee99c67a48f36dba355566265350ed86b141bc2937b0163d8544ef9bd896d3", + "python/sglang/srt/layers/dcp/__init__.py": "78c69e70f2bf0f7423bd8d4a77127266066c08e674adc949f5b317e3e1bfd97c", + "python/sglang/srt/layers/dcp/comm.py": "26eb9e95396c41bc8cd9bdd403241d62c2983837f32f528d9b2387b7fd97869a", + "python/sglang/srt/layers/dcp/layout.py": "5b923260c3b187d8e44bdcfff62ddb02ac7c4b5f49eb71704cb31fab478fabe8", + "python/sglang/srt/layers/dcp/metadata.py": "4dd11b8579b6501aade57fbfb17f54e90af5bbea2ee9680b5e08bf7fb36b8b6a", + "python/sglang/srt/layers/dcp/planner.py": "44bb3013fccf1830673197ee423fa5df2f024a26f1fce5d51435115d1a27419d", + "python/sglang/srt/layers/deep_gemm_wrapper/__init__.py": "7ac24c77462e8faf2de9060ea66205ba258fd89d9dc53302e1b441347d1793a2", + "python/sglang/srt/layers/deep_gemm_wrapper/compile_utils.py": "c021900fe72b46c54fddb3697172e0f4262efcc946e0824cf23093b17027dc74", + "python/sglang/srt/layers/deep_gemm_wrapper/configurer.py": "5ffe5079bbd081d1d24379897f3a750d0ca2caf74b27533b1a00a038fe64cd55", + "python/sglang/srt/layers/deep_gemm_wrapper/entrypoint.py": "b0ddb397f969ec96d0e0b183bec6d6f03c1bce98a8e416edbe09400dec854bf7", + "python/sglang/srt/layers/dp_attention.py": "3b93b699766e9c285885c7e0caf3ffc9db437d70ea2accdaaac1c7ab1681adff", + "python/sglang/srt/layers/flashinfer_comm_fusion.py": "0f2421dd9272f37343d541335007c18383e352ecb2bfcce544cec9e094dad08a", + "python/sglang/srt/layers/hc_mix_triton.py": "da86f494b04236bd897ff43d282125cc54ea77b9fefa56bdc8d54643761265aa", + "python/sglang/srt/layers/hyperconnection.py": "8bdc97375d53e25d9ed819f295bd6002d9937625df30a51e76161705abc7c35d", + "python/sglang/srt/layers/int4fp8_utils.py": "3d3268e58de63a4c211846c32e65b58df0c2933105ab153c219157be3a15c5b4", + "python/sglang/srt/layers/k3_ar_fusion.py": "23a80dcf59440e272b8dec0af1dba482ea0d7a95b19e1891f33612cf113dba09", + "python/sglang/srt/layers/k3_gemm_ar.py": "50db68e017eeec976b54fb314eb85156f9a4d92bb779b1dc2c4abfab5eb205d4", + "python/sglang/srt/layers/k3_sp_collective.py": "44fcd8e0a34a2f180960749126641bdc18c3aba4ae1256d923c295bdd0f000a1", + "python/sglang/srt/layers/layernorm.py": "5f4732b11e072352ec9341ecd68af86567e2a33e75705461b98d93e914f346a6", + "python/sglang/srt/layers/linear.py": "a18935ab61c7340b30464ceaede64f4474551f07ac06a10bfd3c751f0a4d110f", + "python/sglang/srt/layers/logits_processor.py": "b8698de7d00f2d8cc868d8be5d76cedac5317aa93ce1d3d21731be367d1da527", + "python/sglang/srt/layers/logprob_processor.py": "9e0258d52dab060cd4c7065cd6bfa7e6dfe710c508e09b5351a4d5aefa3bac4d", + "python/sglang/srt/layers/logsumexp.py": "43cf9edc381dfe0fd7b86b71dc8ce2b94542fbf2dbbe4ba319d51d79327f0482", + "python/sglang/srt/layers/model_parallel.py": "ec233594a2e12e3de1fc84f863f15a6f5812fbf96b2a218d520cd0dde632b65b", + "python/sglang/srt/layers/modelopt_utils.py": "01b862c26bb554ea1278f256cad805c51c3feaa4ed376aea4fad433c36e8088c", + "python/sglang/srt/layers/moe/__init__.py": "7df9aea0d7c8d2af91641597051f203596cca3e9264a5a107b5a8c26043cfa1d", + "python/sglang/srt/layers/moe/cutlass_moe.py": "2a070a9e6a9f841830894e2c9bffe37d3c87547ec411a99effb5ece039bac2a7", + "python/sglang/srt/layers/moe/cutlass_moe_params.py": "3268018db84bb5dc1623e1b77fe66d2f2b972a1f639a65ae4523a016373e36c3", + "python/sglang/srt/layers/moe/cutlass_w4a8_moe.py": "6be270292282d2fddbb061b06891a726689495da01140a07186fbfc07f351245", + "python/sglang/srt/layers/moe/dwdp/__init__.py": "fda1aff0944af821a5b874b672b446c24a1481ede5b3a453fd4dafd8a08a46bc", + "python/sglang/srt/layers/moe/dwdp/dwdp_manager.py": "d5464b78f28a95b015fab09d932d93250a13a5f34bfcc2d09c55f093c6a74954", + "python/sglang/srt/layers/moe/dwdp/layout.py": "ddfb483885b76c13696bb918038238b368a9927ed96a5376efe899c3a4dc0601", + "python/sglang/srt/layers/moe/dwdp/page_pool.py": "bb8354fca363240be2b1ba76611929d854884fed49606220ae591ae7cea73a1f", + "python/sglang/srt/layers/moe/dwdp/transport.py": "91e17306782a07af849e56f1cfa3d3ffe40e31a8e39362877f66be07aae9aab4", + "python/sglang/srt/layers/moe/dwdp/weight_buffer.py": "59159a7462bde5e347c1b6185ffd119574b427ed20ce5d089efa07054164bbf5", + "python/sglang/srt/layers/moe/dwdp/weight_manager.py": "5e9894e21c179d23df878aa51d3abb5ed39cad4f7bb64c51a27adc139e3661fd", + "python/sglang/srt/layers/moe/ep_moe/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/moe/ep_moe/layer.py": "ff3480f06c3baee391190023a3040c39b970ae890d908c42a00f3c599d2e484a", + "python/sglang/srt/layers/moe/flashinfer_cutedsl_moe.py": "3a153a26287d4e30e82585a9bf1304070635bc0982adee701fc204048b2aebed", + "python/sglang/srt/layers/moe/flashinfer_trtllm_moe.py": "7f5a729870d540ab4f81599e1f59fbe72d8b95d03119bc46f37eb48068c6fa5b", + "python/sglang/srt/layers/moe/fused_moe_native.py": "abfafce66f9bc4565a7aab73a40394d9bc4e042bcf477d5f408553c94a27e498", + "python/sglang/srt/layers/moe/fused_moe_triton/__init__.py": "be2cc3fbe561df1d6eef6eaac65238eeecece81c00f85dc8b5cd1cb504c7d1fc", + "python/sglang/srt/layers/moe/fused_moe_triton/fused_marlin_moe.py": "fab293ee5aaa0d285d161c3bbf23606d2908fe3273eae5f32eb5b49db52f81e4", + "python/sglang/srt/layers/moe/fused_moe_triton/layer.py": "dcb2620e96f23e1004e1439914a807e74293d3c1080db929f9aa542e742e5f05", + "python/sglang/srt/layers/moe/fused_moe_triton/triton_kernels_moe.py": "9eb4b8507b0789db1cb198087a256db28cac913bce36785342428c137ec11882", + "python/sglang/srt/layers/moe/hash_topk.py": "46e637193155824260574ddb085eedb9981298cb1a050ebac62507e6e999f3d2", + "python/sglang/srt/layers/moe/kt_ep_wrapper.py": "639ee63f05ea9767ad267d6d86d9f1b9cecdbbc2970611271e2b771b7bdfdefb", + "python/sglang/srt/layers/moe/mega_moe.py": "fb299d42fae12c78c04cb1760806196f47933b74f0a552826967b77902b0d012", + "python/sglang/srt/layers/moe/mega_moe_sm90.py": "70e8782065a5958eff4a3bbd6986b2a02a8515aab34993d741f8a56658b31e8e", + "python/sglang/srt/layers/moe/moe_runner/__init__.py": "0dce0f1fa1dfcd00e32562fb8ae67ed2a87ca11bbb3ad9c7e88125ebbe696225", + "python/sglang/srt/layers/moe/moe_runner/aiter.py": "459671709b8b7a36ab246f0d0846450b6f6b607de4a17e34831da9e19ce64641", + "python/sglang/srt/layers/moe/moe_runner/ascend.py": "00782903e91d3d9bc17346e15ab950e416a29b609ceaec19b4743c6b5dbb9e51", + "python/sglang/srt/layers/moe/moe_runner/base.py": "66dc391ebd36cf524c058c7ada8bcf32e5fbc446faebf4f672ca6ddcd4f18bd3", + "python/sglang/srt/layers/moe/moe_runner/deep_gemm.py": "c46be8b94401e3ef2619da100688e193b4d352d2e5493e4d7697dd4a92fcf3d6", + "python/sglang/srt/layers/moe/moe_runner/flashinfer_cutedsl.py": "cca94d12d5a062e59582f42b5afa842b72ca1b2baf60367b5542d09f5606da53", + "python/sglang/srt/layers/moe/moe_runner/flashinfer_cutlass.py": "655f7170a7898d28a3c0f539e4f5a2b419509803cd34e32590fff04fb02cf1ad", + "python/sglang/srt/layers/moe/moe_runner/flashinfer_trtllm.py": "b7229908c6ac61f0d78fb82aa77a20077dcbeef72df67e19711d285d495044a8", + "python/sglang/srt/layers/moe/moe_runner/hpc_ops.py": "c138600761d1aefa039eb1048f94fcfe7e6ecc7e7df02f55390aee9ac569f16f", + "python/sglang/srt/layers/moe/moe_runner/humming.py": "57bd948627238de937ad0394f59e40a8b49e6eca91e62c74880df19e0ff847b6", + "python/sglang/srt/layers/moe/moe_runner/marlin.py": "e1db2b78559fd7ed482710f0b95104339ebcd41721a3cb85e17fbc63ab683734", + "python/sglang/srt/layers/moe/moe_runner/runner.py": "46eace8bba47c7f207a264f94b3970ce693657e6cb383f0afc0ea25fb54f2bc5", + "python/sglang/srt/layers/moe/moe_runner/triton.py": "f2d0957311876f2e1c405c5bf18fe105754a32700693a7b83551a075a0dcf475", + "python/sglang/srt/layers/moe/moe_runner/triton_kernels.py": "0f515ee1673e3d4f2e5586c891680ac33971c112b3a5a7f7b52ccabd25b4e84b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/__init__.py": "17001b79d53924601d242d37aa2ba0b144002f02a5b6f1a75e168d97e508829d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/README.md": "6e075121eaff9bfb859498a86bf46cc009b9f3f6a8cc8f0308f959e4bfcdd0ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_sm_100.json": "0d997c67fe7e4b741fbfebae8cc3b88c8f1a4363027409d09d695a77e3000b3e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_sm_90.json": "ccc12031249f4a84a4c534a09217e2846773edf1605c386e9d6dc1473d2768fc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_sm_95.json": "ccc12031249f4a84a4c534a09217e2846773edf1605c386e9d6dc1473d2768fc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_with_prefix_sm_100.json": "ca44d18f28dd39b40ff08052787ec4ea25c994dfe643640f4319aed2a3c0317e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_with_prefix_sm_90.json": "ed8bc5dc1c239ce71fcfc96234612f8efe91025718a4ca9aa0b5490f85a7c323", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/causal_conv1d_fwd_with_prefix_sm_95.json": "6d6dd15bc98773d1f2597c1b683c2a710fb52d092d6c5fb7bd273790217dc9bb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/minimax_m3_gfx950_mxfp8_compact_moe.json": "f08a7280b6fee5aa64b615b007fdd26b344a2958b22023206d0766801a8d68c3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=14336,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "88d1ac13665e5674049cde00f1427d26fd1dde16d1176309f680608eea794b39", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=14336,device_name=NVIDIA_A100-SXM4-80GB.json": "24937486bcb22ebe59bf77524bb0bc70f1610304d3e97c54567046319bd5e890", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=1792,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "a2e4726793c430f3f69e33dfb42361b3ed60d72eb0b9e58b9a123b1b54a35759", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json": "75de1a419d5a7d7684192dd9507df561cde6696853e0beb59b6d904f18ea066f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3072,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "f062d9cce5493697ce5d731068cb6f7294080b33c6de30cd011bc7e0fc475feb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3072,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json": "b3eeea043c7f277985bb4f4d935e1956c786797e463cd452b508e8851098b7a9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3072,device_name=NVIDIA_H100_80GB_HBM3.json": "ca9c6c1feeb6330d9377a23c93a2bc039d83f4e46c52dc1c053861cfe87b7f62", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3584,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "d99dbb68a75a038571aad20293e7ede527351ea452f3b98ddabcbb7178420fd8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json": "c9fdf76265a55528e3ca0d10e0e3005af73d823471bedb4cad005410e7cf9782", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "6563029583759a855150fd9fd2161a737f1d8bfa54819820ca5f5dd83e6b9e87", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=1,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json": "0bae50d8cbf52f1150fea0e7bf5d4867d9f097bb06668ef69d60df94cb6dbb88", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=144,N=512,device_name=NVIDIA_H100_80GB_HBM3.json": "a64e95642861d98d02b094b38ed5213a796d6b540b4d4116cb7dda290538ed76", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1024,device_name=NVIDIA_H100_80GB_HBM3.json": "1a6936e2173995521f42da926b9c0b39c58a79d30df1a6547bddc3061e89d406", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1024,device_name=NVIDIA_H200.json": "b98fd730fa26697317c4891347872d53f61bae2fe332fd95bc2715f9fe8efdbc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1344,device_name=NVIDIA_A100-SXM4-40GB.json": "a4208a91d533cee055b658f293b0042006de0dfd760d48a279768e0d95f39b91", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1344,device_name=NVIDIA_A100-SXM4-80GB.json": "b6b5f6f9ce0dea14d30facc5362e80d9b4f71648712a390cdab3e5fa8d4af6cb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "238779eae0fb13524c5c3f51031ab715e6dd3eab83b2734491568863d0ad9bdc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=14336,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "b2a90f8b86ad54f026c7f43b2ae4eab2f8cb388a6727370beb241122f1ac252f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=14336,device_name=NVIDIA_A100-SXM4-80GB.json": "d1e8e09c843f9b32612a34299d3f88d558fdfab3df1a54dc43cbb471781e914c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1792,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "954e1f8e78099a9cce69f8bedffab4be3da92df6505556a016764da08f7b7ad9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json": "8a551fefa4e66ed68bdd6d1b6ab6ba248044895fe23c8b36f548cb6c7fc662d7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=2048,device_name=NVIDIA_H100_80GB_HBM3.json": "e327b555a908233ac6513c4635bfc3339bf9f5d8cb82893c49e05e53f608e86a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=2688,device_name=NVIDIA_A100-SXM4-80GB.json": "1b83caa96c61d0c941860ed01ca8f49befbf7cfdcb97482ced525a7a0f8d2033", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "6ca5fd02f73137a93e8b745498749c859677ae3a184586f8881aa1088e0bdcc6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3072,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "39e25408f5410f5cfd092a28669cb7851c806ac8caa850106932dc58ae8f5a7a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3072,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json": "3a2117bf19b9b6671bac4b52216952ebbc7ee21f7a803837d4bdec3e34a19c4a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3200,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "7065632b1df8009444d8b198fc95b0a704b9801a83f7f73d4f7c5ed2950c1fd8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3584,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "72ec3d1ed7b3e3a1a43c1f133ed0838891a1192a407ea038f9498bcb7d961c5b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json": "168d609459df9d840ea8dbe4f0a6aed963fdd223bacd3677ea21bd32b95b3d4f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=6400,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "c4e423f72f4240544244167c1bd447330d373eb08dc9ba5c5d1539b0c13ce3e6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json": "d58b056b9203d234c7231386a64b7c55e0f3845f4ba720137d0af2fe29120d5c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json": "14656fb2fc36dc378314b8fb4cdaa6e34d9f02d89bd9c3c645947778f05e529e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json": "9249607f6a8b239090622249e5ef46c71da001f1b17323036297499c85cf57c1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=16,N=800,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "f1ed2d37f0c73f0be1fc7102547c7da0e17fe1659d6a1b78b3a36677f2be6815", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=160,N=192,device_name=NVIDIA_A800-SXM4-80GB.json": "7d1cca7d5148727c6abba0ef18940d96db854511b3f05f9e68bef76c8cc1ce8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=20,N=2048,device_name=NVIDIA_H100_80GB_HBM3.json": "cead71dcac19dd8bb3138d8e3cfb049574ff552f6c2b5df909d07546ca2d2d4e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=24,N=1024,device_name=NVIDIA_H100_80GB_HBM3.json": "9496c46bb56c05528bfe24681e7881fb69dc78cacf72d92ab632acccf9d7e299", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "46e5032bd5df817b3579911259047d6dae2dbbeac2446fd4098c23689e7af2c2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8.json": "c250a2f5aa18a7b65cd464e112eb6f5836ec7b490a9cd69080526c77f2fc6ded", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128, 128].json": "b4f6317a8ff150e92342b64c75ff6fe08685af0d1119a64d2c62c93ce86313f8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "316ecaccd6bb0dc2a6e77bb6261fa69dbf7703720279f8101e474a38d24c7dec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "d1a498ce9bff701025a5608fadf1a035309f69ed4a74a4274f9e84f1715097b0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_H20,block_shape=[128, 128].json": "2443978f8f29870a2e999581c0dabd4e9ab157022b6e77e8b7841f01dcef2c92", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "2eaa26fd53083ddb9265365075e2f65a5ff1debf6ae91988f5ba2326b630419e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=128,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128, 128].json": "5e628568c85eabb34daecbd8089b5eba5d30f34f65fe5e3ad19883402f53a06b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e6ba3d3bc35ffbb301f0d182437415e6407693789259ed2b753cf60385bbd820", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128, 128].json": "e6ba3d3bc35ffbb301f0d182437415e6407693789259ed2b753cf60385bbd820", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8,block_shape=[128, 128].json": "db7089bf775ed540d7dc476e329ca50fd000f2a2f99333128cb2b818332a96ba", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "20c4ca9cf463852a6d7fbb26224a6a98c8d230bf5243b23c0a991b477227cea9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128, 128].json": "c89cc75fc9cd5a72b08fd33cdbcd5dc303e1387434dfd981a6f3601bba68cb74", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4780769f6bc6b78a4fa3a8d2e019a7c7c018b5c7c5f6a4091396c3ece8665c7b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=64,device_name=NVIDIA_A800-SXM4-80GB.json": "6385a99951a5184447a1ea10346910f860be32c12d31b96a9c056e0db01125dc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=64,device_name=NVIDIA_L20,dtype=int8_w8a8.json": "45491df5f5bd59b6a317f7c5233a69b04d6ac96191e5a442e02967f813ddbb6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=256,N=64,device_name=NVIDIA_L40S,dtype=int8_w8a8.json": "49cf712b5c2d454a88cd7a696eeb5cabe6367bd3340d9976386573cc1d1a42e2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "4c1b1caf5b96c2963416b290e58dc43bf420e88f7bbb87ffce39d646fa1e2ef1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_A100-SXM4-80GB.json": "e903cb859bab22a70c55dcb7c340ddee02d588ac6cc89441cfea9df1a8298ba4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_A800-SXM4-80GB.json": "baff91c133594f69f6eb874ba38796c54a41de0ed0a94c9fd8c1441a246fa2a4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "5db09120e9a236a54a87cf69fb4531befb2920d443035895f377fd979c8e4700", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H100_80GB_HBM3.json": "e2e4278c63d6a24b1caf18970c8bdec4e03c3a42b9be4a08ba59afbcc1481288", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "8b90178f6ea6588fb11283a72c26435d4cf3f239364630dc1ae6a24f541849b6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=1280,device_name=NVIDIA_H200.json": "7c92a4e4b10cfcb4a7ab5c9cdde90ba807db516ccfa23400eb25f75e0485a3ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=2560,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "8895659c261334331be94d549d5e3a66e2fff0b7293affd715a61621e44578d0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=2560,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "29fbd2602306e3cbe745bdf977d58ec58c99ba523e441ad41975074315e2e219", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=2560,device_name=NVIDIA_H200.json": "eb4cae3a5bae93aabcf197b4b683c907c873301bc5ed95b2319a6b88c7507f78", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "0c0e0fac2bbf04d2d2596553c0e89c35f6f2a94356ec14d90b6772173f4355b5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H100_80GB_HBM3.json": "a6b8fe43175f4bd36ce5644fbda858fd3afb0b2aa569580d1cf4fcf524b9cf38", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "0148281cad4f98015e852366b1bc6e9e505dccce744399c5bdd9c6f4548e8cec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=320,device_name=NVIDIA_H200.json": "a42e5f76d105739695373a63fd1107873d503eb1af808f62402be5a1d0cfec9f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "c99ffa2a0c09bca3c66e5a5b1cf42f10c71473d17b1bd0349925c77e07f3b60a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_A100-SXM4-80GB.json": "a3138a143ae09b0d589a0c53b516b5ba87b7a74f729532eb923fe3393a8d8754", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_A800-SXM4-80GB.json": "6dfafbd2be8f98cf79c3bada69b40e68e3923e2c14d8e40239987e90a5c87a16", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_GeForce_RTX_4090,dtype=fp8_w8a8.json": "e20f650015099c1fa25705df60f61c234e5714f1b88d8f28d322542bb9123d93", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "4462eaac01af3c2159d2330f0422744eab27ad2756f846d469266eeb571618df", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H100_80GB_HBM3.json": "b231153d54e0500969e2cf2d64b192c9e3736d6eb34ed526d888a81f79d9b088", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "783dd8f6c3b01c572055d39fc9af0ac4f86f2f1fdbe3085f1169b877c6361d6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=64,N=640,device_name=NVIDIA_H200.json": "2887e9672752977d45384aaad0405fc53c96463d504c3c138e43c716334edff0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=AMD_Instinct_MI300X.json": "1e1dec7c1391e63dc7cfd3b6ca83b0e7a03c28061969ba964ebd6e5de9b8befb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=AMD_Instinct_MI325X.json": "1e1dec7c1391e63dc7cfd3b6ca83b0e7a03c28061969ba964ebd6e5de9b8befb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=AMD_Radeon_Graphics.json": "1e1dec7c1391e63dc7cfd3b6ca83b0e7a03c28061969ba964ebd6e5de9b8befb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "57fb200ed12d184b81b0655ad266982478611aa7b5344ee5fb57a4d9e77d58ff", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "2c3e19e4c451e48be2e1b601e61320ca6b6f985c95270aba8267a103b7f379c7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=14336,device_name=NVIDIA_H200.json": "18b207e1e820fa913e3565395ea2ae242a115dc88737a19273735a1383da7988", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=AMD_Instinct_MI300X.json": "cdc36f5f25af79605e7ee093be222d7679050148b7a2edf43c7a6492dc287503", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=AMD_Instinct_MI325X.json": "cdc36f5f25af79605e7ee093be222d7679050148b7a2edf43c7a6492dc287503", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=AMD_Radeon_Graphics.json": "cdc36f5f25af79605e7ee093be222d7679050148b7a2edf43c7a6492dc287503", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_A100-SXM4-40GB.json": "01f7c3734ff9d4c2fc1e2037ef9ef36c3d744d925d52c50321822a3b8834c94c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json": "204601363b7d1c69f3a0e5525af2f40348d4aaaf76e900f4fc1bd5611e110356", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_H100_80GB_HBM3.json": "36cf58d766996c99c585c1b79f06faedb0eaaa2400a3db5d4c021ef0ad808f3e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "a1b36d1e5aacea5e8406a1a6d1ed130f6c11f53628415fcdf58ee89bce3b5899", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=1792,device_name=NVIDIA_H200.json": "8eec4961e59814778b6fef37fc80e0ac7129a1e484babb235c3e379931c174b1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_A100-SXM4-80GB.json": "1cec5698223689f1e659cd28af6cbc9c47a7f3a8c378b0e8bf5fadb8ccee871a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "72c1dece1d0719668dc2b6e51b3320704f7986a6ea8d64bc1c898b44962bfedb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H100_80GB_HBM3.json": "ff9c1e2c18a74020f3c95ef98472884fde58d1c7bde0a59fb76ff9042e8491b4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "e0ee1578ca6014daea5b25aa5a06207180200509ce9405efb76e824525cafac6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=2048,device_name=NVIDIA_H200.json": "a9f8db5ea6e5f74d93ba2cb3ce8994cb6b0cbecf83b9df19a610d16395883c13", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=AMD_Instinct_MI300X.json": "667b25bd3e8796371a9d6c188c5f27b61c2aaff878b63c9bff010b05d7060f8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=AMD_Instinct_MI325X.json": "667b25bd3e8796371a9d6c188c5f27b61c2aaff878b63c9bff010b05d7060f8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=AMD_Radeon_Graphics.json": "667b25bd3e8796371a9d6c188c5f27b61c2aaff878b63c9bff010b05d7060f8f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_A100-SXM4-40GB.json": "46ee3ad1982750fe14f0eb097f017c9fe008fa07dca25351dffab3a311ba0ed6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json": "2ba046acac3fa074c0b478ec66575c8e9f8150cd5d21e70a5ebad19fd3a9446b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_GeForce_RTX_4090,dtype=fp8_w8a8.json": "e10ffec884cc7e28ce32882e50cda7f7a72501187e0d416c4bee285bf6b72697", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "aaa16831a39bb8ef291567126fdab4c18b1d0b879208eec1fbfaee42147537d3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H100_80GB_HBM3.json": "fb99e42c8ba78c6d6084fa1412db76017110c3da068a294fecadd4bd0bfd0aa1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "0578d254676f80fffeef14ef6c738ee99ad759ed2a4978900a1c681c68162fba", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_H200.json": "3e2d9ca0994996982a5e23d177bec1fde0a69a2eec09d06ea1218ad5103960ef", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=3584,device_name=NVIDIA_L40S.json": "a76aa54614edee8c1607c91e126a02acf669a37f48031b0a9d42c543b477f122", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json": "85d598a640567c6f64c1461ca3554d8f053f4bae42a1ab75bb37c4265df751f6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json": "85d598a640567c6f64c1461ca3554d8f053f4bae42a1ab75bb37c4265df751f6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8.json": "85d598a640567c6f64c1461ca3554d8f053f4bae42a1ab75bb37c4265df751f6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_A100-SXM4-80GB.json": "0f162ef2b7a064e485bbcba014603f41bc162b883cc70414645f5afe7358e02b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "a1bcdf13ff5782c6c535f0bd6e260e1f147e57f06073b3ca4fca996496a22497", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H100_80GB_HBM3.json": "ab02b2f2868cb1ddd0ad78106ccff1f7171f6221cafcebb5084c033cbe466e0a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "ad1f1bf8eb90df06ad6fc6f6cee365c4a0d2669ce501a826f676fe15d2a4b7bb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=4096,device_name=NVIDIA_H200.json": "f06fd0a95fc386f67ac526af312a5e13aa9c5cf569b158c4b4969bc9dc9b2aa6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=AMD_Instinct_MI300X.json": "856e3cb7d27ba6d76d8a5e8c28c49f5d5f8743c11b6b748b3a049c36ec2c7928", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=AMD_Instinct_MI325X.json": "856e3cb7d27ba6d76d8a5e8c28c49f5d5f8743c11b6b748b3a049c36ec2c7928", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=AMD_Radeon_Graphics.json": "856e3cb7d27ba6d76d8a5e8c28c49f5d5f8743c11b6b748b3a049c36ec2c7928", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json": "0402675d36687b0c02b7324b50f274a18b802efeb8d0cbc3b8bb1e19cb1869ac", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "f938fb2264ba6450e87ffd154f2abb9159bc5c3f41e78443e8250e3d27f72638", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3.json": "b667b4c9d5b32317400592e4e2d53c1bf5f674951818664d910ccd19c99cbd47", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "dd841a9129942a1a70d4a3bb1e7fad11cfb2c83d5f123d35ffa2654989ebae52", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=7168,device_name=NVIDIA_H200.json": "5b691afd4f29cf08f35fad8d106297477daeb9247fcdf1c3d578d761fe5b801b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json": "f91cd459220002c83a880fbc48f31aebc84fa41568532309b3774b3fb79d46ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json": "f91cd459220002c83a880fbc48f31aebc84fa41568532309b3774b3fb79d46ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=AMD_Radeon_Graphics,dtype=fp8_w8a8.json": "f91cd459220002c83a880fbc48f31aebc84fa41568532309b3774b3fb79d46ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "b18da758c3e1f65b089213c28e41cedb8e70a677c56eb1e6cdd7190d514f570c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_1_0/E=8,N=8192,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "533e57f3455c34139ac6c87054d5048adb47936cea0781d009f4c9e133c6e5a3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_A800-SXM4-80GB.json": "4fefd3fa85b8aa98d3201686571ba4264b1113b620f26f47347809d97991dda2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_H100_80GB_HBM3.json": "237938d7a1db5d4feb61bf2c703f20008e1fb81944947974e8f337e3b41ad75c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_H20.json": "46057c0b81752ced3d874d58b2017f7aa5fa18da01b42eee94f7c945451b83f8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=192,device_name=NVIDIA_H200.json": "9ec344b83364b34b552df41f226ef1c45c047a9b537d07286bd7c9cb4352f314", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H100_80GB_HBM3.json": "478801737b0c6394303ad706c0629d936024e14b146c17778c351e28a9343b55", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a9baa38ac278a0a99c633ba61cf464e54c8ecec762f09eb16acf365161cc7802", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H20.json": "bd2d834480cea96ca206f6c6e87ef8ea8c277e40f517c023d98674113f71965f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "d67e57c99679b0a022f99d5db963a12d47ebea092f9cea6fc5f6ea213ea253fe", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=384,device_name=NVIDIA_H200.json": "c6a865ef8f22b7c195d8a5d7d178b18ad13fcb09ec2a4b2a2bc0062fbb40813f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=512,device_name=NVIDIA_H100_80GB_HBM3.json": "16c59b57843a03302d81e815b843410f3d9971226ca8d8b050855f41ba4fee14", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_A800-SXM4-80GB.json": "4f9ad724e658344b3fde113c837721f34d839f249b36222a767d2cd11949afc5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H100_80GB_HBM3.json": "f4be42f15712b2252be57af25c1d403b70e49e5010a30a7a0d4e92ece4b3100d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "22ebf20bc4cd84254099465f2d2a044ecc822ac99e8ca5ebb3fd33bb014b3c05", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H20.json": "d7436dbb66950f9bc62e89f1fa35b4a8dc3eb606567599b3306c7bbad0d57a78", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "a5d43546f5ef7560e7f18f3ef0c017def9fe4fec1bb6466f1d5f46659bcd8e77", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=768,device_name=NVIDIA_H200.json": "26b68cf8dbdb83957f4c991297a50f15864dd731c7a086ebda901c92c7a7a136", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=128,N=96,device_name=NVIDIA_H20.json": "26d7074653f3f3140402a27d11623ade862f7668d0146e954c7aadb7ce553920", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=129,N=352,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "2fc6d51dd3da07baf991c361a0478df9efc6167cfa39c05cf24db4e849e407b0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=160,N=320,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "65138dd97211459aef277b5b3ee43bfb41ea199fc590fa51377ca3d62b069a98", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=161,N=192,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "780d617f7b245c5ef21371f2dde0cc337b1b973c0fd877d35206be6223d79c96", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "b6d16e2f5aca9c4a52848b66946c8294e7e95302e2e5c65815a560a3b080c670", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "3dcdab8bea83072b257c3f0b809b5107d4035a323e2aa31e0397ed96d8b0cbc9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "baeb9af55ebed47dfc01230f43ad2ded43ad5742102d95810a5d77330436e52b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "7f43c0a3642bae37bb04f632a81db56b3f93872cb6cc286d0ed4df00591e9fe5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "0423be7148c01b5784f48ffd2e8892b47533f1d1106298e23f31ed4d75f22c5d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "ed89ad6972a7997f037589d427b59015aef18ebd98ba7f5621d40da027ff2b6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f2035a9a29fa3aa32243e2cc55ee32401a3d38d8a8882e25a1258f9ca712d572", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "dd9b7885b0b7c89c56bcfd13ecaf776003da50ff1f4353f55a4d021aab4181af", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=264,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3fc1a9551f1f8eb5fb3856c1045138cb8309e2e860a32515e0d6029b5aa15b19", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json": "e01d129b3450dbe3ec0497057bb9de33538a7d6a6c6e2638c7a73a08e40d32c4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "5f288e0ae7e102ee4108c1e85bdab880b49140419ddb66c99c9930d7932a1588", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "7f91d38bff5f5af227132269f2916069537a03dbf1bb7ffce3979264637d629a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=272,N=64,device_name=NVIDIA_A800-SXM4-80GB.json": "3e2c382cde9df1062b51a856b30dd750eb53303d68def1cfc00f78b06239e869", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=288,N=64,device_name=NVIDIA_A800-SXM4-80GB.json": "dd3f3fac5d8f1288e181333243c0ec71780909659d59f0cf8f8338df8cd6700e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_2_0/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3.json": "b667b4c9d5b32317400592e4e2d53c1bf5f674951818664d910ccd19c99cbd47", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_0/E=16,N=1024,device_name=NVIDIA_B200.json": "85ef3bddaa0ecbb29f160fae3284c557820fed89340e4ee6393b8b093ab06597", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=352,device_name=NVIDIA_RTX_6000_Ada_Generation,dtype=fp8_w8a8.json": "44c630aad07b85879a0b2b99d5f7959d18411a53788cc7263505f686a52a0659", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=384,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "2cdc755bf06c5997291e89a249c0916a9e3a755d3e17b4bfc371edb24a2a966f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a9ceea9c093705870fe66fde4fc20f0df9ef16b9e0fe4891092dfafd4cb5336a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=768,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "25f2d91d50bce19b075487612768c64fdaf666a186c41a88671e0746315ce27e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=128,N=768,device_name=NVIDIA_H20.json": "4f6b0d1d56422dbcae3baf197ae754cd0301b00433b36f9ea39dc8f84508b963", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "aea3d6a517daf6ced449af5c5321c054fe74598902a970c9cdf29986a93a187c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=320,device_name=NVIDIA_H20-3e.json": "716904a4daa7ca7d104bc1dc8168b0588d71aa1fd4f77fd2d64c8d79bebd68e7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=384,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "8c659f64d3f94f57a7f0a5f4ffde25aaa4ca4505c2fca92afe526bb58e2013c6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=160,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "9da2b0fb6a9bcb6c43ba96752e66ad7f6a3f0a86e476f152f15e8250e4562e92", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "396dd6d36f4e6e6e07a22bb165b6e34c3c13508199e10afdcc3b2e99873d9bb9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "3f46edcf1e4aa2b0a7a94c58cdbb9b21f5217dabe36b6f1dfbba447625c8d138", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "7e8d5a902b86a2a706c1081f879ea1029820fb02d77e8f641c792c13fea6d45e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a07e1b0a48c17bd3e1bea7dda939750e79e1f791da3d3e375438b3ed58e43140", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "31e50b5d6c8defdae8b124c9a7740e0e613fc844070a470322f01537758e4816", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "573d60f98b5359cbf9ef7118691ecbce1265472a2768cb073d3d8c323b9127d9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=384,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "10d0d89c2d658cf3690d51dd9aa47b51b803593d483ffe7964843f39a7b7e262", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=384,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e5402cf19d66cb0f05fb9158d871d677958c4f68a2f57f9a6086247f716c03cb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=384,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "f78d595c9b62f7dfc651e8b29703d45aa60af1be78f31b8d223bf4a73f4a72a8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=385,N=128,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "ae017e2920145e623b406ae1314cb03d57de4f1cff8fcfc83f837ee9b91875a9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=385,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "eda6a88b4308db10b964991f9644d9007e2d6b04cf76652999c04e80e2272b1b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_3_1/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3.json": "6bd5c96745ee7544de6c074de60b95abedd74af65eb472118dab4ed7eff4c429", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "258d7cdf6b08b753085846687ca998a1d2cdcd537877b3553a2d26181b8a1293", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=1856,device_name=NVIDIA_L40S.json": "843c6b9bb214a1997d01747740eddda05098b2b4c7ddefbba71d94c8cf692680", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8.json": "f8c65a67847daf9464f1af4e11ad5e33f4ba20d95cb17ebc063e7fa4ce006b45", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=352,device_name=NVIDIA_RTX_5880_Ada_Generation,dtype=fp8_w8a8.json": "2fb69c50c0e661939e03eae211db35fabf56b2ad8a0562651bb5fbae29568df0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=384,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "e896063788a6c3322b4001206e848ef77c16601ba0bb34e00637d379dab673f4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=128,N=928,device_name=NVIDIA_L40S.json": "6cc134108aa31e1522de15ccf3a4af402d03a89beaa88079fab1625548ebc84d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=129,N=352,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "0a53e8808366e40b278c3ab1e87cffac7ae69e709d50f89dfa3608748823671b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=129,N=352,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition,dtype=fp8_w8a8.json": "44c630aad07b85879a0b2b99d5f7959d18411a53788cc7263505f686a52a0659", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=129,N=704,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "5bc0b51ad3f82b8dd22bdd76f14e760c3e565a87ef3e5780244e2eb36423bb59", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=160,N=384,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "1d197aeebf7c2724576f64a45d418c54a01c44c6f1f4c22b245a7c3b54969e83", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=161,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "eda579fbd27b541c3a7a0909c82f86babc3904f4dc86c6eba27b351286db89d6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=161,N=384,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition,dtype=fp8_w8a8.json": "44c630aad07b85879a0b2b99d5f7959d18411a53788cc7263505f686a52a0659", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "4fa902b42532b42c625bc24e2df105dd881d083f7f98a71c27ce48a93d1bf0b5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=256,device_name=NVIDIA_B200.json": "3642d5722e6ed8619eb856c2dddffa3e27014b7992b95efb2480824b353ff1c7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=256,device_name=NVIDIA_H800,dtype=fp8_w8a8,block_shape=[128, 128].json": "3375b539053a46028040bd84a188af00889db73d5cbe0a0aebfea7b4d7e7fe56", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=512,device_name=NVIDIA_B200.json": "b9c517c01b040e35f23045446034eb038e567d63937dda68d7d6d36f2bffbd97", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=256,N=512,device_name=NVIDIA_H20.json": "6d27be294c22553df233d8d0b979439b17bf2947edec5527e7339bcbc6e94a47", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "45b2584d17e33ffdfecad7e3e775bfc368c5a59f71c0c6aaa0a5b9da99203f77", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "85a3ac0b17e396eabc44828e2b5bc4d13bab121c7659a0759c7e0a75d8d198c6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "6815bbd1e8ee6c9ec9101a7d434c1a4c9e60fda243b5629dd9c93a56d3061a14", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=257,N=64,device_name=NVIDIA_A100-SXM4-80GB.json": "40493c6c4f8689e665b538afde283ffd270cf50ff82be73be54cc8b83ac698f0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=384,N=128,device_name=,dtype=int4_w4a16.json": "739e5a0ae85eaa88a123ca9f32ffe800300c7bc8adcc2e5d63f4eb7b98908159", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=384,N=128,device_name=,dtype=int4_w4a16_down.json": "739e5a0ae85eaa88a123ca9f32ffe800300c7bc8adcc2e5d63f4eb7b98908159", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=384,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "1449e3bafbe4cbe72f5b58aaf133eb7c638e1fccb8ace131e23958678b6a6c3b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H100_80GB_HBM3.json": "254ceaeaf273380570dd5397cc28c1a5a2e97f93b13d09a8da224f263ccc9baa", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H20-3e.json": "6ab4d7b0b91ae315a408444d05ac911ea7e1c2bb6a75dfd8872f92ce25554d96", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H200.json": "1d11895aacb5082ee8b9163a7bfb770bcdf608cd01225434668ea7a1fcc17fc9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=128,device_name=NVIDIA_H800,dtype=fp8_w8a8,block_shape=[128, 128].json": "d8f289e3e98bc55583826f3526d923469cf598a710ced19d991f3822d94c59f4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=256,device_name=NVIDIA_B200.json": "3dbb49d1d256600058923a0dffabefb124606c690dbc614d8d04f7f2a89dd7ee", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=256,device_name=NVIDIA_H20-3e.json": "de839016c6ce8de8c7ff341a31894a52d43a4a7c481f9fdfdd421a15f4a573c5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=256,device_name=NVIDIA_H200.json": "9a688d50d15a8e56128c55cbd03332912e88f83d4ff004177510697820110fed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=64,device_name=NVIDIA_H100_80GB_HBM3.json": "15e4402a415497788c94d041adbfd8a1ee0eb16caf49b56de7ec265c48cb6c54", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_4_0/E=512,N=64,device_name=NVIDIA_H200.json": "a619a1910373f0370b1cfa8de6d8e626a3a06d7d01850c7d70ff367e9fe3c884", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json": "d7cd2d02c8485903be9d7748a6ce5e59d4aeafd3b09b2bbcf4dd2d895aebef94", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8_down.json": "d7cd2d02c8485903be9d7748a6ce5e59d4aeafd3b09b2bbcf4dd2d895aebef94", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1344,device_name=NVIDIA_B200.json": "e148af672111c72e10ed900eb91dd7b03685283aaaa740057950934208d24954", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "65d860614936717d909f85778998708a4fd23bfb5976077d52fe4efc2c0cb020", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1856,device_name=NVIDIA_B200.json": "4436c2bfbc22853263ca73e1b9092952da06843df216bbdd827dc8ba37f7da1f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "21aabda50ed3348325e25327464f6a33ffb470415142c2a947b388fbd3b09809", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=232,device_name=NVIDIA_B200.json": "7fc486f6f8c7f14312bf3bbe898eec9241c503cfbcc92d7cbf68732775b36867", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=232,device_name=NVIDIA_H100_80GB_HBM3.json": "ccf4a3dd1c6354ffd4b3c4d30b33d7412677af7a851faf2e216fc61be21b6eb3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=2688,device_name=NVIDIA_B200.json": "b0fda1dc65b4fe6feaba18551749b13e7ce63e96658f18def48cc7e915a5bf04", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "bc7efd575e2ad3223f03fc7442899e976904e3cbbd206764a911392b693cbe0b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=352,device_name=NVIDIA_B200.json": "ffed937219bf96ea7012abc427d8baa0ac920653bfd6954e9f65be2e23bfbcb4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=352,device_name=NVIDIA_H100_80GB_HBM3.json": "23df74db06dc672a8c400b16b52a8f58002284ffed6d6b96a013d0e2089c78cd", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=464,device_name=NVIDIA_B200.json": "d2dc681e2eb9b7cd90de9452a13a46b0ead362e957837986dbdd83ca16f0d3de", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=464,device_name=NVIDIA_H100_80GB_HBM3.json": "1ab05dd5e86a8231f9aaea486aaabbb7c8cba1a75cebe65a7d40b66300684ffe", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=704,device_name=NVIDIA_B200.json": "7bac882743da5749cfb1c826897965f325f1b8a9a666a8b5b5a5e362aebcf552", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=704,device_name=NVIDIA_H100_80GB_HBM3.json": "e0f0cd1a8fdda9b6176b5a07aac0a7030d5992edbba43e111b0c4231bcd6d7a4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=928,device_name=NVIDIA_B200.json": "ddd675749dd4da25bdf7b776d7bd0a79ccc0a5fbe8f6c9754924456ed8ba8a2b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=128,N=928,device_name=NVIDIA_H100_80GB_HBM3.json": "952ee3f7049513b4053db9b4549d1e5d8bce3a50139d526bc63e27c7e42d7304", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=16,N=1856,device_name=NVIDIA_B200.json": "4e362b8e978e57401a3846b6a24fed65af3a3e5bc6ba4ec6d1cabb64a6028f69", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=16,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "dbc3beaa3f68bb26e6d568c8c0c40cf637b9f4066052dc9c23129b50f86e9128", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=16,N=2048,device_name=NVIDIA_B200.json": "529f2b3eea08222c5a79afec1b93caa3ed599292cdcf07ac3a864fa128234fd1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_B200,dtype=fp8_w8a8,per_channel_quant=True.json": "7d6f53d4b97bca14965a98778f99e3c553b5f188b63cda946dc63ea3c0746f0b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H20,dtype=fp8_w8a8,per_channel_quant=True.json": "da049f5fb6789cf130ef362e8e221caee4e090091603a8a064277f8c70e3c36c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,per_channel_quant=True.json": "a05f66743170059d7b2a78374bd7a30c416206fcdcf26ad64d12656bd082ffa3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "a997d5122122d8d286931d8c0ff1ec23c424ae6cd561b09fc60c5efd5d405b69", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_H200.json": "e82d8f40230528c208e655ac861245cb1fc75829c79adff888e4a688f217378c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition,dtype=fp8_w8a8,per_channel_quant=True.json": "f6d9e73dfb6bd35dbaa4ace6030817a29848742245a38c788dcb2cc491f4fd90", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=192,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Max-Q_Workstation_Edition.json": "29826c7e8507d4cec5c79bf818c146f4d84a2289854b9a439b067a2b6e319683", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=384,device_name=NVIDIA_B200,dtype=fp8_w8a8,per_channel_quant=True.json": "71e4389df4e54eb7e28d5318f7de6214a916bed38b316e48d4b5d2fed2b39169", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=161,N=384,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "75f32678bc5c80676a35c94acdf1895fa7d23cdd32ebe1713033d60e3e119e9b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_B200,dtype=fp8_w8a8.json": "3e6ed775a6afd26bcd424c716eef360bf7df8663fb78377606652169497fe1b0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20,dtype=fp8_w8a8.json": "de039ac7bedca8bcb6af0b37434c7a3d6ae7ef574e3063befef30b53be1247ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20,dtype=fp8_w8a8_down.json": "de039ac7bedca8bcb6af0b37434c7a3d6ae7ef574e3063befef30b53be1247ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8.json": "2b46e9a118e2e2913c04370d0d2d5e5e583f943df98415eb131d64bc1c2bd45f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8_down.json": "2b46e9a118e2e2913c04370d0d2d5e5e583f943df98415eb131d64bc1c2bd45f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e.json": "6e1ddf115cce355e9e20a9f9ae8ec31f8730495ccbe464587464f8137590d37e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20-3e_down.json": "6e1ddf115cce355e9e20a9f9ae8ec31f8730495ccbe464587464f8137590d37e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20.json": "aa020ec22d8750fd9460c2d772e6c026953c197aa8bffe5e75a7720a38680533", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=192,N=192,device_name=NVIDIA_H20_down.json": "aa020ec22d8750fd9460c2d772e6c026953c197aa8bffe5e75a7720a38680533", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=20,N=1536,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "403477abd3f7102384febf551596d082185d717b88012a03c6daa8f72be179df", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=20,N=1536,device_name=NVIDIA_H200.json": "f43d515d1d7bf385c176900985b5179ea77cd644e0cb305396a581a2333f95c4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=1344,device_name=NVIDIA_B200.json": "a1ea86a173e803ecde95bf6a0582fda52cf6dcad7afca7dd17a1680ad15bd55d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "fc6d86a18730cde466839fca66b4f6235eef0b78197502b174a8d5e0caa4817a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "a1fbe0eb240031ae9b933135053d210e03a38940e6e36d8bfa48d4c7c63660ad", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "211ebb031054e6b5612f2b9c58e97df23cad890e33441117aadd35dacd2421be", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "a1fbe0eb240031ae9b933135053d210e03a38940e6e36d8bfa48d4c7c63660ad", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "211ebb031054e6b5612f2b9c58e97df23cad890e33441117aadd35dacd2421be", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=2688,device_name=NVIDIA_B200.json": "cfab9577a4e218eb0a5213aaa24d47078b7cf64d44cccb1852408767b381c9d1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "057233d0d5f2a2cbfd3077292ddb65c19266bade5ad8e7b0beaa075afbaf0f40", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=384,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "215aeb8489333f5b7d1cc454217a55e9d6ea0ea25c6c6d11339639d29ab3b897", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "9ca68260b79e11471f9540baac49bf0899c078a2bf986dbc52fe386a431c4dc5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "791325ae16cb1e05de42308a5ba86148cca6d2a8abc23a03e013c3e90080098e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "53e8f44228725f4e53f1edf1ba60daf74d11a33adcfa8d0fe86ad0ef6c5a04c0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "791325ae16cb1e05de42308a5ba86148cca6d2a8abc23a03e013c3e90080098e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "53e8f44228725f4e53f1edf1ba60daf74d11a33adcfa8d0fe86ad0ef6c5a04c0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e.json": "780a5f0cc7bb8051dbc921e53cbe4b1db84be972b93c7760ef4e671386431451", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20-3e_down.json": "65efd6589261943ef87a0b794d9daf2263fef611bb42937ae9a15acbb1577f1d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20.json": "780a5f0cc7bb8051dbc921e53cbe4b1db84be972b93c7760ef4e671386431451", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=512,device_name=NVIDIA_H20_down.json": "65efd6589261943ef87a0b794d9daf2263fef611bb42937ae9a15acbb1577f1d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=672,device_name=NVIDIA_B200.json": "496faa17aadbf3c53d0f890cee9c8377f4a90646a3e5a8e7e0b27c5ecdb5a1bf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=256,N=672,device_name=NVIDIA_H100_80GB_HBM3.json": "4b8f9d863f0125d28f77502d51fe02881b7e485351a01fad3bd742dbee1fdfaa", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "19e6b3a96b5bbf1340cf05ae23ef384b8c6f5fe49457b4b7ff88115d2e42c831", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "4753bac1380c741d3c16956f90557f3529edc3b161a6f38c772dc223992daa6f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "64adeda916e9750122b060e6669068c7a5a3ec8234bfe2499e49199a9b0a96a9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "464c6d9660521a06c6b4a90a8a30790ae109b99816875179953b915def013576", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "8c4f4083d952668a7ebdc284ab87b565e03700e63523a28a80b78940b688191e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "0a88a3611a9f18b95280fda9461e3a553c3b254c3db774fd7e337facd960b4ae", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "9a8a5a9c503f4ab7e4348e07a09483868740573668b42e0a17b01889ded4562d", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128, 128].json": "421c5282a574b7afb76f9dd6d55eb6ef9f302017ab4029a065b2943e79d1ef9c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=257,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "381e68ebed0c9bf130dd898750aeb8a40ef787d69aa5ad40ae15db37c89c3ae4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1792,device_name=NVIDIA_B200.json": "b046ed083381bacf17a9baf43ceb7171602f412d57c2ca7aa8204294af945199", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1792,device_name=NVIDIA_H100_80GB_HBM3.json": "80184412ca386f603dc6190cc66bf54cb1419e493eebb5044573c0ab66cb812c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1856,device_name=NVIDIA_B200.json": "d4ebcb1373a0020f6c8497e28e25db5ec66ee9fbb6cc94210217037a46762e1f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "e3a5191eec788aa853ea8716e3ab807324690ec80a1349a8bb14f15e5a400bc8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=224,device_name=NVIDIA_B200.json": "94083a6d2f7e7e95da305df0c0ed40ae532a702078bc8cc44f036d7b5193c4a3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=224,device_name=NVIDIA_H100_80GB_HBM3.json": "1aea06bae1b7b49f157e1b1e70a1abd43b3722fe57434d820583c8c5a131a2e5", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=448,device_name=NVIDIA_B200.json": "7eea850ff3a2c35695b367f446a1cdfcb12a232216bd3a7ca6a361c63f927a95", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=448,device_name=NVIDIA_H100_80GB_HBM3.json": "c3abe23ca68c22649bca1a91f0e13d25d207359bb78439182db98ba034caf6d8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=896,device_name=NVIDIA_B200.json": "5f0f987dafd9459e72f8086c8ed60650143c3a75a37c05e8d502323664d4906e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=896,device_name=NVIDIA_H100_80GB_HBM3.json": "110d7f5b6310d37b8b8ceab952a76b286ebd735a6e572c6d43658b8ee3c19caa", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=928,device_name=NVIDIA_B200.json": "4c722ca4b35d04df58b5d07907fff8f2e361069cab61ce859767fadfe528bdb1", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=32,N=928,device_name=NVIDIA_H100_80GB_HBM3.json": "370d52bc59d130081cec0a79ce8058639fbe0fca6caf5cd701df1d5ccfec5be2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128].json": "4166cc74a782dbd1074bcbf302838a5cc5254c1d291240c13a3764d09f8374ec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "c13ab178c2557ec886aaefd13b28a3bc7c5036d4fb065b69ef76e1786b2ae1b4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128].json": "4166cc74a782dbd1074bcbf302838a5cc5254c1d291240c13a3764d09f8374ec", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=384,N=384,device_name=NVIDIA_H20-3e,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "c13ab178c2557ec886aaefd13b28a3bc7c5036d4fb065b69ef76e1786b2ae1b4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=40,N=1536,device_name=NVIDIA_H200,dtype=fp8_w8a8,per_channel_quant=True.json": "bec7a6de5d1d3c266802102bd582f82c45a263342e0408e6d2cc8083de7addc2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=128,device_name=NVIDIA_B200.json": "9ca8dff039717269e7d81215e6e7305d35c93af84737895cd8b7993f679c38e0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "020b7a36328778ec8a245da1523e047c24d3f73b5a485282000166412cf0e745", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=128,device_name=NVIDIA_H200.json": "c8ef7ff493727b450bb8547648c60dd73c726aaa425b3825474fcb9b29abbbaf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=1344,device_name=NVIDIA_B200.json": "3cfb859c279cefafdaed984ae188eb558f43ad42a5fd2ad1ece4dc5ac66099a0", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json": "de21a66a3636480cbb9add7c5bd9017797c2346bddab2b319a2acdd6753fb158", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=256,device_name=NVIDIA_B200.json": "6e70f307b4e1fa82c3cc573c1ad421c244d0578074139372705672e4309e66ed", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=256,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128, 128].json": "d365e3fe134b5cf69ff234e6923d35e91201098e2ddc61a9ad0efbfcc8b50f2b", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=256,device_name=NVIDIA_H200.json": "e7478e6689b965bc3fcd45e114881a6d88c9ef2c933b5501ec8eb6b82614e305", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=2688,device_name=NVIDIA_B200.json": "1b82e6baca090de90062682b4631b0e78633c31be690547bd43c925278920cae", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "0963e8cd396c736bc91c6bd29e3f7175d4812054377b17ea1b6f3c91d2538218", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=336,device_name=NVIDIA_B200.json": "90cc65e7f99a13029758d1678708bb235f6bb58f3dfd118b2191102b60d4084c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=336,device_name=NVIDIA_H100_80GB_HBM3.json": "ce9fbc962e0623c6e08c81a5b70e57b496a61b6bc953efadb235d53ce3064603", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=672,device_name=NVIDIA_B200.json": "a09f90d7e21dcaa0d87479c144565e12c39cc1ed2f339207320b75772b252185", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=512,N=672,device_name=NVIDIA_H100_80GB_HBM3.json": "1035ffd39b5c925146fba8c8c4300f6819f5cdc1ac3b939b74a148c3f7dcfc96", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1536,device_name=NVIDIA_B200.json": "a56b9885e11b11fe27eca5f7374b803416ab0ab7c45a5180e618574e68ca28be", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1536,device_name=NVIDIA_H100_80GB_HBM3.json": "3bfb9217dca5085b2478d6d163560c531206fed385639bf55f2f6652289c31cb", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1856,device_name=NVIDIA_B200.json": "c03cd023342457d5e94de50bc854b5fa1cbb6645fae36901525520631be84bb7", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=1856,device_name=NVIDIA_H100_80GB_HBM3.json": "44cc31dc0e3dce2b1edeaae90b7346b7759c966600d38ca9184df658fc55ad64", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=192,device_name=NVIDIA_B200.json": "156c92cd714998c9efd2375cdb1665d644229387a4029d86e2783d42ff0e608c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=192,device_name=NVIDIA_H100_80GB_HBM3.json": "ff610d631377f1bfb5ac2ede4e38b8037ce9c5058076daa6acbfb14a057bfe0f", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=2688,device_name=NVIDIA_B200.json": "93251d3ad9bda0cf1323c9081077cef8758d1eb443a5a8fba9c36a8387bd2992", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json": "5ad6440146e11c16f95a71c837c9277704a475f6c8185e2dd3a52eca4d93f977", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=384,device_name=NVIDIA_B200.json": "13163b688aa88ac589c53d74e39a1f2850ac4c9c1d25a7f557476b65b2d160a3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=384,device_name=NVIDIA_H100_80GB_HBM3.json": "21d1afde8079375ebf0f56327af3c494425f265ddbe7f89f8c47e739f2fab16e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=464,device_name=NVIDIA_B200.json": "0ccb8bc37bfc9d4788fdb68663f5d31ae133eacc14379a75878c9776ff7d3ce9", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=464,device_name=NVIDIA_H100_80GB_HBM3.json": "4eed6ee67e88f74a1e35e7a0887f6fdef079d99d59779b2fd2d1de917e7e9918", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=768,device_name=NVIDIA_B200.json": "21ee026818f8e17533a823f1e0579c4abce9573a1ad1733318588a8edf2f7487", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=768,device_name=NVIDIA_H100_80GB_HBM3.json": "25843603641dd86f223e82b36fed94da68d7d2508a343f8d6467f28346bdcacc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=928,device_name=NVIDIA_B200.json": "0bf60f991a0c825878914f15be16be82539a61cbdd5c1be8f6dc57d31a8dd46a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=64,N=928,device_name=NVIDIA_H100_80GB_HBM3.json": "20feaa1dba0d5641c4fc23c861cc4b56e9287a9144e847e7934a690e3ba518fd", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=65,N=1536,device_name=NVIDIA_H100_80GB_HBM3.json": "5873ea5db4da7fa9109f33e00a436cf15c515f1c6c05a413362fd43024cd5d63", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=65,N=1536,device_name=NVIDIA_H100_80GB_HBM3_down.json": "5873ea5db4da7fa9109f33e00a436cf15c515f1c6c05a413362fd43024cd5d63", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=80,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "49a8912ee6f4d1ed31b74f6b8883feb7d78344f92cde98a6c37d61eba85dc3d3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_5_1/E=80,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "e3a3b851c9bb799fe6e02641cca8b43d9a462761e23afe0d42a144d4b263a07a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=384,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128, 128].json": "ee12de31d61c4bd184789e235fa1778861f7428610c20c841abdf7a3361a3abc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=704,device_name=NVIDIA_H200.json": "b395443d24926c1f59d90ad0d3caa7989f9d16c5ffaedbaebab33db247d60e11", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=704,device_name=NVIDIA_H200_down.json": "b395443d24926c1f59d90ad0d3caa7989f9d16c5ffaedbaebab33db247d60e11", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=768,device_name=NVIDIA_GB10,dtype=fp8_w8a8.json": "b8e1c318bb84c878c3d8dbb9f726cfc13e3ce5abbe2c9776941d2e407de6e146", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=128,N=768,device_name=NVIDIA_H200.json": "26b68cf8dbdb83957f4c991297a50f15864dd731c7a086ebda901c92c7a7a136", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=129,N=384,device_name=NVIDIA_H200.json": "f9eb906bb7187c17d1f863e1cb10a499045957b31003eb92d74cfbeb72754451", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=16,N=1408,device_name=NVIDIA_H100_80GB_HBM3.json": "9a06fdb55915bfd138b536ce00ab32ea145ad02c9eda46f4377baaaf361d1831", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=256,N=512,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Server_Edition.json": "d12a7ad0d2bbe834d9a3e116232e565d84698356d758876a6b52f3d9f8f451dc", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=256,N=512,device_name=NVIDIA_RTX_PRO_6000_Blackwell_Server_Edition_down.json": "174955761db4a5b76646121ecd5ad3791bd13bf06644727d8c27b7577401dc56", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=1792,device_name=AMD_Instinct_MI325X.json": "9eeaee332cb79ee55b66897732933b6e6a9fa15933b69ebfbcb47432692392cf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=224,device_name=AMD_Instinct_MI325X.json": "202a5ef736257dbcab3f5cd64179ffb02428d09c90833731a6a5fc5a6f9346f4", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=448,device_name=AMD_Instinct_MI325X.json": "3406b2127e82acfee4847af4451cb748e5c5e8592fc3cfaf16f8852027430533", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=768,device_name=NVIDIA_H100_80GB_HBM3.json": "e52f46c62bd30196e895f6a1fbe78b6c56ec03aa93f1adca1fbe66a736f66e28", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=32,N=896,device_name=AMD_Instinct_MI325X.json": "74baceb424aa18890bf1bfc4ba3643e2e31a4c27b2d4d7c0b72ddf4691a74df3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=512,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "162a768a5d0f37d9753d4f171f656c99af0cc6c16069b44b9c462bd930aa59a8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=512,N=128,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "dc118fb2c7742aaa0a08571a838bf552fd7fb2ceac8d382a3679afa535e257f8", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=513,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128].json": "f9e3579e163b27e886ecff73211044e3f56f6168019258f3c115efd519e5b0bf", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=513,N=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128, 128]_down.json": "f09913c7aadf0aab089a2d4bc26dfaec9ec4bdbe2d497638914e700c858c51ea", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=1536,device_name=AMD_Instinct_MI325X.json": "7f7785d11e38b720edeeb2b33faf0594509974880f9afab91213dd2d3fd15d36", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=192,device_name=AMD_Instinct_MI325X.json": "458d6e7e4ed21f527345a0bd542d1c1506efb5f0e605a4f10439d27d487a4c59", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=384,device_name=AMD_Instinct_MI325X.json": "8a53e814d5c7bb9b8a5ad31bacd42d0379ea56258b588d8b1e01b49f22e00b71", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_6_0/E=64,N=768,device_name=AMD_Instinct_MI325X.json": "f7c00f1942e95888081de80941b6f11935eca620cf3177e9e43cb39d2860aa8a", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=256,N=512,device_name=NVIDIA_H200.json": "29d2963611a6efd579bcad4096c5483509903fa1381ab1afe3fb9e8180a981c6", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=256,N=512,device_name=NVIDIA_H200_down.json": "580ba806aee263268a95c250b7ffc47cf073cfa1f55c2f5b2434e0c42787b3a2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=512,N=160,device_name=NVIDIA_H200.json": "d2324a321541e510c2caf6ba09a190295bf8e5035031052f180300ef286a6b46", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=512,N=320,device_name=NVIDIA_H200.json": "6605724a9be662ffd476ec7c33614aac57e13d1c321166f7f11ed14518636d07", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/triton_3_7_1/E=512,N=80,device_name=NVIDIA_H200.json": "4bfcd012ce58ded82f11cda93415597743bfe5b66ddd5d10cef34765125d32e2", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/update_sconv_cache_sm_100.json": "9e93756af03b3ff1ba35b6fe64d09ee2b5f3cb9209ea0735593d152314b627c3", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/update_sconv_cache_sm_90.json": "9eb4322b6584e78392e0108d2b1857978aa78d9f4e56159fa9ca7ef150182b9c", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/update_sconv_cache_sm_95.json": "4fc9b82db8223ede1afbdcefdfd05e92ec8fe6de2afc66f101e81687eabf2896", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/fused_moe.py": "1858f4050d3465b3b1f7fce979713e6c8f56a14cf8298c99a105b5877dd6431e", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/fused_moe_triton_config.py": "022c8aa47972dd975ebf7be9c6d04ac4c60604cf705cf80c9b38e45973193d09", + "python/sglang/srt/layers/moe/moe_runner/triton_utils/moe_align_block_size.py": "3556aba5fc1142546f30d1f03034831e6893ee5ce05d868c29207485cb28df78", + "python/sglang/srt/layers/moe/route_quant_handoff.py": "9bb752e7763be1640ae03541c0ef064813786e6cfb98a712a42de12ce44d86aa", + "python/sglang/srt/layers/moe/token_dispatcher/__init__.py": "e79e4a67cffbd6af9d5fa53fd8055ef54c9d3dee54bd5e90aa0540f25cfaa161", + "python/sglang/srt/layers/moe/token_dispatcher/ascend_tp.py": "28e97cf60dc67a01444f97b66e9bcab6b99cbc35a29b3a3c9c93b601066bbd67", + "python/sglang/srt/layers/moe/token_dispatcher/base.py": "a77e88375ac36c3997a704fe909fc7c9b66e4f51605f6d86efec69f3c84b2fc3", + "python/sglang/srt/layers/moe/token_dispatcher/deepep.py": "201827c6ffb2289392b9e1b36908ca524009c864d07e19388603f435efd76d2d", + "python/sglang/srt/layers/moe/token_dispatcher/flashinfer.py": "e411261fa1fdd2a4129b2dcc709c2ce7836d7413c7350d65448e33b3b2e559cf", + "python/sglang/srt/layers/moe/token_dispatcher/flashinfer_utils.py": "d26bf7c4fc811d42e30373e4495cd3163540aa8071dadc3534b675e627793389", + "python/sglang/srt/layers/moe/token_dispatcher/mooncake.py": "a5c940dd61de9621b4a8fd027140e6852fbc2df2dd965852a51dc190d0055818", + "python/sglang/srt/layers/moe/token_dispatcher/moriep.py": "de295b0ee79257484d0e5e0a8e7632b996b801d2d5d31c2fe5b4b402db3fa571", + "python/sglang/srt/layers/moe/token_dispatcher/nixl.py": "c6208523e0a66977b77130b288db80b55d31f71ffc98fa4759886eebb2810113", + "python/sglang/srt/layers/moe/token_dispatcher/pplx.py": "052053b7ba7b3d0070585d7eb81bf20cb6ccb1480859fe00d65e779998207e16", + "python/sglang/srt/layers/moe/token_dispatcher/standard.py": "9de02768e3877163c0955edf49be7de72aa3870ac351ad1e586b1679b0e72ebb", + "python/sglang/srt/layers/moe/topk.py": "8cc479ccfc835899db587194a3b193806135666f4743722da81cf3eb9a413300", + "python/sglang/srt/layers/moe/utils.py": "4ff2fa9835b36b4614c224adf75bcfed1694c13f0954befd1c90bde2793cd931", + "python/sglang/srt/layers/moe/waterfill.py": "dc09471a2ec1fd7ca98e84b06972edad8106443ecd0699e00d1f51191b0e00c5", + "python/sglang/srt/layers/n_gram_embedding.py": "ec3736e033c17bd99d7f03b7dc10017eb629fdb3e720aa5df939890caefb6785", + "python/sglang/srt/layers/parameter.py": "fc780d233617c99f6cdbaf60708cb771e27adb2e051ec7e9934b5431a55104f4", + "python/sglang/srt/layers/pooler.py": "788da634ca0ede66fbd8496242749abf07bf496146c6d178bfbb985297bff8a0", + "python/sglang/srt/layers/quantization/__init__.py": "cb87075ccfa96a8153951af8abef029f6c2e38cf285bb3e5277ef245fe1782ae", + "python/sglang/srt/layers/quantization/auto_round.py": "79e0664c76d37a6d006e242db9c296a96a06adbca5d49b5764d9abd07d66feb3", + "python/sglang/srt/layers/quantization/awq/__init__.py": "5592695d532179e7a5f208e50b8db7a39d1c0ccaee0367b784de8ee7b0c9531a", + "python/sglang/srt/layers/quantization/awq/awq.py": "028b39a024d3f6ce1ff2050c405a37e961b6ad646c0a67c7ec838d551a3b9d93", + "python/sglang/srt/layers/quantization/awq/schemes/__init__.py": "1fe1a2332de5f2f7b889d3473e52d78cbd32888d93c6522544670c17c0b97e03", + "python/sglang/srt/layers/quantization/awq/schemes/awq_cpu.py": "a285cad90cfa5df3b6f48f162ca4c3426efe02125ee9218e934b40a280d8c00d", + "python/sglang/srt/layers/quantization/awq/schemes/awq_linear.py": "e9b8b3ad69a7fee1841178deee05e554f979160aa0172cd31e205a0241ff1b6c", + "python/sglang/srt/layers/quantization/awq/schemes/awq_marlin.py": "1ef9c44e1c4b9fbc4e8f370d30afcdc36525be7a0964a7e31dd3b454cfe4765f", + "python/sglang/srt/layers/quantization/awq/schemes/awq_moe.py": "b6635d40313094835fa29687e6069ee44cfe74139cbc377b496a89e4a393fe25", + "python/sglang/srt/layers/quantization/awq/schemes/awq_scheme.py": "f5c37bf94c578b3193986eb9c7e23706f7fc84363c0c7e5aa2a9e109212fdb42", + "python/sglang/srt/layers/quantization/base_config.py": "b4d42c8f20588578b9b77ac536bd3296db71addb2692be904d62e3171b478ce0", + "python/sglang/srt/layers/quantization/base_scheme.py": "8443e8f810e130b95de96a7bced3b0c4922af5210d495b2052b524c7e3c1d55d", + "python/sglang/srt/layers/quantization/bitsandbytes.py": "68dbffc49bea248296fc3066879f15cf4214eb3f1f4f1c17f0d8fc168c3be08c", + "python/sglang/srt/layers/quantization/blockwise_int8.py": "3515d6e4efee78da5a420cd5355cd8ae9a68d2f5dbc8fffb6af281e99d2f1817", + "python/sglang/srt/layers/quantization/compressed_tensors/README.md": "f3495660ccc4166716e64b89eb09b4e703395d4cc24d04d2439961ffb35cdeba", + "python/sglang/srt/layers/quantization/compressed_tensors/compressed_tensors.py": "cd39a1f943dbf0f1fc5e69a260457265cbf5a2aaafd90ea4babe7eb1cf617a0a", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/__init__.py": "1fcef63d3af982e6f4cedd461c4ac6d9e59b8390582460abb5fa2ced3f0e269d", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_scheme.py": "40dec04b729a39d3362390d90fac29ca52ab99a90019ac56fd80497188f70476", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a4_mxint4_moe.py": "12624a8cfd8d03fd04ab4a7ecae05039c86bd93ef27f9838430625dfa94a3063", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a4_nvfp4.py": "f5a6efd61a9bb8b6e6d791891eaae440d60b04417f04ae67ed015f35df61b646", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a4_nvfp4_moe.py": "83d3eaa9e7843f809e8193d981d9dc90f81bab97a36cd30a8969f51fe2783177", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a8_fp8_moe.py": "adafb1332d0317a062ce6ad798cfef138756ce2bfed23e92696acd93e021dd27", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a8_int8_moe.py": "91537ccb48e8a3734111a44b1144c12e25c2939557b8b9dfafa9419d0d5dbd97", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a16_fp8.py": "7714b0dd7621a2c8a542cdafadaf573ddf8fa60e4b2feb826ec831b0edbe565e", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_fp8.py": "c853c513b29883c16dde974fe6b2d6e8ed6c4ab442509fd8a8f0f27c6cc15a85", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_fp8_moe.py": "bd823c839720f334ef90d65448e3ca14b16a5e9a21669dbe17ea1e144a8ff6e5", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_int8.py": "32ef6b9196ca6dc04a82deabcb849a1d029f09fd3137ab32fbe6691f6e23b40e", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_int8_moe.py": "0765e6abd35b6587794cab960d35311ed5a8718c3faa856db186c200988e5eb9", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_wNa16.py": "a78990db02e703847316fa71f2b8891d034c6fbb6fcaafb104f5e1002a7f396c", + "python/sglang/srt/layers/quantization/compressed_tensors/schemes/compressed_tensors_wNa16_moe.py": "74f1c0a36bef17ec0065002fda0824de5b1152e956e6f60bbc95134edff6e0a5", + "python/sglang/srt/layers/quantization/compressed_tensors/utils.py": "6f43153656248fd7fa3782fbc30ab052aa13e368ecdbd6fb00fac6c5e122df6d", + "python/sglang/srt/layers/quantization/dequantization.py": "e1bc76891ebfb33fe12fde7e0913884025c26bc42d18e0aa0044b4246e3b9ffd", + "python/sglang/srt/layers/quantization/fp4_kv_cache_quant_method.py": "0eb5c710559f3bf5ba493d992043213dacb651398edddcbc3b71db8570dbc038", + "python/sglang/srt/layers/quantization/fp4_utils.py": "2ff0495eb47d8afb282406d7e5306c9c20b5edcb65316435c7f39c3fe064bb32", + "python/sglang/srt/layers/quantization/fp8.py": "be081d39b0ebd397fb89208acadba7103111e95e3925569f466240667ea6de7f", + "python/sglang/srt/layers/quantization/fp8_utils.py": "cb310162f67b6cd33da8547c84b48cf356ea999d04c9ed5434ab52eaa2358619", + "python/sglang/srt/layers/quantization/gguf.py": "9cca184242c56a05a15b336f12ef5547efd8c0c97c66cd1630b6f2f0cbf64598", + "python/sglang/srt/layers/quantization/gptq/__init__.py": "30b60b9992a44a9f1a062197640df17e602070ae7b1be56925dfa7fa1e8deff4", + "python/sglang/srt/layers/quantization/gptq/gptq.py": "38f1912027a9774e7bc55e0ec66fc260ad4d9e2653afb000612163bdc7eaaab6", + "python/sglang/srt/layers/quantization/gptq/schemes/__init__.py": "1bc2ea55491a7c61c8e4429007318dfe16b0c9fbfa6606010c02b2f2311dd64b", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_cpu.py": "58bd9993efadc3a8afafd60154ea64aff78eefb42fda16976679d86527b9cca2", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_linear.py": "c8a1197e80de020adac83206fd4d388d1af228cc9407b15bc56191e8fbd02da9", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_marlin.py": "0648295334c1df8e33c008801616a0127333a0a9cd282c1dfa1d95716ac7ba07", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_moe.py": "135e004f7613a59aa0765cbe3d779c9bb0c459f3a199b868358759e020aaeb5d", + "python/sglang/srt/layers/quantization/gptq/schemes/gptq_scheme.py": "72dd1818001dea7c4a02d45778aa1078499a587a448e9afab057159b2957c482", + "python/sglang/srt/layers/quantization/humming.py": "7095d6edc186e6c1a306171f3814202fd2863aafaa77797820dd3645d84bbfc7", + "python/sglang/srt/layers/quantization/humming_utils.py": "d87e5ae9e2f29eacf4ab7e5d33327fcadfe3c9922de9b00982a00188982a726d", + "python/sglang/srt/layers/quantization/int8_utils.py": "d8340e7412dfd35c4b75b72a472367c5dea1508ddfa126080061e374f76db70f", + "python/sglang/srt/layers/quantization/kv_cache.py": "4b5862ab5530b563678f49a332213ea2b83437088a797ec6b925a8bf9b3273f2", + "python/sglang/srt/layers/quantization/kvfp4_tensor.py": "19ca3c7d21df3bbcd7b6c56f3c829a37d29814a9f80fbbd73987d08fc1842c5f", + "python/sglang/srt/layers/quantization/marlin_utils.py": "1f0529ca2b24e2af804eaaf51fe72d76484cf5c7ff91a768612c5c9ddfba0bf3", + "python/sglang/srt/layers/quantization/marlin_utils_fp4.py": "09460a6468148e4fbb9fcf82e907b378c457d21e308cc0e9bb3d8807f1679839", + "python/sglang/srt/layers/quantization/marlin_utils_fp8.py": "a05db436551dc12843c65de63bf6a4c40a3fe1fdc461422472ba0d555beadb8f", + "python/sglang/srt/layers/quantization/mlx.py": "1ce4c98f6b93abc250d8c43f3aff659a6146a1ff1265fa73f5b50a19ed40e490", + "python/sglang/srt/layers/quantization/modelopt_quant.py": "b05ed81bef0443781c79c7a6daf05204b8d6c50903cd84dae87ef3303c93d311", + "python/sglang/srt/layers/quantization/modelslim/README.md": "280e04b9a9ae69653d62c19b401f41b239d473297651a3785804f34035a5e14b", + "python/sglang/srt/layers/quantization/modelslim/modelslim.py": "dfbadf0987f8ac866b2c393eb4454227a8fe960c500b1821ad26ecc602ac802b", + "python/sglang/srt/layers/quantization/modelslim/schemes/__init__.py": "65e55f50c5856e370756f68ce933615bed12e01bd65ab24df2ac201c6d71b19e", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp4.py": "13915c338ef514fbf65e167c67e236839ed9b22b575a19148afa51e7eae4bf56", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp4_w4a8.py": "39caaf6e606acedbdbb8753dd2b49ab553b9ae9009d48b0cafbb0b99a4d7238e", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp8.py": "8ead67d94feec4e7f52341ba43e89ddbd5c2917a61b45402a9f4bcd70ab52328", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_mxfp8_moe.py": "2111aa441fb8831d02a594172153b3dca66506914b5cee43e9e12352fd4be75c", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_scheme.py": "3c35094a703eb80d8ba4e44a436405850f0c876195fe19e53628ec9fa4ff2d12", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a4_int4.py": "964162624e548aa408e869b50609ba40453b4432153ff887f2c3fd4609460eef", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a4_int4_moe.py": "ccda8039be906206ac224be6854e038b9ea2bbe6f9039facb9cdae0a8c6e80ec", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a8_int8_moe.py": "cea0df9233d6456f892edfaf25bc3b298c2623c85c4aa2d91a59ccbb63a03df4", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w4a8_mxfp4_moe.py": "f47ccc6324eb90742c3771874b653d41981e1f2a6f4ad5cd147c0d06dbca5f53", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w8a8_int8.py": "c31dd5ff7c011d3a2cfb0edde466243ca8c5646f91f3916eb4a40c9ab7b8aaac", + "python/sglang/srt/layers/quantization/modelslim/schemes/modelslim_w8a8_int8_moe.py": "257a44e9071827dd4b6e094b9cfe809bb332fc3a23044b6809c863cf09e30ef8", + "python/sglang/srt/layers/quantization/moe_wna16.py": "1ba087ae1d074d07a918dcbeaf84b2318d830f1c9b61a2a488fe2aa725bbf6d9", + "python/sglang/srt/layers/quantization/mxfp4.py": "822a8dbec3f93c69b3bb6e391f4bbc4f69482842fec2d6a97224752f446dcb43", + "python/sglang/srt/layers/quantization/mxfp4_flashinfer_cutlass_moe.py": "4c17a8ff539b18f5001b71ccbd8fc5486e1f4f0432f422c845d94f91d8d6ee18", + "python/sglang/srt/layers/quantization/mxfp4_flashinfer_trtllm_moe.py": "470a7fa83038e7084738a3eaa46adda01ff073b58fa16bc5c80e710935874ffa", + "python/sglang/srt/layers/quantization/mxfp4_humming_moe.py": "d91fd78e65b95e2dcef12e430144f8a28bd82d7a51530979049a923a4636ec0e", + "python/sglang/srt/layers/quantization/mxfp4_marlin_moe.py": "11c3247b6faf8f1659a4b9e9415e370aef3acd70e18fb77261a575f90633b546", + "python/sglang/srt/layers/quantization/mxfp4_tensor.py": "6c67825e520e8661591465a9fe521390844312019468ba5ac03bcccb57133a60", + "python/sglang/srt/layers/quantization/mxfp8_block_convert.py": "39205c32389e71ae684ef7fc44af364c73c0b664e955225f6e75055a3b29634f", + "python/sglang/srt/layers/quantization/npu_mxfp4.py": "dea73ffa5ff92b1006e54fa2e2c8a6b5124d63ecb7ab089c5c2050112d2779d9", + "python/sglang/srt/layers/quantization/npu_mxfp4_w4a4.py": "eec4fa7db564e0f084c85b740047bef1e5baaf63624a9b933ff969070b2aab22", + "python/sglang/srt/layers/quantization/nvfp4_online.py": "3e44022a73e05a2ade22a98b3f04b0bc9b23d9a376d82ede6e506385f1a4e12a", + "python/sglang/srt/layers/quantization/online_quantization.py": "410088a35d9364617f522ba8eaef5a6bd9a63446883ed6a70882715492e21e48", + "python/sglang/srt/layers/quantization/petit.py": "253972ff143348f81f4c045663755db93a392fca5ed615a2631f10d719bea795", + "python/sglang/srt/layers/quantization/petit_utils.py": "fa0cb8ccc86a368200d51d27efee42d1e7d5e788c7a2709480f0d45058c6b323", + "python/sglang/srt/layers/quantization/private_draft_head.py": "08e8232ca0a9bc93999bbd3f35f91e075a3bcf9da4e02889666060b5212ab2d1", + "python/sglang/srt/layers/quantization/quark/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/layers/quantization/quark/quark.py": "e445e6b87594ae3243c66c32147bcf966726430812e4ec77439f9a5168a2d6fd", + "python/sglang/srt/layers/quantization/quark/schemes/__init__.py": "8593d4ee997ffc3cf14ba6768f093011046e70ceb2144c627e013eac23c8d35c", + "python/sglang/srt/layers/quantization/quark/schemes/quark_scheme.py": "4655c2f81fb7169c07393f11bd080717ab1a34fe9da32e1d0392acc706a9e77e", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w4a4_mxfp4.py": "8f27127604b8dd68bd6734b2cace74544e14a2ad87d8ca51a712ebd49bb219e7", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w4a4_mxfp4_moe.py": "23231b1e107c36536daa6fb3b946502cd9ac3d61cc6ac36d17d170840f054158", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w4a8_mxfp4_moe.py": "e8d7bccd09308cec3bc4ae1b0a3fea3d05b4ff09424fffe5e534b6a5a4151c79", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w8a8_fp8.py": "0354e9556833d264ad1ce5fe7952dc51c36b6b87b3566ac07e73b3dec39159c9", + "python/sglang/srt/layers/quantization/quark/schemes/quark_w8a8_fp8_moe.py": "69f015cdb3501dbd0e96005a9b73aebf53ee8d2299eb9359533c3305c548f635", + "python/sglang/srt/layers/quantization/quark/utils.py": "38fd28f40a45c1cf982c8af772fccda30619720fbf9bb3614bc9d88fc2263a7f", + "python/sglang/srt/layers/quantization/quark/weights.py": "539cfe2dc4ead86a20f04ff4506214dd3987f000511a90633908e76e496e53e9", + "python/sglang/srt/layers/quantization/quark_int4fp8_moe.py": "12957b021fd9648b1102eac5aabb63cee34d23c16c8ed84fb979ad4918c7d5bf", + "python/sglang/srt/layers/quantization/rocm_mxfp4_utils.py": "678a585a5e84c4e5eadaa7d31e8ad6d7a8556c9f919381bc5abc67ff1f1ba071", + "python/sglang/srt/layers/quantization/unquant.py": "9103cc6d4e03e19134aa1ccc92a9692f825ea6833ed701e4a12175a328ee1cac", + "python/sglang/srt/layers/quantization/utils.py": "290d4567ca2a8207bb1a4edfe6bf4c5db1f2d3b1972dade03cbcd69959a7b31a", + "python/sglang/srt/layers/quantization/vision_mxfp8.py": "abd9b92edc32c923581723f3fda0348d04f478edd7169fcb2732645917b021eb", + "python/sglang/srt/layers/quantization/w4afp8.py": "d43150f16f07329efbeda64c704bbb731e6904e9dda559e865f5c44e757f191a", + "python/sglang/srt/layers/quantization/w8a8_fp8.py": "010290429b6d79e60a01fe6af62ce80a69fa6d5dc1c38165e448c04198b246c3", + "python/sglang/srt/layers/quantization/w8a8_int8.py": "f266f3cc9bd118cbd138336965afee76382c4e8728452ad226e96e41d6ab9d25", + "python/sglang/srt/layers/radix_attention.py": "9e51244758e1c0923fc03b08045039900fc8ca3138485a6d6c47926f0cd423d1", + "python/sglang/srt/layers/radix_linear_attention.py": "4af975b5e0ea2b17505920a43509372200fffc62eebed2e4b04346175710a179", + "python/sglang/srt/layers/rocm_linear_utils.py": "87ca6a653584c01bc264be38697ad93af3a52fdde023be1edb2c59043c8c04b0", + "python/sglang/srt/layers/rotary_embedding/__init__.py": "7329f3e0422fdae69421c4335cd49e9ccaa89b861d7f89123cd1f207aa511ed6", + "python/sglang/srt/layers/rotary_embedding/base.py": "dc4d4ddf9a0d2b90f2108e0b5888f27822a5c6adcd83d966d9f10f6581504028", + "python/sglang/srt/layers/rotary_embedding/factory.py": "33fcd7e8c52f626e800e8be8231166221a526a49ad99c2be73b2b1829993cd99", + "python/sglang/srt/layers/rotary_embedding/mrope.py": "6f952b96801f9cab29c170670a308d97eca832d39b69374f866e50318c904146", + "python/sglang/srt/layers/rotary_embedding/mrope_rope_index.py": "625502f5e3fe75baab237627242d3a112b23d6f0140b22fff25b34391bdbef10", + "python/sglang/srt/layers/rotary_embedding/rope_variant.py": "5711a778a965c7a84fcf6b2552c1c7a2efd6eb820ea3f48fd4597d01dd86f9ff", + "python/sglang/srt/layers/rotary_embedding/utils.py": "828a50285218e40c3429d2f4e75b1d051e3a89d831a7ab005e8c2609278aeddc", + "python/sglang/srt/layers/rotary_embedding/yarn.py": "105a507bd92816cf785e807c8582086d2c9201781d1b0329083695ccc9d09058", + "python/sglang/srt/layers/sampler.py": "d96221b3873f1ad9d83fa8d4457af70f3aacb2513112ed405172bf5aceccb064", + "python/sglang/srt/layers/sparse_pooler.py": "f6007c76e478f11f851ad03843b0f57c80d2bdb2a50fbd0ddfc4b72ef83bef7b", + "python/sglang/srt/layers/utils/__init__.py": "992a4f05906e3f06ea1c942941ea0f05c2de68f89c8b6ccc1e4bcefdfe0e8ea1", + "python/sglang/srt/layers/utils/common.py": "5d3b3d71926e31aa0495ca7453efaeefd4e59802619826b91276761074764f0b", + "python/sglang/srt/layers/utils/cp_utils.py": "ea620e6240bc17517517005c774685a2fbf9507138b93805058cbf532435b286", + "python/sglang/srt/layers/utils/multi_platform.py": "3ad3db2c47c7db560fa76ee642f6bf1fcb10086fe14f5ff8840b90ba692cc309", + "python/sglang/srt/layers/vocab_parallel_embedding.py": "c837114a550d4d5b337e3e14847eb0b72896c45a124b57f2364272e8cb4a0113", + "python/sglang/srt/layers/zero_copy_context.py": "85bcaba1ac6911cacf83051f5214f3e4dd1edb9d3c1f6809aa8f1e3ab3072468", + "python/sglang/srt/lora/backend/ascend_backend.py": "f09a695ec58dbd46d81b9224ff35769483d1df9c535dc40f694a969425002326", + "python/sglang/srt/lora/backend/base_backend.py": "ac0a8622709f58962ccc4c39aadc23008664ce7a9ff48176877405ebbd1c8327", + "python/sglang/srt/lora/backend/chunked_backend.py": "e78d5eebc9d8369627242986f10de4ae7e948f54f3f2ba323138f73ede198bef", + "python/sglang/srt/lora/backend/lmhead_mixing.py": "88fe73ff06b6e2736dd3eea92639f9af0614b6ccb3ad83f2a34c2f17ffc3d654", + "python/sglang/srt/lora/backend/lora_registry.py": "77111565e70ddb33ecb656bf3f787809d0a8a37d328f2f2ea49294d87a5b73cb", + "python/sglang/srt/lora/backend/torch_backend.py": "2f2be4da44af150a66e9164485e83f0b0b819ff5160729c03a4c04a409d89c7e", + "python/sglang/srt/lora/backend/triton_backend.py": "fcd1768977d780c7f0187234f514b5bc41a675aeb753876bc2c9709672eb150d", + "python/sglang/srt/lora/deepseek_mla_correction.py": "34e2a7579cecae5aa06c2f734ffaa6052e397d1b6f80a27aafd506ae90731390", + "python/sglang/srt/lora/eviction_policy.py": "ee3ab6705034aef0448c5612456685f3b039efbd07d307313fe78539d3f2d520", + "python/sglang/srt/lora/layers.py": "a1b456750dad3ffd06df417f949f14b196c6813a3991943073abe8ad307c6181", + "python/sglang/srt/lora/lora.py": "368221bec72a8c75e900e46b76fd80c6c15a1adf929b9e069684c159c89bacee", + "python/sglang/srt/lora/lora_config.py": "abd3e2644c0ba0739ac1ac5cd15b43764c1fd0a2106fe610e0c6c841059505c1", + "python/sglang/srt/lora/lora_drainer.py": "561d0531a91b9ede808ebb21fcd037248504d5398ce79b8767ba954cb024ef95", + "python/sglang/srt/lora/lora_manager.py": "bcac6adb2797a211e648f8bfa98e84d45b482da7178a4b72130e02eabcde668b", + "python/sglang/srt/lora/lora_moe_runner_marlin.py": "f901cdcb79a9d4fcfdeccc8ed38ea82b88fd3eb9459514c4fa89f4cf9c01e1c0", + "python/sglang/srt/lora/lora_moe_runners.py": "6fb25d71031e67e6f13f67a078c7994c4f72322c01964dfed01cd4ebe7f2aab2", + "python/sglang/srt/lora/lora_overlap_loader.py": "d567ebd9865f224a97eaaa70c4bb12f27017552a4d2fcced7d64e72c7966d12c", + "python/sglang/srt/lora/lora_registry.py": "14474232285bdf7b979a05f93a10dc3bc4d4fa76c4e76dd6ead76fb0f91be79a", + "python/sglang/srt/lora/marlin_lora_temp/__init__.py": "fa121557e964bf92c935e13df5e7cdcb6346b3c90410d217827a84d97d54d08d", + "python/sglang/srt/lora/marlin_lora_temp/activation.py": "86f69dcc43a73c61c686e5fc3639407f0f0ba51bbcb6c3dc02cd7680d04b838e", + "python/sglang/srt/lora/marlin_lora_temp/direct_decode.py": "30424b11fe03c66ae48fc41069aad58dc7910b6fd5009e125532d006f7b0539b", + "python/sglang/srt/lora/marlin_lora_temp/lora_layer.py": "6ec8f8152e9888ab02a2dfc98e3b951f1e54e1130a762d481a340f541d9ff9d7", + "python/sglang/srt/lora/marlin_lora_temp/moe_runner.py": "2477906ab0b07cea59b403e28353ed68fe7b02b93c20b3b1ddb546902faa9741", + "python/sglang/srt/lora/marlin_lora_temp/policy.py": "b3bfd0850023c3e7a41bba40ff665c0957ded62b539f59116101b7cc36eb35e2", + "python/sglang/srt/lora/marlin_lora_temp/sgl_backend.py": "cab7e5c17f46e227ebea5f3ff54e25a2ba639ff423cb7f937fc97e276eefc854", + "python/sglang/srt/lora/marlin_lora_temp/shared_outer.py": "93ac7082a4a3786460310ba4c8d580ae127a1a7b3e7d75c133f0fcad9f304cdf", + "python/sglang/srt/lora/mem_pool.py": "f955cdf2cb9fd8dc5c1f29f254bc69caf3517c0118c0935429379f04e7b9c733", + "python/sglang/srt/lora/torch_ops/__init__.py": "a54d8b9f1b57cf752893530d858cf5c0b36936b4e55aa3a7aa8bc97866889c48", + "python/sglang/srt/lora/torch_ops/graph_lora_ops.py": "390676cc38975095ba124d1932aa8c27dc2b4605e18c495c095ae852f4c96790", + "python/sglang/srt/lora/torch_ops/lora_ops.py": "fc6b43a3b721194441c6ad80561596a064a4c5863de5b62fc3e2fade48f866f1", + "python/sglang/srt/lora/trtllm_lora_temp/__init__.py": "cc7bbe1717c92d5b0c944b94e871bdd3348f6deb086b8116dcabc179279c7744", + "python/sglang/srt/lora/trtllm_lora_temp/attention.py": "e180238bc5512e41496a808fe7d9783231b4c1fffc9b556906b1c74821e16825", + "python/sglang/srt/lora/trtllm_lora_temp/deepseek_mla_correction.py": "020cbeb935ee95598a8953ef082f1e92f8fb506bb665f3559591311f812335df", + "python/sglang/srt/lora/trtllm_lora_temp/environ.py": "391391cb385d9472fd44314cbe09fd2e73eeab65dfb3b2bc8caf0fde8e71434b", + "python/sglang/srt/lora/trtllm_lora_temp/experimental_sgl_trtllm_moe.py": "57238892cd2a481bfa8f3cb74eb73d15bfdde0fc2ab80ed782ca6e0724979dc8", + "python/sglang/srt/lora/trtllm_lora_temp/inkling_dense.py": "d9b3b95ff24faa097ae5e108cd72388e291e989211f0c518ee3079631b09c28f", + "python/sglang/srt/lora/trtllm_lora_temp/lora_dispatch.py": "8a4b258d43eda0e978a018e1ae2f297d4702b4038749ac6486d167f1ee4a7636", + "python/sglang/srt/lora/trtllm_lora_temp/lora_layer.py": "ec8b9bb0f1d611051271c61080af3b1a6ffd4724f946c152537399c4eb1752b1", + "python/sglang/srt/lora/trtllm_lora_temp/merged_column.py": "e52017ebfba01df0fe37b01b1770438bb23548e450d663208673b01ae19971cb", + "python/sglang/srt/lora/trtllm_lora_temp/moe_overlap.py": "ecc556bd4aa274e2db97002e022c935c991f139892b9cebd377e9f11e171474d", + "python/sglang/srt/lora/trtllm_lora_temp/sgl_backend.py": "bf90ef8d9ce1a7382d2caf76d494b3810637800128e30ed7dbec0125957af20c", + "python/sglang/srt/lora/trtllm_lora_temp/sgl_fp8_moe.py": "fe39d65f7e4d56806762e9518d598e9095f3657249718349b8c058df6dc60948", + "python/sglang/srt/lora/trtllm_lora_temp/shared_add_overlap.py": "c2df0c884816c05a996487742005073d7e30dbca4689bbbf1adf0ed60b4cc7ac", + "python/sglang/srt/lora/trtllm_lora_temp/specialized_expand.py": "6246ad33cbd08b529b6299c05cac20b1e3939daa0d085228661296048b9e7cf6", + "python/sglang/srt/lora/utils.py": "6c2b94b92a45ebefcd2e3e4b5c8f9d2a7d5496ef8b98832a2d10667f61c505b1", + "python/sglang/srt/managers/async_dynamic_batch_tokenizer.py": "a52ed01045e146dbddcd915f3ea1c0d15775207bebf26777df84bbaabb709ff6", + "python/sglang/srt/managers/cache_controller.py": "3f323c0b08acb8b1de6f3ff8c08f1ed34d508afd186ae61d370f4e1087d89974", + "python/sglang/srt/managers/communicator.py": "8228691d693cc2877b23fc777866a6779c1ed8511dff0c64ad002d2c602e0552", + "python/sglang/srt/managers/configure_logging.py": "acfd1542b779fcfdc207ea5f94037f9275e5ecfcd7ca77e17b7a63d9d4dbbdfa", + "python/sglang/srt/managers/data_parallel_controller.py": "ba6bbee2be27a5cec6d1625a4ae8d131dc5bb19dd6c32d985e378116d085173e", + "python/sglang/srt/managers/detokenizer_manager.py": "d90f88443bbde167c516dd4b55cd978bb75dfda1766d7e83c4f16a3094d9954d", + "python/sglang/srt/managers/disagg_service.py": "b1b2a8cd4d9bd1c891fbc403c499859277d85f641508a6f75919d8997e88b67d", + "python/sglang/srt/managers/embed_types.py": "a82f4dec31163faf0982b1346290698b1a19aa648f7b6381d3b129d73046de75", + "python/sglang/srt/managers/hisparse_coordinator.py": "f40ff83c78647cee92d674df808681dd805e29aca0711e2a944231d10cddc8c8", + "python/sglang/srt/managers/io_struct.py": "cc022f58fe2468fb6231c1e65a41106cbc0d73fe1bd784d6f57df94a412564a9", + "python/sglang/srt/managers/load_snapshot.py": "cf691698fef36941b65ca73f79684e95466fb8da528115b381d0f310d3673c98", + "python/sglang/srt/managers/min_free_slots_delayer.py": "bb864fc17446d3ccedc208250ac0171a235a39870bc151139c411049772fbeef", + "python/sglang/srt/managers/mm_schedule.py": "0c25cae8193e85088be5e1c012268689d868d87a49c5d81fee624c5e8f7dcfe7", + "python/sglang/srt/managers/mm_utils.py": "a51e0de5ec1abe5b2d094b43df8e2cf962372d50ffeb775d915b3c385b45a871", + "python/sglang/srt/managers/multi_tokenizer_mixin.py": "d5ae16421e4be95b51ad7bda44604ad4759e1bd7fda716d52a5102f29c356e58", + "python/sglang/srt/managers/multimodal_processor.py": "d295ce69c2fa2c5eb6940a28609ed913fef980f64de6af30635292c250875f0f", + "python/sglang/srt/managers/overlap_utils.py": "7762a4e463a8052fdac22e76ba904cedb35fb2deabda687849724a354bc891aa", + "python/sglang/srt/managers/prefill_delayer.py": "ca1bb87ae714a3329776965e7a47b53f2bfe1d411beac627e2af50721c823d04", + "python/sglang/srt/managers/rust_server.py": "ee6ce020ce33911c5445e21c8daf074e864d2a04530ca3d037bcabd5da9b13f8", + "python/sglang/srt/managers/schedule_batch.py": "56b475c078d2aed7fc626dd7f41559b169498da285bf729d94b76e8abda13c42", + "python/sglang/srt/managers/schedule_policy.py": "7fa154986e574cabdbc341875401a59a7a388f94c548f11bf3d2bd7badc131d4", + "python/sglang/srt/managers/scheduler.py": "8bc11f8bd2ddef96bf32adc1fe5b52c3929e23538cde1047914eb336f3994595", + "python/sglang/srt/managers/scheduler_components/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/managers/scheduler_components/batch_result_processor.py": "22bd0ccfb1acfa4374a977ac0f104cee55652e6c5449d7c272d6775718828f7c", + "python/sglang/srt/managers/scheduler_components/dp_attn.py": "30c6112257c01bb4499cb3112789ada3cb9256e99c14881016be024d8876fc9e", + "python/sglang/srt/managers/scheduler_components/flush_wrapper.py": "5adbcdccd5fd6de5760735126fb83f9f578ea6d2d77c14dad374213ae0f2a925", + "python/sglang/srt/managers/scheduler_components/idle_sleeper.py": "031821b3f74435835dd9d40007eff027eff912375eeefbc7724210150f505082", + "python/sglang/srt/managers/scheduler_components/invariant_checker.py": "2d3ad1f4bb760747f4a09a674015c7f8fbad4623150add58612660034e545d66", + "python/sglang/srt/managers/scheduler_components/ipc_channels.py": "ec73fc4546bb75991daf1abf5be1b4f0fc23770eebcdb704ea0973e51285699e", + "python/sglang/srt/managers/scheduler_components/kv_events_publisher.py": "600d51ae91978322fbc8d3cf8b8f136b7f6f9eb803819e90149ad69698dbcae7", + "python/sglang/srt/managers/scheduler_components/load_inquirer.py": "2d27be46e1cf70ed4164dd28ccc0b3a2be8967780a12a4e83b36f0a288ab2c1c", + "python/sglang/srt/managers/scheduler_components/logprob_result_processor.py": "e155923884c924cc6cc98fe9ee7800f093f0d8b755be27599902992cdab1725f", + "python/sglang/srt/managers/scheduler_components/memory_usage.py": "82844af91ffed25cf1468ce3ee9afa4bf7d170432d6e7a3242971bb886848e40", + "python/sglang/srt/managers/scheduler_components/metrics_reporter.py": "88ca2f1f7ed43b9f226393643a66c39e6146eea8ef5052ca617fde32cfd465a3", + "python/sglang/srt/managers/scheduler_components/new_token_ratio_tracker.py": "865da371d324f57117f0aaa45cb53f15ffa22a32a458c3ff1eeacdd95c3f16cd", + "python/sglang/srt/managers/scheduler_components/output_sender.py": "e1c4e17a45a69157a73396f2d46099cef2a48ec8a2c86ee652f460e58eef8611", + "python/sglang/srt/managers/scheduler_components/output_streamer.py": "4f069fbba82a77360fec29330edf5f6cf3740960984c5e1d01ef4e385c90ecaa", + "python/sglang/srt/managers/scheduler_components/pool_stats_observer.py": "a9cd71a9cd38c4178657c5ddd433cde55f4abde918bb512f2b61441f9b88089f", + "python/sglang/srt/managers/scheduler_components/profiler_manager.py": "b1fdbdf4f00caa3d2ec810f0e4245ef44dc1327ad3f9833a1aa2ad726a4443fa", + "python/sglang/srt/managers/scheduler_components/recv_skipper.py": "3468d334af6a624769a8888d36b2b477270d5faae9d8b3a28af38e4cf31bfef2", + "python/sglang/srt/managers/scheduler_components/request_receiver.py": "899ac13dc79cf41a7582357298a40a03fa4f7d931955ddbc89705301916b4d5e", + "python/sglang/srt/managers/scheduler_components/weight_updater.py": "70944138cb88d88feddf9f2474684bc8cf7739484efef367336efc0e2ed9411e", + "python/sglang/srt/managers/scheduler_input_blocker.py": "edfe07948d75b3871bae173997914397878aca66aba0b42ffb8e26eb7e97102d", + "python/sglang/srt/managers/scheduler_pp_mixin.py": "89027f3bf1e37a485b8f2c9a96b62b1ed87879efaced1e41071179ba76b025a5", + "python/sglang/srt/managers/tokenizer_control_mixin.py": "e7f1ccacd6c243e1b5630f8f04b2fa444a6cc5635a7e8c2036ab0663ecb23091", + "python/sglang/srt/managers/tokenizer_manager.py": "591d5bf0ae4ab5009b8dfa37bd4d496f62b40cf13ee19bf7c867804b8a263bc8", + "python/sglang/srt/managers/tokenizer_manager_score_mixin.py": "1afd43f14f2521bc03c7d7e5f6fb839c32a250314922245d2eb8100a11022419", + "python/sglang/srt/managers/tp_worker.py": "c39b0b3363a57612caf73c600c07f9e67e56ae3ad939048eba7e856002047e59", + "python/sglang/srt/managers/utils.py": "23967b5942bc893d843f39028bb6d091c678125bc4378fa09499804b26f3c7ea", + "python/sglang/srt/mem_cache/allocation.py": "5012c58e1ca32dd28c97917195c87d80927eed55d60eeccc67f436f822b42c24", + "python/sglang/srt/mem_cache/allocation_sizing.py": "093f09c8ae88dc4008589195b97ca6a200e22b470839447800adde6ec8ff5400", + "python/sglang/srt/mem_cache/allocator/__init__.py": "c89351f05411121d0aadcb565ee848d78dd91726a61533f58b43cb7eeae2bddb", + "python/sglang/srt/mem_cache/allocator/base.py": "8159576fea298f977deb1535da9f42b4386e9ece2d663a2258aa97210d5f79ce", + "python/sglang/srt/mem_cache/allocator/hisparse.py": "ec75a199e4da40fc03bfb59f28bc0a1c5bd41b036e2e1cb54b81b1a0f9944fc0", + "python/sglang/srt/mem_cache/allocator/mamba.py": "b3d4561b7f96aa55f615c491b3d5a8c8e72e156fd7e6cf639ee7f87cfd80674c", + "python/sglang/srt/mem_cache/allocator/paged.py": "e58478ecb416a3a3bad1faa07863fe084f17bd3b1feb0f59a26b72b500a5a429", + "python/sglang/srt/mem_cache/allocator/swa.py": "1791c173ec8bf42b7a2ba9d5cdd1dbdbfd0c01b7de98e3206af9a178a3cf928d", + "python/sglang/srt/mem_cache/allocator/token.py": "07372fc82e58c58ff9fa749aa6573b0b1c9d7eb59d5e8c779c3b198a4da4370e", + "python/sglang/srt/mem_cache/base_prefix_cache.py": "d61f7ec0793661731f6150cdbbbb861428740e5697675beb7bcc67766df68791", + "python/sglang/srt/mem_cache/base_swa_memory_pool.py": "d37f2318c1d1fff9a0d6b7c17439ffd7733fb5a697c93dbc2fa31ec40803e280", + "python/sglang/srt/mem_cache/cache_init_params.py": "68ee503d8d1a908c338e0bb7f0bbdf67fd239ccf7be9fcfb6c94fdcf1278fbc2", + "python/sglang/srt/mem_cache/chunk_cache.py": "4819830a78b66d94427e235d20883561cb2a965764407184452eeef56f38b549", + "python/sglang/srt/mem_cache/common.py": "8e822206137dd6bfdf1c67ef02b93505c5a024778aa284e9a1709721c958e276", + "python/sglang/srt/mem_cache/cpp_radix_tree/.clang-format": "dc2a6c4be9a0951daedae7d3ba0955f2062b4f05ae165d812d1e8d3706ef6c15", + "python/sglang/srt/mem_cache/cpp_radix_tree/common.h": "cf196b6f42e2930229fb757f0cfe9a22680424b878bfdbb06857a76e0adec4d4", + "python/sglang/srt/mem_cache/cpp_radix_tree/radix_tree.py": "b50669cfe1fa1f134041ef6662ab7a697f267c3672bbf7db25370234af8db353", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2.cpp": "4606cc83205e6fa0a00f53b4c241caade013d993144da5b263ae2ad050819704", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2.h": "443969b06253f7fa1e33d70b51ff4595a1f81f7d1a510726bf2e051c1edade02", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_binding.cpp": "b3c07ed96bbde446ee58c4688bb1c19053f9855e1ae0e15d2ccfe1088ac74204", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_debug.cpp": "922cd38f2a90d697f9cdba70a90fe7fc9dc300cc7ee52b14eb3cee8cb6024c95", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_impl.h": "9dd2617f47568d4f57d96faeb8eb5031c9a148e5720c648cfe21350330a5dec2", + "python/sglang/srt/mem_cache/cpp_radix_tree/tree_v2_node.h": "eed6c36b2201eaa0e89339161a9227446e51911bf2328a067ac629d7ef3a8ffc", + "python/sglang/srt/mem_cache/cpp_utils/hash_binding.cpp": "f4ab69e2e99b2b11dd19588bed5011ce737bf9fdf639669925d4119e0aa24b2a", + "python/sglang/srt/mem_cache/cpp_utils/native_hash.py": "8ae66bf8147fd0daa518a1519028a5ce3504cdf5616341cb348a71b873251924", + "python/sglang/srt/mem_cache/deepseek_v4_compress_state.py": "9f993de84546782d529403974665e3882defed42bb0b0459f833403cbe816ce3", + "python/sglang/srt/mem_cache/deepseek_v4_memory_pool.py": "bf3a94483cf099111460611cdb83addbe740b970613177df4c803a50b3468451", + "python/sglang/srt/mem_cache/dsa_cache_layer_split.py": "432d2fd880163b5c8633dd4e5f6527c658b045890c9a6e90d40909bfc153102e", + "python/sglang/srt/mem_cache/embedding_cache_controller.py": "0fe05d298032b7dd375e95a3daf0241a4333739c72002f4de680a30d0ae78b9d", + "python/sglang/srt/mem_cache/embedding_store.py": "bc359008e336099772b44961e0dd34b5a3169d5c0467679aa09112c53bd3eb8c", + "python/sglang/srt/mem_cache/events.py": "02a73642033edf74ae881c32139d8afe7c38b650424661ed8868c0c8f6c42fcb", + "python/sglang/srt/mem_cache/evict_policy.py": "8e839aa19244b870db52577ed06c7e1b4c02302813d33cca1f2d49ff190b929f", + "python/sglang/srt/mem_cache/flush_cache.py": "19873198d5e1e21b0ca457cd3ae093a4a8a55bb82e6704ed020feeb1578cdc9d", + "python/sglang/srt/mem_cache/hicache_storage.py": "de92d6c7228f3c93d889e1c054f867235055f74663b2808c5456e53ff040be86", + "python/sglang/srt/mem_cache/hiradix_cache.py": "6defcfe6b90f8205078aa08a605ea560d708d81d5121445205408d39cbdc846a", + "python/sglang/srt/mem_cache/hisparse_memory_pool.py": "65b49da21e56f544d4fe8abcf1fe5a91d03f68ef6e5c1a06f3ab45817c362e65", + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py": "bc06826aeae69fa9702469d6a8606fba6efafe66433e402f9a8fd488dfdb1096", + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py": "a348509b43c64ee979d838dfd7c6ee3350b6617edb608ccb0f593f7af86e7140", + "python/sglang/srt/mem_cache/index_key_cache.py": "740533e40dfa061c2b3540d403caeb079ff5c1b135ff4df23b66eeac05f00f2f", + "python/sglang/srt/mem_cache/kv_cache_builder.py": "7eae73259a8c52559b1b7d95ea9600fa70155da6e3a1fa8c2ba094d02bf8c058", + "python/sglang/srt/mem_cache/kv_cache_configurator.py": "06ea5d33aead6b058d64665e0282ee7f5d89ccbb1c221b229b2610f570121099", + "python/sglang/srt/mem_cache/kv_cache_dtype.py": "c104b125ff723c584bfdcd368a2129a9980e10381de0470c22522d4a0ae55f1c", + "python/sglang/srt/mem_cache/kv_vmm_backing.py": "c34c50a50260abebad49ab1b9832b2ece22a5a56dc66f8083c2220306cf11cc3", + "python/sglang/srt/mem_cache/l2_transfer.py": "d78f93396f2798dac12dc42e977592f24326c3445f253c671fa64e84137193f0", + "python/sglang/srt/mem_cache/layout/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/mem_cache/layout/page_major.py": "0ac5254ffb984db066285ce9508091e9f24dd2619bed631d7b0e7f3841959b84", + "python/sglang/srt/mem_cache/mamba_checkpoint_pool.py": "00be6d6ca4bc058ce743f08e83037b4b4a6aa6f62795c95bd70c332d8117d318", + "python/sglang/srt/mem_cache/mamba_radix_cache.py": "c90dd4f835b273673b9e2289624023469719041b6499b779818f3e5f4da455cb", + "python/sglang/srt/mem_cache/mamba_slot_fused.py": "291c34436e1d82b97f82a8ec8afe8b7999692c9be677f30b1a98f306e8970522", + "python/sglang/srt/mem_cache/memory_pool.py": "ebcb705f37b6f78cfb730ea43c767538a4f63b719a14336f5bbac71d20ec3f7c", + "python/sglang/srt/mem_cache/memory_pool_host.py": "fd2b196b9bf39ae93f96afce6748ae2571c26308dbc150da452dd055f3b03125", + "python/sglang/srt/mem_cache/multi_ended_allocator.py": "30415f31c66043aefe60f92278f8f1fa16ef2b1980fc45baee70766a536b5d1c", + "python/sglang/srt/mem_cache/multimodal_cache.py": "f1415edeb4554534de2648e2ee1ffacde06236a7b0028f29f94b9b94a954b739", + "python/sglang/srt/mem_cache/ple_state_pool.py": "a99b71c6e3941c060e4126c212fa9a941545d4d6614af7131681dc9b696515e2", + "python/sglang/srt/mem_cache/pool_host/__init__.py": "991f35e8e919d7b9c7a9fbf9c418a1087102bcb22dabb764aaf95ca4af071b86", + "python/sglang/srt/mem_cache/pool_host/base.py": "3a04fb9805312de59422e262c966713116f866ca836ef8de440829930a45a809", + "python/sglang/srt/mem_cache/pool_host/common.py": "b98f0399385093044562ceece5e04868e4ee5867aa36b89f36d0c2177cda6e15", + "python/sglang/srt/mem_cache/pool_host/hisparse.py": "0f94fd23d74613556ac5dbca59d8399fd3c5f6cbfc8758775bedb5fb5b8f9e01", + "python/sglang/srt/mem_cache/pool_host/mha.py": "1ce14fb16a447e63575bae99aa2845604c5bd2a403e518bc448a73044fde2f9a", + "python/sglang/srt/mem_cache/pool_host/mla.py": "977fe584060f0ef377949fd9bf7e060241f4aa38758299d4a401db8f1c9bf9db", + "python/sglang/srt/mem_cache/pure_swa_radix_cache.py": "ad4d75c308d0767ade0c6113081772a5f4f9ea49ab0e675ed899bcbed7ffe53a", + "python/sglang/srt/mem_cache/qsa_kv_pool.py": "85e7687daee0af9506b4c0e8840ec5b4c870be6f6930a3c210cbd31bf1f84412", + "python/sglang/srt/mem_cache/radix_cache.py": "c3ddcce2da58c455ea949d3214d77a2afb841de96ae7e5bf77a2730ec9d6299f", + "python/sglang/srt/mem_cache/radix_cache_cpp.py": "28bb1289e1ec45f4974638eec78f6fe17b963ae1a7ff6316c175b7d679e38e12", + "python/sglang/srt/mem_cache/registry.py": "0e09618b4e88fddca91540ea8813eaa35507ccded56f4c287b5b4b26af5bc00e", + "python/sglang/srt/mem_cache/sparsity/__init__.py": "cb5b7692800a739f4c3aa99cc4215b7aa437337bae2d7ef63ab9c703253e751b", + "python/sglang/srt/mem_cache/sparsity/algorithms/__init__.py": "f2d8e139958b5165f52acce6bd3a3bb04352b0ca610d3008fdfa6d9f26857977", + "python/sglang/srt/mem_cache/sparsity/algorithms/base_algorithm.py": "a805e5e0a2cc0e54daa530a52f98dffe949a3acf08b413911865c342ae9aaf4b", + "python/sglang/srt/mem_cache/sparsity/algorithms/deepseek_dsa.py": "5b70e38087383704ce8ca09800ffb37d8a74d88e55470750a9a1c05f07d3803b", + "python/sglang/srt/mem_cache/sparsity/algorithms/quest_algorithm.py": "a3a57a8621e513f982b56c45b5bf294bd9943e72fb5c768354fcddf97f673780", + "python/sglang/srt/mem_cache/sparsity/backend/__init__.py": "26273f1622afcdf6ba6ca5d8b329d3d58e3ded32c01c4635938107d4dff1305f", + "python/sglang/srt/mem_cache/sparsity/backend/backend_adaptor.py": "507274b969655308c2b8700417a787616c4a8619f0a45a4effcafa6a2224e333", + "python/sglang/srt/mem_cache/sparsity/core/__init__.py": "374d1108ac4dc013d0ceb0ff8c72f0fd6e826dd88aaa94576317dfc15b89ac9e", + "python/sglang/srt/mem_cache/sparsity/core/sparse_coordinator.py": "84559fc9615580a1245494cc3bd889abd4f960ea2904ca5dbe4a8aa336499311", + "python/sglang/srt/mem_cache/sparsity/factory.py": "174760bd209f84a68ad4c6ace33faeda3f4ff1cc307b5fa8ac07c9cace4a1a64", + "python/sglang/srt/mem_cache/storage/__init__.py": "1c3cc715455e38796bcbb1e57cbe6d45de47500d3637de29f2ecc0fd56bc9e53", + "python/sglang/srt/mem_cache/storage/aibrix_kvcache/README.md": "419e5f2f02c3a0bb502247b4fe076a829e1232b32c2086cf9157b3fb366d3391", + "python/sglang/srt/mem_cache/storage/aibrix_kvcache/aibrix_kvcache_storage.py": "c9a9f64c8d81de9e6d35bf39db03579a560710454eea26d627466a4502562379", + "python/sglang/srt/mem_cache/storage/aibrix_kvcache/unit_test.py": "84c269f9c31d2ae308634046dace048fa0d8d74abb7081df98015573adae4f0b", + "python/sglang/srt/mem_cache/storage/backend_factory.py": "d0a64077ce4e1b27be7c831543efe9622a102da0ffc0850dd2c4c786c7774c4b", + "python/sglang/srt/mem_cache/storage/eic/README.md": "28b16c973377a35508835bbd728090fd44c481ea3f2c5d025fca2b0c4be38bf7", + "python/sglang/srt/mem_cache/storage/eic/eic_storage.py": "175a6fa0ad59dffe36717b8e3217fe20937a7aa179251aa35f67408d69227afd", + "python/sglang/srt/mem_cache/storage/eic/test_unit.py": "3df34fa4beb6e2ddb7b72560b664b9175a468ae58332b0b7f590fa65b90df36f", + "python/sglang/srt/mem_cache/storage/file/__init__.py": "211b5bf704f84f381c9d81b929507e05c9c4eb9955e1ae3f00a129e8a78ccc7d", + "python/sglang/srt/mem_cache/storage/file/lru_file_evictor.py": "9e590e144c1169d463102e9aa147432cf5fa9108f1f8936de1184903c79a1330", + "python/sglang/srt/mem_cache/storage/flexkv/README.md": "c16b85753ea2f6f6027fa027868a74c16ea311674df38837008e16c01f50e7bf", + "python/sglang/srt/mem_cache/storage/flexkv/__init__.py": "77b4c12ed0352f565f0a3caff7d82caa572975ffa9785626028743442ceae67b", + "python/sglang/srt/mem_cache/storage/flexkv/example_config_mp.yaml": "83d9734fe13ceeb9773850f679ba54f49ca36a313fe5c6a95691a6bda7fd9aae", + "python/sglang/srt/mem_cache/storage/flexkv/flexkv_comm.py": "a565bb687c22388a9d14dd13e3e93112d3e4a003825ad7358e296ec61320c89f", + "python/sglang/srt/mem_cache/storage/flexkv/flexkv_connector.py": "635e481bfcaef29a6037d482446bf425e327b33e4fd13804f1b400e48dc4e3a3", + "python/sglang/srt/mem_cache/storage/flexkv/flexkv_radix_cache.py": "0fc8bbd7859005f454b3ea73b8e41ddc53b621c1bde4fdd62adc910df8ff2314", + "python/sglang/srt/mem_cache/storage/flexkv/verify_outputs.py": "3d20a6b8847e85e4e2fa9a778a657213549900d24fa6b810b9ec65833f97c3b6", + "python/sglang/srt/mem_cache/storage/hf3fs/docs/README.md": "b9f28a67b99d882233597d65c7ba8e42784b2e87b5f7f168ea98187109fca62a", + "python/sglang/srt/mem_cache/storage/hf3fs/docs/deploy_sglang_3fs_multinode.md": "e9aab6a832ef9f4e47651a00dc1213b128d29189d5107e5f456db1fe508399cd", + "python/sglang/srt/mem_cache/storage/hf3fs/docs/setup_usrbio_client.md": "8506110b4ea9adeaff24e4f1f8e45b74c9d0404a5b0aa786f420085088fd1b2e", + "python/sglang/srt/mem_cache/storage/hf3fs/hf3fs_client.py": "df11b4755e499a76c827c901d7f964f2301eaac84e714eed5c44b6ee57726fc2", + "python/sglang/srt/mem_cache/storage/hf3fs/hf3fs_usrbio_client.py": "dcdc16ae6f9b1c3307afcbc6af17cbfd1a0cebe1e538b03ebfcf4755fc53c2b5", + "python/sglang/srt/mem_cache/storage/hf3fs/hf3fs_utils.cpp": "74360fb7198be8e161132bff1ae4e0ce44c3a418dc0f410af24a619e7ede6867", + "python/sglang/srt/mem_cache/storage/hf3fs/mini_3fs_metadata_server.py": "a7e00b06d02ef5ca801d064ac8d7547961cef81b49caa8dcccf6ae835eff678b", + "python/sglang/srt/mem_cache/storage/hf3fs/storage_hf3fs.py": "ed33f0ce269ababa2496498c22ddeccde48faebbd4f9c036bd09f510e5a03cdd", + "python/sglang/srt/mem_cache/storage/hf3fs/test_hf3fs_utils.py": "2fea7f6cadea4745d900917267722a4d9498ef7116975b45cee736b03ab7a4a6", + "python/sglang/srt/mem_cache/storage/lmcache/README.md": "8214e609b24428cc93e3a46ee8dd4e3af082eb6d188747f33b77a92dff43f123", + "python/sglang/srt/mem_cache/storage/lmcache/example_config_ip.yaml": "48de9bd2cf06ac6105305551b611e4ae9a2f36e21355866eaad98faac697e1c5", + "python/sglang/srt/mem_cache/storage/lmcache/example_config_mp.yaml": "882686e3a48242cea38a620cd0214f564efbf7d637312bf8a82ccbb652820ef1", + "python/sglang/srt/mem_cache/storage/lmcache/lmc_radix_cache.py": "e7a0c04e1e4deebff441569c9cd96f910620e82def99391266404e09813cb483", + "python/sglang/srt/mem_cache/storage/lmcache/unit_test.py": "e563e3777e705379b1856c36140f1b3ed2cee1b5714325b8bc9ab69b6b8479ea", + "python/sglang/srt/mem_cache/storage/mmap/__init__.py": "3d355914915afc1ebb316292a60ad0f55281c88e103505aa1d4d75e3be21073f", + "python/sglang/srt/mem_cache/storage/mmap/mmap_allocator.py": "68b043b8bf868846dd0990ff5cb98079a54c2d01283bd8152edff196c9954d69", + "python/sglang/srt/mem_cache/storage/mooncake_store/README.md": "e6e7f1adf5a56e9ca871bc6e750efcae5be4b540d66c5b70953e19cf625004ec", + "python/sglang/srt/mem_cache/storage/mooncake_store/mooncake_embedding_store.py": "7ec3ef1b2e98e2ea4b85e117ad8e8c705103fe2cea2b52096884ee219702dd30", + "python/sglang/srt/mem_cache/storage/mooncake_store/mooncake_store.py": "d8232dc281bdc849df1dee9dd77b8ff4582818b3d46b0106c79a6cbc3729d7e5", + "python/sglang/srt/mem_cache/storage/mooncake_store/test_mooncake_store.py": "16af85082ba8c65be637403fa1f94bbe2eaf9b9f9698eccd1180c407dec5ffbe", + "python/sglang/srt/mem_cache/storage/nixl/README.md": "56e0cec6167d1c6bd53f6b197a3a2417ac8bb48afba687bf79c0c12cddbdda75", + "python/sglang/srt/mem_cache/storage/nixl/hicache_nixl.py": "8d9109990e4bbb2fd0ad60dc676c4369fabbd946ab84cd32c6a093af5125797f", + "python/sglang/srt/mem_cache/storage/nixl/nixl.config.toml.sample": "65efaf63789842d6412aa78d508232ad7a62a14face2c7049da86d523b87beea", + "python/sglang/srt/mem_cache/storage/nixl/nixl_cleaner.py": "16bbefafaefa793d201d71656ed415fded5c2e465476e011cce7058041bafedf", + "python/sglang/srt/mem_cache/storage/nixl/nixl_registry.py": "aee7d343b1e91d8f13d769b0de1ea66fcb0536f0400415e60407898fc7550dfc", + "python/sglang/srt/mem_cache/storage/nixl/nixl_routing.py": "5c40bfcc8814cea19137574be69ce31a6554c4ca795ab4ea49156c8e55375c7a", + "python/sglang/srt/mem_cache/storage/nixl/nixl_utils.py": "6ea9a6f58601709d93a65a71c52c204b3d25e28198d0d37feb7a67c80ba67c57", + "python/sglang/srt/mem_cache/storage/shm/__init__.py": "b84dde8fa936064b55e4ff467296e0c6fba9ca8a0574e60320f1d7b0d16b20d1", + "python/sglang/srt/mem_cache/storage/shm/hicache_shm.py": "32f9658b5027b0d282950440a0d2da59ac78f3d995edf46b191142581e58474f", + "python/sglang/srt/mem_cache/storage/simm/README.md": "eb549638b8a964a378c36a8de6850bedd49afe7361b409e7c6b7d1a8aaf3ff08", + "python/sglang/srt/mem_cache/storage/simm/hicache_simm.py": "e0fc56ebbc248ee4ee8c2c3b02b8679e06c34b84b72ae3442aa6ec8ad996c825", + "python/sglang/srt/mem_cache/storage/simm/test_simm.py": "4dd5ef674785cecb33e0a7de504259b9db496d59de2923d491b1dbee5db4f297", + "python/sglang/srt/mem_cache/storage/umbp/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/mem_cache/storage/umbp/umbp_host_allocator.py": "f4b31ed2d77a6679494aa95b112844c7934ea7531490ccd552dff6edb911a987", + "python/sglang/srt/mem_cache/storage/umbp/umbp_store.py": "a05076928164521278786f5ff5d83b49926dcdd1c36d186548a29908d5f8027c", + "python/sglang/srt/mem_cache/swa_memory_pool.py": "be524192527287453eb09ffce1d2b1e457a454bc18a6029e4c80dc3174a531a9", + "python/sglang/srt/mem_cache/swa_radix_cache.py": "ce38277491908c28457a39a53a90485e3ca8c56c6d579f0ff9b598d54c38b76b", + "python/sglang/srt/mem_cache/unified_cache/__init__.py": "dfe2244f37bf6c26b2b8473d6c0317fa4996ec16a1e98afb8dabd1ed93c90efc", + "python/sglang/srt/mem_cache/unified_cache/cache_action.py": "6e1ff116fbcbc77954e12bfbb8d525e9d60d26aa2b95d54f19920c3f15f9ed52", + "python/sglang/srt/mem_cache/unified_cache/component_type.py": "7d369ff5f0c9b84c0f0f73910357e7929b4bda6fc1287f987522a83f8c893376", + "python/sglang/srt/mem_cache/unified_cache/components/README.md": "28ae5e66cc56368593cad72793b70ab61e5798d586300e9e1922b5be2e9ca586", + "python/sglang/srt/mem_cache/unified_cache/components/__init__.py": "bde842f9c2d5054e000281d301ecfa1e934bef65628a77fdb6c20172c0f0995c", + "python/sglang/srt/mem_cache/unified_cache/components/full_component.py": "edf7ff730f81db8d2d322d54329f74953175cba5745ed55ab6e5d24115706d66", + "python/sglang/srt/mem_cache/unified_cache/components/mamba_component.py": "9bfcb7a20af48c2fce8cb63537db54cb4231456d9c04896370e290611e0ba799", + "python/sglang/srt/mem_cache/unified_cache/components/swa_component.py": "2db0eeaf673cf690460f9c859fdc35eecbcf3ddb9396b21c7a7502f8925d6b52", + "python/sglang/srt/mem_cache/unified_cache/components/tree_component.py": "e79eab56f3803fa81181cfa4d6a42d7aeba95b5d89a1420195c4003483bbad0e", + "python/sglang/srt/mem_cache/unified_cache/session_ref_tracker.py": "21353af6b20585132b65e3952dc5ce3f2450780db1fd8d0d809e184d3fb37007", + "python/sglang/srt/mem_cache/unified_cache/tree_core_registry.py": "d767fcdc2c2d7ec40f541be897a4036d55fae7a40c629217cf72ddacf1bb7359", + "python/sglang/srt/mem_cache/unified_cache/unified_tree_core.py": "2b66bd6c8105c12d8b57b5d6c1abd3a87136bfaf0524fd9606c7746c81327aed", + "python/sglang/srt/mem_cache/unified_cache/unified_tree_core_interface.py": "cbffb202a3a4bc2e91b184c19551ff1a310eaebdf70fb8fe93e52c5ac8c3f9a5", + "python/sglang/srt/mem_cache/unified_memory_pool.py": "143f40588c2b88929dfc5017281373413827026ee79e6870b703b0b999946348", + "python/sglang/srt/mem_cache/unified_radix_cache.py": "6e29ffa01adb96c9d400331850fe60b054cd83c980f033d36552e369a5d5c6ce", + "python/sglang/srt/mem_cache/utils.py": "9310f130db27f7277ad0295a02f82809f3798c4e6ba0ea828990a76809f7068b", + "python/sglang/srt/model_executor/cpu_graph_runner.py": "253c23bf2abe2642763e7942a973e4456c49733253c45b47e54c936fec1100a7", + "python/sglang/srt/model_executor/cuda_graph_buffer_registry.py": "28fbde4e1e9f2824928b29283690fed9e7f38cac435d416f355fb92d8ea346fd", + "python/sglang/srt/model_executor/cuda_graph_config.py": "a131496f543eb354e91ca818b0f3863918da51aadae8e8a6fba087edd30cec76", + "python/sglang/srt/model_executor/forward_batch_deepseek_mha_mixin.py": "4d46d49221749cff5289c262d8acd6e2f5f3d44db1a1d7ffabbeb32fd9e6f05a", + "python/sglang/srt/model_executor/forward_batch_info.py": "c5465206368475dd2c1887de893679fa171793ee00eddaca8ce6acadc9237627", + "python/sglang/srt/model_executor/forward_context.py": "63900e43eaf683bcc50991e56dac6d194566b9fcef2ed452ff8e5818e503d2d0", + "python/sglang/srt/model_executor/graph_memory_usage.py": "e98c9a6d7c4af6eff1302e0a592cd1724098b043cbd47cdb0c25780d3058ae9b", + "python/sglang/srt/model_executor/graph_shared_output.py": "aa7b7bfbf903584089ba64f8756a541343edea0c8fcce5f6d49e608e7c0159f1", + "python/sglang/srt/model_executor/hook_manager.py": "899bea28f874cb7a44b7d10fcff50814b6f99221e31fe4aabd073227f3c24073", + "python/sglang/srt/model_executor/input_buffers.py": "5167fe0294d63ee7dcb4f8c5bf9bf4430c838666c7b00f670c8c57a50d9e14e3", + "python/sglang/srt/model_executor/mindspore_runner.py": "a2d5affc4c2d97069a93f17b215a870d1b32ab75479e47adfa73797b666e0bc0", + "python/sglang/srt/model_executor/model_runner.py": "d93a427b8ba77128ba0752adb990a1d69a489e3249c189ee9bca67583ace2069", + "python/sglang/srt/model_executor/model_runner_components/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/model_executor/model_runner_components/attention_backend_setup.py": "bf01b845e22471e19941168dad276e8f429ca302e7cd59ec4c0463defc5bbda0", + "python/sglang/srt/model_executor/model_runner_components/cuda_graph_setup.py": "ca36d4b440ea7a67f42cfc1c253a292f5dd039041ea24cc6d9177ce58aed3205", + "python/sglang/srt/model_executor/model_runner_components/kv_pool_runtime.py": "ab82c8793c90f0fcdbfdbe4a9edaa28bc760c304c4a76cd6b03a96f20263d061", + "python/sglang/srt/model_executor/model_runner_components/layer_setup.py": "235c9ecd3a707645fd3aeeb54602c4233d23cf23a216e16ed8ef7cd6be2f4e4c", + "python/sglang/srt/model_executor/model_runner_components/load_model_utils.py": "c864d5fa51311a9653a609bf23a70f21d2d6ea5c1556c5287adbdbb1b3c4ad4f", + "python/sglang/srt/model_executor/model_runner_components/misc_utils.py": "673bf8a3feb784c9054c9865d2c3441f34039e43d84548928c2b4b7022f57112", + "python/sglang/srt/model_executor/model_runner_components/moe_ep_setup.py": "5776252dc6787df809c41e2c2b2130b153c76bee773ac814d673be782d6b2d0a", + "python/sglang/srt/model_executor/model_runner_components/ngram_embedding_manager.py": "050718d06087e1586d220654fd91916c4dd1b0494a2312baab768bc2c3e9d797", + "python/sglang/srt/model_executor/model_runner_components/remote_instance_weight_transporter.py": "092536c27b0f72216170708dfd3ab6edea2e057f9e4a5bfdaa8fdaa17606684e", + "python/sglang/srt/model_executor/model_runner_components/spec_aux_hidden_state.py": "db31c1d76466c6f99e5acdf9483a2a6beb4e6d8a6d96a07c17646257a61a7e9f", + "python/sglang/srt/model_executor/model_runner_components/startup_weight_load.py": "cd502780948edcffc33027a4b324a37da14630468b1c5ed0cd22bf4515bc4efb", + "python/sglang/srt/model_executor/model_runner_components/weight_exporter.py": "de472de90137203bcd00585e400a9200b62f2b78385ed9296fc0d00ced9e4487", + "python/sglang/srt/model_executor/model_runner_components/weight_updater.py": "564f42a67afa1d0f37a0049b8ba6d444808bc9b3ecd536d071feab125358df81", + "python/sglang/srt/model_executor/pool_configurator.py": "2bbd8233d29e1e748b4600f902a9911db1de4a14d727f30d6dd3fdf4083624ef", + "python/sglang/srt/model_executor/runner/__init__.py": "97fa36fe04f0627ea70570f30b63e84dd8eb5945b8043d087cc81f7e4ff949c6", + "python/sglang/srt/model_executor/runner/base_cuda_graph_runner.py": "2f64791e0a5056a248126e306b4a003b510ecec66d42bcf62e52f7801ba23ac9", + "python/sglang/srt/model_executor/runner/base_runner.py": "7703c46be36a5e5c04b6a0d99117b58cc007e578c61effcbe968ef8cac90adc3", + "python/sglang/srt/model_executor/runner/decode_cuda_graph_runner.py": "96a92a7c60a8ec81c606721ec7d5cf7588173a55505e58f7f231757a056029df", + "python/sglang/srt/model_executor/runner/eager_runner.py": "40168d097921768244166dabd3506e9f136ef7dec1455e7cef927978c790c351", + "python/sglang/srt/model_executor/runner/flashinfer_autotune.py": "a719df49227f1c16725ee08b3653ce533a231f202f026eb0abf6654b2230a5c4", + "python/sglang/srt/model_executor/runner/prefill_cuda_graph_runner.py": "d0a020ec366e536f80357c749a9653cca00202da0019f890d4a205e783e6e875", + "python/sglang/srt/model_executor/runner/shape_key.py": "11f5b0c097aa4041c9b52f83422760394b039eda9633862035ba09cd7b5c3bf5", + "python/sglang/srt/model_executor/runner_backend/__init__.py": "0ca105fd3561122d1dfe030672f9ac094ef000aafcd3109f565ce78d8e1b05b8", + "python/sglang/srt/model_executor/runner_backend/base_cuda_graph_backend.py": "57fcbc83c10b8e83dd60cd3da1cb7e2a58b19ee0a390d80ae921ed24bcac4ecc", + "python/sglang/srt/model_executor/runner_backend/breakable_cuda_graph_backend.py": "e64520232bb15bba64aaa98bf89fdd34d25b13e1ae1190caeb25b98ddc4e6f0d", + "python/sglang/srt/model_executor/runner_backend/cuda_graph_dedup_mixin.py": "9038ca91df07fd957ee910ba6ce8af10da36608da01331591a391bdc8e2c535c", + "python/sglang/srt/model_executor/runner_backend/full_cuda_graph_backend.py": "f765293a501591ffa5a108cc73ea3efed8c90fc4a947021602a15d4248ee5c12", + "python/sglang/srt/model_executor/runner_backend/tc_piecewise_cuda_graph_backend.py": "66414526bedeed4b085d691410507b7c3428b965d93e5ca4108ad004d6704ef9", + "python/sglang/srt/model_executor/runner_backend/utils.py": "c0deb930798f6fd63e4a7955a850c0b6f866868502da1f45269f63b796c1c124", + "python/sglang/srt/model_executor/runner_backend_utils/__init__.py": "7b7119efcfd59dad25698a73771656856e533c0e393b073fd3ad0afd38f34279", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/__init__.py": "7cc27ba46d122dfe8f37ff11f02223e4fb2cc5577165a5d6d4dabd7b023488c7", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/breakable_cuda_graph.py": "730d8c0963bf7752e0aa3094f76046424ee836cd1067cb9d8e4cdefcced5c50a", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/context.py": "f7cf9d819d872d4c0d3c0201ba9853939e4509ac8309445ba9f75aefa6525729", + "python/sglang/srt/model_executor/runner_backend_utils/breakable_cuda_graph/cuda_utils.py": "808b8f470974294317589f4dd914d0eb7e3087d1e81bb4465f19f3dc0ac86b31", + "python/sglang/srt/model_executor/runner_backend_utils/tc_piecewise_cuda_graph/__init__.py": "364c2cdfabfc7c1e746f87aced897c54f10790fd5a05c4f9100d342ab6db85a6", + "python/sglang/srt/model_executor/runner_backend_utils/tc_piecewise_cuda_graph/context_manager.py": "1f51ba025ea2130b9c13483dabd1e505edd75bae61f9a05d22bb8273ae238d95", + "python/sglang/srt/model_executor/runner_utils/__init__.py": "e4d428f53b42efe3a95446bacf1ee7d7828e66179d1368020e67ee70e723bcee", + "python/sglang/srt/model_executor/runner_utils/buffers.py": "b330f13a2f7bfaefe69c4fe39024fa64357ad963113700389180d7821e29e3dc", + "python/sglang/srt/model_executor/runner_utils/capture_mode.py": "539b4f62039a17c5e5e0a0637757d04de3cfda83a5ed37f611c2d5be2e4795db", + "python/sglang/srt/model_executor/runner_utils/deepep_adapter.py": "d97ecae40b3ce131994459af95ab425cec058e74d78b54ee7ed405d11a57c1f4", + "python/sglang/srt/model_executor/runner_utils/pool.py": "f271c959b63c5925e0784f3232dc7babce2b2dd9eee525a18b58fd60886eea54", + "python/sglang/srt/model_executor/runner_utils/shared_read_event.py": "4dc2cbdb575719dd7b604977116272ceb4f95c356f48047123deac2773faae83", + "python/sglang/srt/model_loader/__init__.py": "8cfa1f43a634864baf70c664ad8bc911a9da50a1cf84a7942f5187bef477ce00", + "python/sglang/srt/model_loader/auto_loader.py": "4401654e17fd8c9a65bc15bac7f4786d7fb37eb95fffb9f747339ab57ff5b173", + "python/sglang/srt/model_loader/ci_weight_validation.py": "73c825b8435845663dc600a456de9e7c416626ce37c7c85331eec77a87b77881", + "python/sglang/srt/model_loader/gguf_name_maps.py": "281feaa82e79d805d58ba68ed6dbe6287db3515300ab3cbdd8e397cd44bdcdb9", + "python/sglang/srt/model_loader/loader.py": "5746f08e47e8a21e173a0df6036a9c1d58d0ffee5d392ef5361deb7d77d0a539", + "python/sglang/srt/model_loader/remote_instance_weight_loader_utils.py": "6e4743a6715a7a24bd854144b9d9383fd6479da8ca39991845f4e96d5a5c6b2a", + "python/sglang/srt/model_loader/utils.py": "7151f2b4092d14cb13a68ec645f386e024f4919eb22dc52fe72052da01419834", + "python/sglang/srt/model_loader/weight_utils.py": "1759d4feb63dc1e41f509f16c4d46d2f00a175fec6f5efda1fb5a7501394588a", + "python/sglang/srt/models/afmoe.py": "51416d24e54e8686c2a15a08ad211dd62fa281b5a9ffaf7c32461d44ba69771d", + "python/sglang/srt/models/apertus.py": "5f3f741d622c74475de0a2788a364728d933ac98e72fb3b061e643e702bed800", + "python/sglang/srt/models/arcee.py": "00d5599d470e993a6b3308dc0ba9231c386d45cbff60d51d65957c0f51e1007f", + "python/sglang/srt/models/baichuan.py": "3a8ea172c648f8e472012dd7c6a68e02b4df34bbf0d2d36527aa35c6542b0e00", + "python/sglang/srt/models/bailing_moe.py": "c5052c1d24a805a78623d89f32d164a50db75167b177333b682814b3473c3599", + "python/sglang/srt/models/bailing_moe_linear.py": "366d86420d3811c7a6b084c7b4280b2d994e3b2f058df4918a83a452bb66acfe", + "python/sglang/srt/models/bailing_moe_nextn.py": "d33076e60f6801ea42e5e6f2ca3a97e449bf20b2ed3d8ae930726aa2490d31ba", + "python/sglang/srt/models/bert.py": "23b157b2a5d90c24c7ced6a67909120d1d0759fe5b9d518c15bb29ee7e4240aa", + "python/sglang/srt/models/chatglm.py": "76f9c49d9b4cba67d244841774449485a8c98201402508fc9cbd2d7efc07d302", + "python/sglang/srt/models/clip.py": "0b3851d2381bc2cedda81d985f18875414f9ccd6844958ddd556b8fadc1cf2e9", + "python/sglang/srt/models/cohere2_moe.py": "bba44f58ef1ec55e1004d8ddbf99950eae69806f3a061c102a45fcd428fcffa0", + "python/sglang/srt/models/cohere2_vision.py": "4350018aa1c8f8dee60024ff48756ec7b88a1d906b35263308b666772d7ea346", + "python/sglang/srt/models/commandr.py": "a80d35171cbd8f87dfe2a1832440c311c340ce06ac8c66324a29afb1c915cf2e", + "python/sglang/srt/models/dbrx.py": "9f0d6d344cd10eb4f810d042137ffa067b547f86a1a82f9c4882b959f62d7814", + "python/sglang/srt/models/deepseek.py": "7f1e7743b734acc16f821d166301015120bd6e64242464d326d5c3a38883c830", + "python/sglang/srt/models/deepseek_common/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/models/deepseek_common/amd/__init__.py": "91337352ff5bde7bb2d74116c6beabf628948ab03fe055604376861e3486bb19", + "python/sglang/srt/models/deepseek_common/amd/deepseek_v4_fused_mhc.py": "83d2a21a47f867c8816c6e60aac17e435f0b212946838d280dcad99f670af91c", + "python/sglang/srt/models/deepseek_common/attention_backend_handler.py": "0d379aed9bac29ccea54361ffd22ffbd4853c9008f70a8d75b06b6a6ebd8a2de", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/__init__.py": "4907531368605837fb09f3579dd648ce6a27cbbbd2177ac69629a1f6705dbd37", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_methods.py": "4d66f9a7098eb22e1a94ba16ceb2865e18df578de9e9878cb3b314dcaa3d2e1c", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mha.py": "9ecd6362edf7dcbd6f9e49842450bb45295bc8efb605ade27082a8d7bd8807e0", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mha_rocm.py": "398271bf5d75636eb721987b3c73387be7ce17349bd20533a1fd259e0d35b15e", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla.py": "d54137d7bba213cbfc39365fbe41492a4cb26ac479236c77fd7bda55c7c4bc42", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla_fused_rope_cpu.py": "c6c3965d5d76a6a80ffca6dfd40229df38ce92ed8aae946eb2bd356c50cef268", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla_fused_rope_rocm.py": "9a7cd4113aa4c830aa4403ecf240fe13eecfcb84bca4100a762b571d07d70145", + "python/sglang/srt/models/deepseek_common/attention_forward_methods/forward_mla_rocm.py": "9ed9a0fd2262c22935879c919540dc96d3965bb0ef59d18e7460747ea8e52629", + "python/sglang/srt/models/deepseek_common/deepseek_weight_loader.py": "04a7e150912e7035c9ec538822367c4d9160235a4e23d94a2e526d1c6a4f9f19", + "python/sglang/srt/models/deepseek_common/utils.py": "7e9b06cce0501c1de11afc261e446c1d4edcd5f43b06c7f273ddf633c6893f3e", + "python/sglang/srt/models/deepseek_janus_pro.py": "c22190f341e785675a3c9d1b62441467f4da4bb7a4bf9095759c9e6e8d427deb", + "python/sglang/srt/models/deepseek_nextn.py": "462c7595ac80361c5988bfdda4a63a3cde0236983d2afcef11241216a210986c", + "python/sglang/srt/models/deepseek_ocr.py": "7f11abd028f5d48f178120e69c5dcb936f17fa48699c9eaf482be1771d186797", + "python/sglang/srt/models/deepseek_v2.py": "1ba2ffe6bf7537d0fcef6945f44b239883125a8bc382e86fa57885c135bed21f", + "python/sglang/srt/models/deepseek_v4.py": "304cdce90a9638804731c36a6f4f61f56c7d81f2e530f7bedd67bc5eb632e75b", + "python/sglang/srt/models/deepseek_v4_dspark.py": "0a7221f4405ae49b88983c97eaf97e073823871180d9080e6f7215a1206ef16a", + "python/sglang/srt/models/deepseek_v4_nextn.py": "d3139cd8f1dce2b2100f5eaeda71bb826abf4b5fc9dc20170147f6727bd24d30", + "python/sglang/srt/models/deepseek_vl2.py": "f2ec27c761892722ea7003e4f16f66b84786866551f77de4debb3961b4702a7a", + "python/sglang/srt/models/dflash.py": "b4c867543d80845bb621cb9bf93a0f9d8b09a6753f2a4d32e5e36d2122babc30", + "python/sglang/srt/models/dots_ocr.py": "b16905b043635f96ff09e70b0aa5e37a9b2bea2cb209b3539a365b45fa01e1e9", + "python/sglang/srt/models/dots_vlm.py": "13e74814ce7ae20cf2d37855cd429e3227b2d40269d301985f41ce1888d0da7f", + "python/sglang/srt/models/dots_vlm_vit.py": "03dfa21a2955d6d00148f97c40c9a840ca9613e33261b88911497954cc608f74", + "python/sglang/srt/models/dspark.py": "194759ffba28cc1e1d7d8ba28cb2f0134ec9f935eae34392bca2178c748b19ce", + "python/sglang/srt/models/ernie4.py": "2cbf4d45eb9ab1bc6b11ddac224de50697374bc8fcc21b711b1c73adb9e5604e", + "python/sglang/srt/models/ernie45_moe_vl.py": "0b0047ca789e1d763afaceb687bd1129eebdb0be26436e142ade22254adefc8d", + "python/sglang/srt/models/ernie45_vl.py": "cc7804e3875b65c7f541eb2676565616158fd019c8a6fcc6635119ae57dc93a1", + "python/sglang/srt/models/ernie4_eagle.py": "fcc548df82ad5df32cbe847406951d47800265931226e68853f4d97c17a16b77", + "python/sglang/srt/models/exaone.py": "a38b7b4bc8e2e2ec25108bfde1414f33fd585b06772aa376a10974799bf5bce0", + "python/sglang/srt/models/exaone4.py": "8d46719fc5bab2348a96c5d4b5ca481776c23e81421404c870a620633043d1d4", + "python/sglang/srt/models/exaone_moe.py": "d29647bf5a6756dd087a5b28a23704a461b10900588f0321bcf88fbca228e2d0", + "python/sglang/srt/models/exaone_moe_mtp.py": "71ae12725a3c92a14a679002cfc8c091de0f578dfbc2d263376e443c1502f544", + "python/sglang/srt/models/falcon_h1.py": "2feed2e456a7ed86f8d6827994df3514e5c94244dd675ef99b4f91c58cd63812", + "python/sglang/srt/models/gemma.py": "0fb42f0965d7b846b9e1b04cb63f76404bf77b9fd9db91c76c08cb940e37ece5", + "python/sglang/srt/models/gemma2.py": "aeef5821188e4b01c3e7d3569851ac9609de210d7988d7bc560a3d9c9b0202c3", + "python/sglang/srt/models/gemma2_reward.py": "2b89ab5090aa9c7832763ac38084c58095d1f5584b23c5acef29cf5287194ab8", + "python/sglang/srt/models/gemma3_causal.py": "e68b3840ebef0b986ab96653ee2bc4395192f330ddd2a95f0ad1e420912166a4", + "python/sglang/srt/models/gemma3_mm.py": "f35141ba77b106706574e8ba3f905e54e8210e5a7d7fbdcd1d2991d036a36e71", + "python/sglang/srt/models/gemma3n_audio.py": "8ac80a7e30395227986b0c54ea679d2f6b2c5e5cd83ea01b6a00c19cb71e982d", + "python/sglang/srt/models/gemma3n_causal.py": "833ca64d4d4571a6612d6cbd63c7260ddc1207691e8f0d835a58a9b6c017e079", + "python/sglang/srt/models/gemma3n_mm.py": "c5b0965ccf240ae0d6216bd4796a12a85d0f16920f5c658a5fefb1363137331c", + "python/sglang/srt/models/gemma4_audio.py": "08a394f05e3b87593346cc68f2c7c6fca5edd527a9564f2e25fbd0117dafb8c1", + "python/sglang/srt/models/gemma4_causal.py": "62a9e720bb0b339005bb96ff12a128c476936b9ec2764e529bbed7e3df4a6f5c", + "python/sglang/srt/models/gemma4_mm.py": "4e58c60a573f140afe9bf51d8023d909aac48ca906dca40bace4b37394f137d3", + "python/sglang/srt/models/gemma4_mtp.py": "3c2025089f6c62738770a45bbf64df5bc615c2f378cdb1753f4febc055aff138", + "python/sglang/srt/models/gemma4_unified.py": "d5498b253f35e83ab0aaf219a2c2bf2f42c6bbd3f95ffce02760e78b2e38a4e9", + "python/sglang/srt/models/gemma4_vision.py": "66eaaa3968f9ec8339890dc105174e74db21c6efeab5ca31650c368db97a445a", + "python/sglang/srt/models/glm4.py": "ca559ff25961b5c87e017d76a8169c48a3ac6e6e59ada6ee8f2d5699ba5ba6c8", + "python/sglang/srt/models/glm4_moe.py": "da66fe6314fa84e7401900cf7e7a05d7dced72b39477595c3a67fda735e24256", + "python/sglang/srt/models/glm4_moe_lite.py": "cfcee7654fd72dbd192fcd1b8a1728fb318059caa41c679e3457abf50a7e1031", + "python/sglang/srt/models/glm4_moe_lite_nextn.py": "165b7fd2a6b15fdb338707846dea4aa4f4a380f87eff358a4463c8598fff1f2a", + "python/sglang/srt/models/glm4_moe_nextn.py": "6c6b01239f596f2c3ff7cff2836b498d2c7e5d891ef4d387eb9d2d74e46dab91", + "python/sglang/srt/models/glm4v.py": "92ea7274deab155e77bdc8acaff13b422ef46038aadb46aaa59c0783aa1e526e", + "python/sglang/srt/models/glm4v_moe.py": "b510ecd4d1aa164699e1306861e993a9b07bf126f98944bd618e9c158754d5bc", + "python/sglang/srt/models/glm_image_vl.py": "7d994d2b83a9cd46151bf525dae23525d4b1ab6636b57d62933348242c2d40cd", + "python/sglang/srt/models/glm_ocr.py": "1f0af6af0d24a3d8e36ca50e93e52ec8f2d45f8b6e2db7634bd551301deed8d0", + "python/sglang/srt/models/glm_ocr_nextn.py": "f4495df9b3a3cbeef4948d563c832f378b302113d714dc14892feadde8b9a7e2", + "python/sglang/srt/models/glmasr.py": "36bba050ca1b985944c46ee662f3045f6cc2c76bbb7168033900de75baf48ed1", + "python/sglang/srt/models/gpt2.py": "acc560106bdb0f4bf7666a6500bfe04871cc7cc330ff9f984343825a048ae429", + "python/sglang/srt/models/gpt_bigcode.py": "d93a118f5a053b4f5a916a38ac277e8ecffa810497fc36f38104586f381b405d", + "python/sglang/srt/models/gpt_j.py": "ea6573f8f959be3ad3e6b429955cbc2c8e60957af456b439ddb2fb53b1121536", + "python/sglang/srt/models/gpt_oss.py": "e345802d5b8696e58cf3022083110dd8d1fda18290cf7fdc13274605fc3e3dcc", + "python/sglang/srt/models/granite.py": "2157d2628813e0d91877b54ba9cbce90067b77cd56ddf6b00b634e94b1f7738d", + "python/sglang/srt/models/granitemoe.py": "f1a465f47fa472801ba0c8cefb9227254ea6309273e5ba6394054d329ad03910", + "python/sglang/srt/models/granitemoehybrid.py": "63e020e0d734db583a5dd19fa70c7bad6a1ea4800a92a7fb0ec8084edebbe44f", + "python/sglang/srt/models/grok.py": "63b87b5e58545c7bc474f9f1793917afb18cf33b9618946a0f7631acc52cc481", + "python/sglang/srt/models/hrm_text.py": "d71689264ede55ce8ba847ac63ce6cb43b671734d267a0b67b08d60b62a1a88f", + "python/sglang/srt/models/hunyuan.py": "137de560974b24bd2c8705d82a13f4a2357d2b86fd16c389c8f07d1cb5639749", + "python/sglang/srt/models/hunyuan_v3.py": "bcf21fe22dafbf739b009eb3ea0c996251c08c69b07d5a61284e735ae6d184ff", + "python/sglang/srt/models/hunyuan_v3_nextn.py": "1389dc50cc287248b03adcbe4e2c394d5c81cec5191e3c047a1b3f2156dbfed7", + "python/sglang/srt/models/idefics2.py": "b2794f629f7faeb43d25050ea3d7dc0a1aad0da55134217973ac6c6bfc2869e2", + "python/sglang/srt/models/inkling.py": "bb54c701428d58967690bb016b170a237cb018f28bc1b2941dda61a6c33ffbfd", + "python/sglang/srt/models/inkling_common/__init__.py": "b96821456ca126fc0ba0c2d6d026664714dcaea47fea7add939d80d74f401d94", + "python/sglang/srt/models/inkling_common/attn.py": "2152a03ccd0c0535e65385c6961e968981eb8af9966fa8189a724a3016635a92", + "python/sglang/srt/models/inkling_common/dense_mlp.py": "632432bc4dba4d2e9d7593777aee00af746b2da448d0d0e7e30b424c11b30f59", + "python/sglang/srt/models/inkling_common/hmlp.py": "377c5ac0d2fd579897dfe8e059e60052ffdf08095e02d5c8ab90c8c1fa288474", + "python/sglang/srt/models/inkling_common/kernels/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/models/inkling_common/kernels/comm.py": "f2e1224fe7f1eeb1c576c4592ce55d875a8681e26efdfea54b504b41667bddec", + "python/sglang/srt/models/inkling_common/kernels/sconv.py": "7e9862ea08df10fea5772f51bad0708424b996409c5447ac3872f539e6414b4c", + "python/sglang/srt/models/inkling_common/lora.py": "706df5c637c5b092c246d0bf95605604c33329880f292c061441c4c9ed788c69", + "python/sglang/srt/models/inkling_common/moe.py": "4bf39c7662ac4337ce81c5136ce288be18e532290400fd27de5fc0ea4384ea92", + "python/sglang/srt/models/inkling_common/norm.py": "2f386379b4ec8680cfa438202885a5c31de9e0d9287c2a5fa10e2f1874f2d39e", + "python/sglang/srt/models/inkling_common/quantization/__init__.py": "20764ebd292899f5c31c5747ae7289174126807570f84482ebdf44a01ebf5329", + "python/sglang/srt/models/inkling_common/quantization/config.py": "ffd7c1bda9e756ec6056b61a5b6d853a2bde682cd6ac39b9fe8b0b3ceba21613", + "python/sglang/srt/models/inkling_common/quantization/quant.py": "9fac6d421bdfd85086e390c45f22794f79bc23934387be094206df26ff8a00b0", + "python/sglang/srt/models/inkling_common/sconv.py": "39f7e78b8b9b476de003a902ebfc7acd98cae625901d94d23b24d383238dce06", + "python/sglang/srt/models/inkling_common/util.py": "6258d774bb930aad9f93c7fa91475e808d1a427fe3d6044e1fbc2fe8867a25cd", + "python/sglang/srt/models/internlm2.py": "e9a1b60b9ec93b02cebb60b2a8db90ec75a5ba07aac92ef48d0b418f03a59bc3", + "python/sglang/srt/models/internlm2_reward.py": "c229f6bcf851c72696b5d637f04ce8dc865ae49f8436fe9558c2b57d2aa7364a", + "python/sglang/srt/models/interns1.py": "f36a7f8af20b4dc127f3138fc951b573d693fa16ab3af96dbcca267a63583dec", + "python/sglang/srt/models/interns1pro.py": "f8e196bb3eae4df08312c58ac124587f2195732bef28851aff0d3e7b1b31d3e4", + "python/sglang/srt/models/interns2_mobius.py": "b6b1684fd7d6e5110d4a6bd297f0703d83629ccbc9f1d330f2363e864d7f310d", + "python/sglang/srt/models/interns2preview.py": "f19744e2c4c18d2919100423b8bfdc0546c80512a293b2e49a2a727272e067b7", + "python/sglang/srt/models/internvl.py": "b318a9e40618e85114a472494c3e9410d2ad9ad7074ad1cfb89fbd48483d86f1", + "python/sglang/srt/models/iquest_loopcoder.py": "a9276f23629feb434f0e12a81709c7d9bd903b228b84e68c2c6706373713b91b", + "python/sglang/srt/models/jet_nemotron.py": "38ebd2df37393986c1d816f316634412cb2a7a0d4bb52b0acc068b012e3c8b92", + "python/sglang/srt/models/jet_vlm.py": "2b406a23b6a742e0e0912b330191d7795dc52fc9ee8828abcf774a029e624d02", + "python/sglang/srt/models/kimi_k25.py": "cf64ca2bab9c828aaedae7a86ce018947d32138377fd2f2a5b9a2e4ea7769503", + "python/sglang/srt/models/kimi_k25_eagle3.py": "4717e7ced2536b879ffecbafd8597ad55a78707cda79cffa27ebc11a9aa25f1d", + "python/sglang/srt/models/kimi_k3.py": "d8dfc58e73246577d9eb6aef5488ee4c205ca40b88bd9af849ccfffb59146f04", + "python/sglang/srt/models/kimi_k3_vl.py": "2924c38f652a6ebff2ef79c49f2f336ba18723ea4b854d3ac14d95292988acdb", + "python/sglang/srt/models/kimi_linear.py": "40274c2c8e6fe095c0b3edea28ced13083a26dcdf45b7b0eb06e5788686a8209", + "python/sglang/srt/models/kimi_vl.py": "8b6d662dfccf19543ff8223a862bd1eaeed80f073001c27f20c655130ee9c713", + "python/sglang/srt/models/kimi_vl_moonvit.py": "e417162c4e61613bd76994ee9fe0af1a58eebaa44ec14b6d6b85bf778ae6dec4", + "python/sglang/srt/models/laguna.py": "085ddabc569bdc797394f9dbc83e16d1e8db309b50295517f5ee03b974de6d01", + "python/sglang/srt/models/lfm2.py": "1ed88642d9370b69be11d219e86caeae80aaac035062a70fd2d148a2ecb14f92", + "python/sglang/srt/models/lfm2_moe.py": "7a3eb60fa52f32f07cea305e233bc0514a940a9a7444daa42252b4be06596f3d", + "python/sglang/srt/models/lfm2_vl.py": "256facc230ca3455a651a2feb94302a9b25cfb66316f041f87ae5d5fb306db77", + "python/sglang/srt/models/lightonocr.py": "88b3e3f81a099bb19d280f078c9ba303e1ca85e1f5fa078424d516d29fe39577", + "python/sglang/srt/models/llada2.py": "89306a43224bb9a51749fe7738be7356f40d9858a5f11037a45ec0239b02eee6", + "python/sglang/srt/models/llama.py": "1f70c2745c24658a55c2b17a7629a9c728e41f2fb2734801ba12becda55d932f", + "python/sglang/srt/models/llama4.py": "e372b3afea00078bb75e1b0d6d3c3472a740db63c54e84b9511549fc5d47da0e", + "python/sglang/srt/models/llama_classification.py": "055235ecdd405590a3e883eb3279012f5ae52b6889b842e489794a3f713e67bb", + "python/sglang/srt/models/llama_eagle.py": "03a48b74e97bd7f43582fc4b11d06f3423f384538c4845c86df1c6804fbde6f8", + "python/sglang/srt/models/llama_eagle3.py": "16ab0259f7823174688e0461827aecdc51edeb7693eb720c9a0f7cab3bdcc8cb", + "python/sglang/srt/models/llama_embedding.py": "ceafbf94dbb7e5504573b79e9a26a6d3376418813c7f3ae093939661f8ab6670", + "python/sglang/srt/models/llama_reward.py": "87625f811511a8aea3e11e05a12e4490edced7703ac3126a015db48a0098039b", + "python/sglang/srt/models/llava.py": "49ffe4b8e6dab21185e6dfd5e632bfab9f02b8ffdccb3e3ef94e95aaf7a021c3", + "python/sglang/srt/models/llavavid.py": "cd78585da7006df12425fb2a5d1fc5a6998e13ed1a4e2ff4c51efd1e3c45fd76", + "python/sglang/srt/models/locate_anything.py": "e5ad5a36e85f417e38ec297ac091dee0ef54fe9495c7cd5c9d1ab920b277b8fc", + "python/sglang/srt/models/longcat_flash.py": "db2b42f23b3461a6d0a0be1c52a05550c3bf5ae93ea45165c91d4248d40e01cf", + "python/sglang/srt/models/longcat_flash_nextn.py": "b2dab60290fbba8c612e2f0712fcab802f98aee18d585665ca4697a60439a636", + "python/sglang/srt/models/mellum.py": "ec83a2403979372196e8ba805d0bc4d3a60a05f39ebf4918fc25fd2c710cdaed", + "python/sglang/srt/models/midashenglm.py": "41feec5b1cd1c902f518dfbfe829d072a46046b945c2a8cd2ed00d388c17e14b", + "python/sglang/srt/models/mimo.py": "4dd89f957b5ea3f1cb1fb43561feb10c039747336b3a92d1e248d55ccb9e96d3", + "python/sglang/srt/models/mimo_audio.py": "2530a986a818f518d258ef1353c5b436eac05a5eaa43dcd9f0097060afd33114", + "python/sglang/srt/models/mimo_mtp.py": "da82aeb473817dfea5828b65cc4c9724c9ba80aae0fc6397b11c7450cbba2a94", + "python/sglang/srt/models/mimo_v2.py": "f7a413a456e6567155b91ad479fa6ec42420f66b7dadd5449d0d45613a50a7c1", + "python/sglang/srt/models/mimo_v2_asr.py": "6527276c32b62e75af54d95f6132b600f8e0e62a4afe45c3a263fbf72ab68ca2", + "python/sglang/srt/models/mimo_v2_nextn.py": "d5ee45e7db07f2e527a2d03ea013fb8cd2a54495b330f51f0c9fb81c127df061", + "python/sglang/srt/models/mimo_vl.py": "0b365aafabc003b0a8bfc7617542e1ae7cbbc1ab2b32a13763c05fc69606f6d8", + "python/sglang/srt/models/mindspore.py": "e05c612e4f467779caf96267f2e7e07146b04fe1bc81e578758bd92911346c87", + "python/sglang/srt/models/minicpm.py": "10288c7ac6d8e762aa7fd71fd9d186d1daa804a836161242718c27b23471a6bd", + "python/sglang/srt/models/minicpm3.py": "4f0519477f7cc9aa708a040c184b6544a21c6c5a142ae3b3767ec61d6853df55", + "python/sglang/srt/models/minicpmo.py": "c47dfac0dde4b64672db7b015d4e0891686e70924259e0c4a86e68139ef56314", + "python/sglang/srt/models/minicpmv.py": "cf93d077bffac4401d7d8de57f728dabb1197537da615143777092249a23bdef", + "python/sglang/srt/models/minicpmv_vit.py": "bf539b30ce1fb139bf70c43ef0fe6bd4d96dc7104fc0004cdfd313a394f008e6", + "python/sglang/srt/models/minimax_m2.py": "dd593d37b88bce083f55a94055d4eb24a4585cf0f93f4e761749529b764e3446", + "python/sglang/srt/models/minimax_m3.py": "2cef3ef046f7e1a2786cf5874bdb2ceab83e99d2ce70b421af0ea2d3094e29d5", + "python/sglang/srt/models/minimax_m3_vl.py": "e472fabc0e06683de377debf71940c16929e1fe2e1b7e6ea74a172e14f109a3b", + "python/sglang/srt/models/minimax_vl_common.py": "3f141f6fb07081d11d7255adbcd11d5feb506cd291315501a8f1653b8de40be3", + "python/sglang/srt/models/ministral3.py": "93a77d7707c5415d24704ef83e15d6a080bbe39796715b105288ce8fcc63cbdd", + "python/sglang/srt/models/mistral.py": "21a2df76c3cb114833f521a64e8dac53986036e1eb4bdd5b65759a5100904cea", + "python/sglang/srt/models/mistral_eagle.py": "c286d3f3946dfa08537cefc3f1979ce1fc6ac4469ec6aa7eb2bcc62a67782aa4", + "python/sglang/srt/models/mistral_large_3.py": "787c57a6499ebf68e3661135e3f14350ee808eacff9e7a339fe5bcd73492e09e", + "python/sglang/srt/models/mistral_large_3_eagle.py": "172bca42aeb3f1f1399de0de9d45bb8046d64f319c407cd48eea9f91e10ac056", + "python/sglang/srt/models/mixtral.py": "96da18082e741b197a428089558b2c9454edc59bf4c8e3786ea476c7c0c04346", + "python/sglang/srt/models/mixtral_quant.py": "cd8cd32e82be078d4dc7609a7f5483180dd859a3698c5451185066c428c51f1d", + "python/sglang/srt/models/mllama.py": "3da05e06e5479fb909cd3f890063bda3dff10a4bc621da8563d842c959f09184", + "python/sglang/srt/models/mllama4.py": "a532260b2312fc894f8b7029e44e9351cbfb64a5a519a429ab98ef0a1d997c63", + "python/sglang/srt/models/moss_vl.py": "28308ce12e14186c7c49a6c3a30e420d56d85ba26f9e3672f3b31dfd7d238712", + "python/sglang/srt/models/muse_glimmer.py": "eebf558cf180de061283def5662a2b2489f6e6330f4e812e5ea47b3a183d708c", + "python/sglang/srt/models/nano_nemotron_vl.py": "8518784a2c5b2475fc125daece17864de13fc443e00923cb8ddbc227b090b1e6", + "python/sglang/srt/models/nemotron_h.py": "0510c47bac841d1da1ec3b2e7e3ff9a54dddaafa393a7a08dae9efc3c5be910b", + "python/sglang/srt/models/nemotron_h_mtp.py": "32392f28eb09ff30786bac289cc3c37aa7614455438a2bc62f78325140d96dd5", + "python/sglang/srt/models/nemotron_h_utils.py": "a7ddbf52ee14533da3a06e9f63f3bdcee2726007af615fdd22aba88143c3b510", + "python/sglang/srt/models/nemotron_nas.py": "875028f2d773fb1f7904894a2437e060238fb6e1e49723b72698da89f02d43bf", + "python/sglang/srt/models/nvila.py": "667265c922eff8080a13a5bc52aadc71754a1353588a91243721bd9e40235559", + "python/sglang/srt/models/nvila_lite.py": "1331c607d087580f1d6772a057d912b71e5dd84eceb9df2e4f41c36b804c0252", + "python/sglang/srt/models/olmo.py": "bccc66bc7985745d36ab09a7f6c0e66548687cb789fd0cdbad9547a1076d05f8", + "python/sglang/srt/models/olmo2.py": "543220ce3ac3767d8d039e44165005703cf273bb5b05436c04bd5f75aa2e50db", + "python/sglang/srt/models/olmoe.py": "0369a0f057bb8905727ecd38368e7153664f9f40bb67081734ca6deec236f521", + "python/sglang/srt/models/opt.py": "276fdc26df083a110a5b368c129731f313a641a77b8d917f928a88d5ff10d1b2", + "python/sglang/srt/models/orion.py": "60d9f622dcfb5c89346b86c2fe00e978d71b6e36b7746480c5eced5db2bf93a3", + "python/sglang/srt/models/packed_ple.py": "32a733d445fae43d5fadc85106c6a3617248e1d0be4e8b101607aef197bff6c0", + "python/sglang/srt/models/paddleocr_vl.py": "60fdb8e506dca8afe50567782baee879806d5cda0b44cb0033c5f574d99f83bf", + "python/sglang/srt/models/parakeet.py": "afa477ab4dc5fe1e82855066664db54f8fed8602ce9e7bc744c83ded57d80ab5", + "python/sglang/srt/models/persimmon.py": "a270b4ae43f763a41304c37b90af3fc651134b03af6e5feb8f24c5b9068cb8b5", + "python/sglang/srt/models/phi.py": "382592c42616624252577c2e4f75d610db2da0a446f9f1f9a76fab24505094c1", + "python/sglang/srt/models/phi3_small.py": "e2a701bdadc1747b89294cb646f2a3f080133372362ec2fdbee1b611fd9f2e02", + "python/sglang/srt/models/phi4mm.py": "f5ad75724add38c0488c6c1e73a4968393e99aa19bfa3a88cd22d6b5dcd093d4", + "python/sglang/srt/models/phi4mm_audio.py": "d0285e930a18b9d0276d8d3e272370cff8a7ccc97133c16650ba91f66c243e14", + "python/sglang/srt/models/phi4mm_utils.py": "6d6dee9f8c774870ef4a400e1d01053b6f3a14674e3de2a10692423a63650bd1", + "python/sglang/srt/models/phimoe.py": "603aa98fd79c0167db1cafb9b2c80e27375ac340325c34b721d03b3378e39b0f", + "python/sglang/srt/models/pixtral.py": "744492a3d65174ae2f0341c3542afd55c870f67b158e83c7b49fe1bb8f1a4dbb", + "python/sglang/srt/models/points_v15_chat.py": "1d5fc64602d371eb4a8740766a026bcb4d8dfdab5c588e4d3e38d010b6ab5069", + "python/sglang/srt/models/qwen.py": "7f783026bd35b5095cbc31436aa2c6775c4584c2d367e73076d864b467c0a70c", + "python/sglang/srt/models/qwen2.py": "41741eb780a3f75bc3ae4f43cc09d538b15752b1d5da34b5a96d8bca36970fdc", + "python/sglang/srt/models/qwen2_5_vl.py": "6949ad69c74dadb1d9e29cd794d13a1019ef3f1342cbd9d2946f53e6b0b19327", + "python/sglang/srt/models/qwen2_audio.py": "36fd4a320987a53035bd94c9bdc49bacf664aee884f139ed43bbd9c5215be55f", + "python/sglang/srt/models/qwen2_classification.py": "b45ecd8c713792662fcf8d6df0810a59e6fda40011fc35f82ea0678b6da7976b", + "python/sglang/srt/models/qwen2_eagle.py": "8c7f437f93e991dc33e04333a77eabd945cecf5fc6e039e64c5e188ef04add71", + "python/sglang/srt/models/qwen2_moe.py": "20467a642243f2160f34381c31468b85c60c33316e4a33b38c07be3ac53424df", + "python/sglang/srt/models/qwen2_rm.py": "e81ec356c191ea45d5db5a1eb3bbc72c29bd9599c70ed3011aa1027c70f15579", + "python/sglang/srt/models/qwen2_vl.py": "ed6c3b2039b1e8bf2e43aaf9d7dd59be224fd6022e20ff84223caaf8c0d9bd4d", + "python/sglang/srt/models/qwen3.py": "39c7c9c6b0107f12ac76cd2b6b54a0694c8540c1bb9588a380e05fcd3ee93e6b", + "python/sglang/srt/models/qwen3_5.py": "f7e52f647d8e3dd8c980ae170569585ee118c782df055b21b1e93bbc28b1f9e8", + "python/sglang/srt/models/qwen3_5_mtp.py": "f5e2440a6b16c65ea7768b38441283750692890300c39266025786f33d48f796", + "python/sglang/srt/models/qwen3_5_text.py": "b5e41ae9d90a3b0cef80a644335da66d385403bc5bd64eeb1d391a148bd3a8fc", + "python/sglang/srt/models/qwen3_asr.py": "f3b30fda98ac587f87ae4c2f414dc56ca2246867598e9c6ba3ea8a3db6076777", + "python/sglang/srt/models/qwen3_classification.py": "8eeb04172601531add9cc72c5a2ef7c5f370c443b3407fafd9af188e687aaf66", + "python/sglang/srt/models/qwen3_embedding.py": "863f53ed09e8d28e657212d9379191f9ce684c736a98f4a6d4d1b593c5cdb598", + "python/sglang/srt/models/qwen3_moe.py": "7c559324111dfdc6927e97d13e31d5ff7b23bf7efa4d4fa33d636c026212bb05", + "python/sglang/srt/models/qwen3_moe_mtp.py": "e795243b8af8bd75af56022af0be83d7b1be537d1a5659e372a34030e2339ebf", + "python/sglang/srt/models/qwen3_next.py": "a489dbe53eb6f5ad24f8b0dc04b65f1ef8a14cb4172f37de1a3df759a1f047e6", + "python/sglang/srt/models/qwen3_next_mtp.py": "143c6b62eeb23e1f2f79cb9c856540dfb40ae7f49a2695aa4698f3460cc34d8c", + "python/sglang/srt/models/qwen3_omni_moe.py": "ccb9850c1353f145ff31856b9307e9064f59024c2a7eee0a70338e986ab99a80", + "python/sglang/srt/models/qwen3_rm.py": "07a12c16cdab6a97ed7896aee9dfbfe746591816aece1ab4181ed1d5891a1166", + "python/sglang/srt/models/qwen3_vl.py": "f08159602498687df548797edc45849f84540c2a3d57bc3e1120665ccdb280cf", + "python/sglang/srt/models/qwen3_vl_moe.py": "48adc25f100392919f446ebd7e662b0d7fe7d13f85daa3b01cb694b79dd6e4c8", + "python/sglang/srt/models/qwen4_exp.py": "311375b089b05091bb1a99d95eeec238a03268381f491854322abf40e3f3328e", + "python/sglang/srt/models/qwen4_exp_mtp.py": "7597cbf46993768cee865c888fdb0ad3560f123ead707700d785f7ae0d28497c", + "python/sglang/srt/models/radio.py": "3e603a16807d9fb511e8ea463366cb685224dc0a7bd71c1bc2f8879db69e116a", + "python/sglang/srt/models/registry.py": "3c5b4e87c5943147c28cb5b68e187cdf8f8f9d880c42f1f6941fce99fe757e41", + "python/sglang/srt/models/roberta.py": "87994b2a22c88c1c5810581439159759d5ba6c9f2c90ac8558d9c4a9525706de", + "python/sglang/srt/models/sarashina2_vision.py": "b6f1f865bf94f6981caf19bfed4bab9e6af95dea34c57716607bae7080ec7a4b", + "python/sglang/srt/models/sarvam_moe.py": "d06ad53aa9283b7d2763eb9d5905f3ba7c26a0c2ea1e8ad9fb3cd7f6dd8eb267", + "python/sglang/srt/models/sdar.py": "fbec6b8ed653758a76aa75986c243267f0d7a6637a80508a7b94c0a9f963c72d", + "python/sglang/srt/models/sdar_moe.py": "07776e14b56972900c31921cc22c0e964a7c9a9af39dedb038920556ca8c45dc", + "python/sglang/srt/models/siglip.py": "722bac4d6dbe18f224a0931f5076c84aa41067adcd8211bed455f1b31d7976db", + "python/sglang/srt/models/siglip2.py": "bc81904cf0a746fc15932e73298bb6401ead827a2399924ee754013f68507c95", + "python/sglang/srt/models/solar.py": "b2ba46c5d1931bf11aeff6c31390934602be133a2defe7381ed6f69b0dd1fcca", + "python/sglang/srt/models/stablelm.py": "3b13b359144c799b2a2947906dcb199552783f91f5117d4a0ae6640060f04fdd", + "python/sglang/srt/models/starcoder2.py": "2fcaef42743aefd14ff44b8cf2ca7357aa4a69ea23e9ec9b2deb9b934ab5c461", + "python/sglang/srt/models/step3_vl.py": "a7b918d8cc89d0c1347d5553bd15738dcd0d7c79b726c2f4ecaa073bc5d486b4", + "python/sglang/srt/models/step3_vl_10b.py": "9654f28e13bb8fdafd157e603608fe4212f48c028b026cd08ccd6b90b8d22428", + "python/sglang/srt/models/step3p5.py": "dd201e0fe8eb0e833a325d37e3853eb25711ae78a8fccc71dd5a3089f5acf69c", + "python/sglang/srt/models/step3p5_mtp.py": "59403c590c52c69376f6b3b7997686f1bf60b24983cdaf8fb1cc0439f745094e", + "python/sglang/srt/models/step3p7.py": "814dff8fec4ed5e310ccfd3300a543d63f7620a6a084eed05126bd0c6cd99b42", + "python/sglang/srt/models/teleflm.py": "d5d2af97bc09d103cc8891a6c19863651a8247b2929f293db6e5bba2f953c2a5", + "python/sglang/srt/models/torch_native_llama.py": "5cb5a798c87fc2c546bb04fe9cffb0695dfe6b20ea22ab05d5340feede692248", + "python/sglang/srt/models/transformers.py": "cd06ceac5b96a81630770bf41cfd2244ca4384d6028fdc482fc0c81aa7abf3b5", + "python/sglang/srt/models/unlimited_ocr.py": "dc4605bf016db9a619353e7ae21a798571b9c565ab5652e20495ab66b1ca3e34", + "python/sglang/srt/models/utils.py": "7a05f7b446086ea6427b562b895355c1dd5b0b2b2563467d8daf11bcbfa979d1", + "python/sglang/srt/models/voxtral.py": "5a81bd2c2219aa791ac5d5a4a78c1969e9c678a3fec3282dc21fe526e026e4e3", + "python/sglang/srt/models/whisper.py": "3ca327482f0e6be78408da1b64a59018cce4f62741e713c38ddec0057232288d", + "python/sglang/srt/models/xverse.py": "f675d37ed6d32e7da68f35f6a59232082f03e173ddddd8b2942c7f06049de619", + "python/sglang/srt/models/xverse_moe.py": "f26cddaac7b663cd2b1605d1575e8f4ff0413b1ac3a1a68f460e39604f40806f", + "python/sglang/srt/models/yivl.py": "f329de6db7907d07267d44c261186801c580df2bb9022128f4a958716b0a42f5", + "python/sglang/srt/models/zaya.py": "e9aa7f2a13597df88c098267fed0fec664b4e4fb20de0d7520c785a3e4107f54", + "python/sglang/srt/multimodal/__init__.py": "1eccef4346506ea01312ea8f8cf5a37307704a53acccdca0e8c3e94c5f7e29ef", + "python/sglang/srt/multimodal/audio_from_video.py": "caaad30b5339ea5508a5a0a1ac688520b24a1d989f106a04d66d2b5cbfaebe77", + "python/sglang/srt/multimodal/cache/__init__.py": "c55ee6dd5cf2a2417cb9f8e1382fb3e6073f219398d495596e1b001970cda16f", + "python/sglang/srt/multimodal/cache/identity.py": "575e0c59c4c53f39e13e39d161a2378f5eb9e6f0c1843d7ef65c291e0c98aa8d", + "python/sglang/srt/multimodal/cache/preprocess_cache.py": "01b12a7b21c61539a3b5f62eb358e8278c8ecb5547d0f0cbe855c2290870d227", + "python/sglang/srt/multimodal/customized_mm_processor_utils.py": "288a2c31f8de0e69212ebbdf4814802959a877e4070f0a830e57a2916a7fd78c", + "python/sglang/srt/multimodal/encoder_preprocessing.py": "16ce42db23c82c43725633f58e9d462613f0b619409442ecc0ea1bd635eb7c3b", + "python/sglang/srt/multimodal/evs/README.md": "2639aff4833d067f6e109e383f9a63667cc5c118ae6eecd2cd0b5be6539b1b0e", + "python/sglang/srt/multimodal/evs/__init__.py": "d0a4e395f23d868ff513c20f7f5b76591a5232c461346cd1300c0b75130d1503", + "python/sglang/srt/multimodal/evs/evs_core.py": "a96d74c0d6d08b2d54301a2744037a9a2600c2ca0a199d32e2e69e6cd5094d18", + "python/sglang/srt/multimodal/evs/evs_module.py": "0ebd652748903794048e397310edc797779d60066dab18715146c34397632b35", + "python/sglang/srt/multimodal/evs/evs_processor.py": "aa39f0bdadc56b0bd8f20ea8a4a8408a05895ee6a4c82386025d45486622aa25", + "python/sglang/srt/multimodal/inkling/__init__.py": "2fbef5e7488f2f44f7db231f3de174a37af46d8d5d1585ac81e80052f94a8666", + "python/sglang/srt/multimodal/inkling/feature_extraction.py": "d1f14c50d2a0dddbeb2249c00b6fc1c118b05f65477a9000608d24b36939cd2e", + "python/sglang/srt/multimodal/inkling/image_processing.py": "bf11425a3eda1180ef585c0fd0b6461063c608ebe93540bac3a73273872af6bf", + "python/sglang/srt/multimodal/inkling/image_processing_rust.py": "ee81a8133042cf06d7e08b5d97bb55a3c84d7a2cf213b9a22cada27537e0b7dd", + "python/sglang/srt/multimodal/inkling/processing_inkling.py": "578be654ffe3f2ede5628e9254ed9484e028ada0294d5a9c8f692472cb66b01c", + "python/sglang/srt/multimodal/internvl_utils.py": "06fcd349896e1a3c1fd12ea0ee26801bd265e91602ff47c1c496ce226d479da5", + "python/sglang/srt/multimodal/internvl_vit_cuda_graph_runner.py": "45e7717c3e6356019761b528944e009debbbe88842364b98c74c18a26062a1e9", + "python/sglang/srt/multimodal/kimi_k3_image_processing.py": "5a87501834fd8b5189a11d8d2a6497de2a12baa47bba7775e5c3dd8bc3e2f9ca", + "python/sglang/srt/multimodal/kimi_k3_vit_cuda_graph_runner.py": "18d27ee23b87e2a06ffa1dfbfa46611a3ad414861f2d982e58d49287d4b2eb8d", + "python/sglang/srt/multimodal/media_artifacts/__init__.py": "37158f4df86b84d22c9582b631436603ccbdf94947fd8f86435588c70cb1346e", + "python/sglang/srt/multimodal/media_artifacts/base.py": "d07984b72280a6153a7e2ded8b4e392eec760485f75594fd17154bab1329d080", + "python/sglang/srt/multimodal/media_artifacts/kimi_k3.py": "196e633c6a437cc0bcf15bd4ee86316e5d0932a78d66453f7b920df494324187", + "python/sglang/srt/multimodal/mm_utils.py": "2cab2ecac1f3fcbb08377556d9480facdcc3c910f607fa3771eb6e3c6377102a", + "python/sglang/srt/multimodal/processors/base_processor.py": "1e5052235b0b76840949a597e2f2816e5dc296cbff45cdc218fdd9a3dfbdca9f", + "python/sglang/srt/multimodal/processors/clip.py": "9290a6464e0e36f48a868c6ea058cc85212b311edaad7b0ff0ba6aea59411a54", + "python/sglang/srt/multimodal/processors/cohere2_vision.py": "fe3863384d7e07e1bab7c78aadd927214013f28ceb288a2747b7acd77b35a6a3", + "python/sglang/srt/multimodal/processors/deepseek_ocr.py": "8acaac872069693f27de4dc84cab401673cc9276933acc1c106cffdd7960a358", + "python/sglang/srt/multimodal/processors/deepseek_vl_v2.py": "be8670c2929978d6f6c004fa46bcfb8f454dc2cd54124472289a9822ab6757a3", + "python/sglang/srt/multimodal/processors/dots_vlm.py": "faf20b27d660c150a785e861791b5047ffb232c2f977f871a75186234724632f", + "python/sglang/srt/multimodal/processors/ernie45_vl.py": "45086c502a488dc4ba3a3db9ba106d231dbd09a2cb31df902d5ce8a5d6620bbb", + "python/sglang/srt/multimodal/processors/executor.py": "b69d19801ea61a36f6359e3e4f5464d9eaa1de825368a2c1aaa36005098f63b2", + "python/sglang/srt/multimodal/processors/gemma3.py": "1c1bd5774eb7bb741013a1efa8eb994d2d8cd7c51382d87a6168e78e61ce1a1c", + "python/sglang/srt/multimodal/processors/gemma3n.py": "005baf0e4d790266376a59115a5512f8d6feb44c2feeaa403ceca62cef3e0852", + "python/sglang/srt/multimodal/processors/gemma4.py": "a3d8b0db8b7f34fcd0c42839b9c7d3ff38f439d702898542ff5c80c12a57cbed", + "python/sglang/srt/multimodal/processors/gemma4_unified.py": "0a4364a71bbacba534b89a390f41b1e3d07fd5096f57d2d192767d24e81cf4b4", + "python/sglang/srt/multimodal/processors/glm4v.py": "8b4198d2ec3de68e009db6d228d29064aacb8c782ade406225ce4f7f48f3e922", + "python/sglang/srt/multimodal/processors/glm_image.py": "fea5e9f805a25a77250bfebf2b5b0dde8458cfc986cb5ac39656fe4b72f751e4", + "python/sglang/srt/multimodal/processors/glmasr.py": "e08396780d66db0e8ce826b52f82d4f44029901c7d2ebb6bb19bad7ae4d4f8c2", + "python/sglang/srt/multimodal/processors/inkling.py": "d23c1d67fbd643d5be2390c2a1340a1d21bb64d3c3624b061ef8f01fda041fd2", + "python/sglang/srt/multimodal/processors/interns1pro.py": "018ff87350f60de410e7516a5e4b5895cdfab3547c2c6341a3f60070b76bf117", + "python/sglang/srt/multimodal/processors/internvl.py": "d28fd661ea772c46e9a735b2da3ee2363acddaa16bae989af3b821e066604cbd", + "python/sglang/srt/multimodal/processors/janus_pro.py": "427ac76c5f98fe58d1fce72b91b7ea63fd46a4ec7dcf4fc5c49e96bb643375cd", + "python/sglang/srt/multimodal/processors/kimi_common.py": "671ac50154f5e46bb32b2af758481bd3dba6fdaf8768510e35b2b1472cba4abc", + "python/sglang/srt/multimodal/processors/kimi_k25.py": "80b1805dcd7311f376922b01543e3dac45aa95050332cf21d08aa38e00fa777b", + "python/sglang/srt/multimodal/processors/kimi_k3.py": "94a6352f64cb68db103e750c57652b57b44c5d1cf2ea6e54c9f925c7d604b461", + "python/sglang/srt/multimodal/processors/kimi_vl.py": "1c61a58362af452cfff36347ff20c043c315f8bb3e0696255a87e1824c237766", + "python/sglang/srt/multimodal/processors/lfm2_vl.py": "dbc8bc147d77162b79daf4d0e722fe8e0bb3b208517a82439fbfcfc0232aea87", + "python/sglang/srt/multimodal/processors/lightonocr.py": "d0ef1de2d85ff3e6b982aa333dc8f3c7859853e4b13aafde972a0aeaf06882d3", + "python/sglang/srt/multimodal/processors/llava.py": "a1f37f13d7867077eeae165f6a4e3c7ee1b8b146fda871d857bcb3e517a7e541", + "python/sglang/srt/multimodal/processors/locate_anything.py": "4e721b8f8ccceef8be8aefe067568a988cd2a5efe7625975c8ce97aa3cbf8a39", + "python/sglang/srt/multimodal/processors/midashenglm.py": "80c4f6a6404a15816d43a177cf9abab6a864b61df01a2f91af7649b97f366a03", + "python/sglang/srt/multimodal/processors/mimo_audio.py": "2c2c5249581bd1a8d61c428f5612312eb7764e3eb8925f9af12a94c4d332eb9d", + "python/sglang/srt/multimodal/processors/mimo_v2.py": "6fa9682bae6abfb488cf4054b73c76f7d8274e0a3c363c88b79b17548a9524c1", + "python/sglang/srt/multimodal/processors/mimo_v2_asr.py": "927de6b375b1d0c8bf219eeacff1e90611e2811dd52643bc78ccda66b519e694", + "python/sglang/srt/multimodal/processors/minicpm.py": "e3214d38661e8eca56ddbe1e8716f4df2ea3505102d1e7c50f955dcd9bebc7ee", + "python/sglang/srt/multimodal/processors/minicpmv4_6.py": "cc482bbf6f04f75df155c8be405cea46f6fd0cd180f2337f5f282b7d5556d64c", + "python/sglang/srt/multimodal/processors/minimax_m3_vl.py": "60f3ec8ac933e4b71b32e29d181b5877efc3f1ea40bba241aa89479ad55baf5e", + "python/sglang/srt/multimodal/processors/mlama.py": "81ff37009499cc6bfbb3c2cf0ba5509ae15793df2ca4eb36e8183d31dff1936d", + "python/sglang/srt/multimodal/processors/mllama4.py": "4e80dbbe14923a3c35a6283da2224b7bac2f347a8066a899b7feae00c621b90d", + "python/sglang/srt/multimodal/processors/moss_vl.py": "f8f23bbd42433e03ff09cded52a91854ac6a12d753ee26febb4074f56360e717", + "python/sglang/srt/multimodal/processors/muse_glimmer.py": "81b4333f5a2eed02b0f2d08e13271d26601136c2d8fed87c706a9f50e6f2c183", + "python/sglang/srt/multimodal/processors/nano_nemotron_vl.py": "8d45178821fde4e89a3c806d7a51eb0d892f030266b76b9fb88f66d5c44faad3", + "python/sglang/srt/multimodal/processors/nvila.py": "3c547888a565af32a07930baf58d1011743daa42fcdd51aac93fc935279db9e4", + "python/sglang/srt/multimodal/processors/paddleocr_vlm.py": "247c86f9477bf3f1ec508420f6e83db94eeeef43e9382d77094b854782921d0b", + "python/sglang/srt/multimodal/processors/phi4mm.py": "21ff671e86b65be4dfbc773fcc361155489994fc9b6d5dbcd4d879c19cdaab70", + "python/sglang/srt/multimodal/processors/pixtral.py": "f243baa66854711bd4a31362948f04d2870356ee0fd8c3ef03a053c8f8222443", + "python/sglang/srt/multimodal/processors/points_v15_chat.py": "d52953daf4f65f65ecc9456b90b9d096268f7eed1410b95d3f5ca47e160734bd", + "python/sglang/srt/multimodal/processors/qwen3_asr.py": "c7417cf0d8630965cdf2205f7a3d9640dd46fee3973a4f232110dc23c5b25db8", + "python/sglang/srt/multimodal/processors/qwen_audio.py": "4eebd82bf5a87ca604944f666905a0d22a4ac04875d7c9c57cd066833d2006b9", + "python/sglang/srt/multimodal/processors/qwen_vl.py": "b47003e1f0840a057519adff46fc72a9318a61e2eb3ef8cedfa9eab19e98b7f7", + "python/sglang/srt/multimodal/processors/sarashina2_vision.py": "592770bfec1a2896be592e83e4d811a35b2bfe9ae419c91902231bb9dd374246", + "python/sglang/srt/multimodal/processors/step3_vl.py": "57f60588ace2767af58024d2fe6c3bf2502abc951570922b27651ac8207381a1", + "python/sglang/srt/multimodal/processors/transformers_auto.py": "843de5bd0abfabf30baa126613890bfdb3d383933e082ddf1d9a792b42a10bc6", + "python/sglang/srt/multimodal/processors/unlimited_ocr.py": "b612e75e69d269b0d4b75625180d89171cc9455e58d3ab9e066e77fa8c175519", + "python/sglang/srt/multimodal/processors/voxtral.py": "cc3d1f6a27a05fbd9724b02bfb89c42e3906e1fb5d663a1125c71ba4f24e8b29", + "python/sglang/srt/multimodal/processors/whisper.py": "6983b089e81e3bd685b8db376e5a4fb061ed26fc73fb4294fea55db834feb445", + "python/sglang/srt/multimodal/transport/__init__.py": "f5c373399f116778c70f2da906f7685469fd13099b83e5208025f81aa3808dbb", + "python/sglang/srt/multimodal/transport/cuda_ipc.py": "03bc109511d08628ab15ef13f78967dd463d1784d45ba98e088f5b7a5b97cb95", + "python/sglang/srt/multimodal/transport/memory_pool.py": "69cc93717a553d4e0201d3ca086c27d58ecd28236e320b6db234901bdd765852", + "python/sglang/srt/multimodal/vit_cuda_graph_runner.py": "27d0131857e172992afadec1672888bb7d4b48befc3e6c10c4bbf38ed0f37d33", + "python/sglang/srt/multiplex/multiplexing_mixin.py": "a4b50c50a4c0b7b5cae39e9f5f0a6f36e6fe57ae6bc68e4518bcf1fd0ed0d51e", + "python/sglang/srt/multiplex/pdmux_context.py": "b4e6ff1aa10a19f9cdd285088424b9388574fd291edfd466e155cbaa8e876b9e", + "python/sglang/srt/observability/cpu_monitor.py": "61ee5b561c432abe4e3a86dd0a09715c82d79dbab7781e0568615bf34d65aec1", + "python/sglang/srt/observability/forward_pass_metrics.py": "197783e4f501a3651a0bfe376eda29f35cd4a7bf18b6e7b9eebf094ff285f5da", + "python/sglang/srt/observability/func_timer.py": "5bac9017a6dbc69468d3a9706bb91e5901d1a1b788e8b2ab2d836f8a8fccd179", + "python/sglang/srt/observability/label_transform.py": "3be373d06e95723d5a31486c3866fc32467bf25f0bba59d86f35c685770e05e5", + "python/sglang/srt/observability/metrics_collector.py": "9b2469b149e58d6e427dfafe82af073e61e04c825ff7d2b5dec138fd77b5c134", + "python/sglang/srt/observability/mooncake_trace.py": "1538cab22cf2573f93e1559132746508377aa8832029f9ba9fda7a565fe39385", + "python/sglang/srt/observability/ray_wrappers.py": "c04b308075ebe1637cdd514181a4e0da96e7c5b602f5a62e41d6612f570a2864", + "python/sglang/srt/observability/req_time_stats.py": "3a32af2aafbb95366a12aa6b01fa8d0c1b973f0188019ea623c69c7d285ed46f", + "python/sglang/srt/observability/request_metrics_exporter.py": "7ca23d47a1ba8ca0eed97f15354ffdd1a10cc93341588b78cc3dd74d07dc61fa", + "python/sglang/srt/observability/startup_func_log_and_timer.py": "3d1560dd9d9de4604c1627d95d1f9587319c9fd9e629392a114e3554929999a2", + "python/sglang/srt/observability/startup_time.py": "930118e13fd1ceeaf4dd78a31533eff4a474bf63bd5e53a7958933431d49e87a", + "python/sglang/srt/observability/trace.py": "c28d12b5dcfb88bfa488886c78740e6bef39047c146684a916f2889b4b859796", + "python/sglang/srt/observability/trace_async.py": "1208ed781ed1b00c9bdadd382fc99999ecd35d69131a23d3b71af406947893c3", + "python/sglang/srt/observability/utils.py": "797ed7c3ab8785bc0d8b783bbdd70420a3363a9fb473e7a6642583fb8ea16680", + "python/sglang/srt/parser/code_completion_parser.py": "22b62a8c0ead66e61f16dcdb10e1887cd3168c67318337e1e09d30f893f27457", + "python/sglang/srt/parser/conversation.py": "21b48ce77bc36f84ae30685686f53d7acfbc97a1dd5e4176da5f505665229df5", + "python/sglang/srt/parser/harmony_parser.py": "630786e1acd69b98e6cd819a00711749a391a6059cb4fa5219093f8e9e47f821", + "python/sglang/srt/parser/inkling_renderer.py": "257424c8f88a90e281b5db0427ffff3bf32aedb6f1ee4efef55d2a26abaacfa9", + "python/sglang/srt/parser/inkling_tokenizer.py": "8c3a9f8d0c05434a44902155da14bc1bd54ce22837fb7b7bc3848f2da3067120", + "python/sglang/srt/parser/jinja_template_utils.py": "27759425d3b5856095de117e1c431645d4e61e548cec3517be8f237cf0de65be", + "python/sglang/srt/parser/reasoning_parser.py": "42e798ba0ce6db8db876c576f45e40787194b15251829f2879f311e5f9427ce2", + "python/sglang/srt/parser/template_detection.py": "b81f86f61ea56619bca67ad1c37d9dc84f5a6369f36e3365f0ac135b064e9a86", + "python/sglang/srt/parser/template_manager.py": "2c7de852332f68d9ca5e535f42633372aa86e5bd69406ec8a102f43b17855b32", + "python/sglang/srt/platforms/__init__.py": "2430f325fb54aa6a1265c64149e01929140e841f450f52536b344fa1c51a7ffe", + "python/sglang/srt/platforms/cpu.py": "3e3282b95d4d817bde3a4194f2189b15b6ff4523e92c1c64e14d4fb24631d84e", + "python/sglang/srt/platforms/cuda.py": "fa43e9386319d9f410cc9a9eae4af804df949eaa1d6bcde98b184f7912e32845", + "python/sglang/srt/platforms/device_mixin.py": "1956853a6cb6ff390d525d6b4e13141d7fb04360f1257ba858744fb911b64238", + "python/sglang/srt/platforms/interface.py": "9612ea0d8a40bddc7b4f36c6965352b5d76e051638b07f2551a4f703f8681a33", + "python/sglang/srt/platforms/rocm.py": "36dd7d7330e72c2dad9666c1cef97cfd92eb38545e537184cec598b5a7b90831", + "python/sglang/srt/platforms/xpu.py": "dabb92273bc96592db184ee5e3a11094b228b293b71f8b99739d6ee4d357f636", + "python/sglang/srt/plugins/__init__.py": "3a975a73f1a7887e68c81ea7a2530250597ac8ae978efc0b0f70f038a99a3164", + "python/sglang/srt/plugins/hook_registry.py": "fe214acac324cb2f019aa1dffe1ddcb6e4691862fdd1b6a0ad5033d8167e31e9", + "python/sglang/srt/ray/__init__.py": "36fc3f0c2bb9d10de55553dc6c8e67fa2ca3e3ee4984998b1201750581b4666d", + "python/sglang/srt/ray/data_parallel_controller.py": "c510f5d6bef02376d2e6f9069f25d4c6bb704235a04f073e5206ca356bc3f301", + "python/sglang/srt/ray/engine.py": "d324c2fdfb693b3f2e5628e874ad734e20ba8bd5c5b2c8555376c7c6b9c42eda", + "python/sglang/srt/ray/http_server.py": "616b9eadc53220fc2afef31af5de5891f83f3a11ad557f210a402a3153933b95", + "python/sglang/srt/ray/scheduler_actor.py": "14c1e413098f3d808c21e81082fca3fc5f2cf210c0a2c71d6eaa801eca73c4c8", + "python/sglang/srt/runtime_context.py": "f2ddc424afdf1d3710958c553586954fc3e4399919c4473c442a865c0252545d", + "python/sglang/srt/rust_extensions/__init__.py": "0add2045c132d39d0ef7eebb016156c708223ddee6f2eb6fe514f762e8237606", + "python/sglang/srt/rust_extensions/_grpc.cpython-312-x86_64-linux-gnu.so": "1f444161d000dc5c33629181d6ce0cb0993cf4471147501e8d84d78f94c2bfbe", + "python/sglang/srt/rust_extensions/_multimodal.cpython-312-x86_64-linux-gnu.so": "db9e82757193be696867d27e1549ed072f032d3b582028b135316f0d9363d4a6", + "python/sglang/srt/rust_extensions/_server.cpython-312-x86_64-linux-gnu.so": "d7d796f29c6336a69f3e7b544f2fb02583d66350a167a9c19e610c71b374dce0", + "python/sglang/srt/rust_extensions/loader.py": "0a6408b69ba1f9107eb92f207d3949672480c5fc80ce7e7c90c0752bfed0a642", + "python/sglang/srt/sampling/custom_logit_processor.py": "e0e0ab65e2ded8975a9d161a52c92cb61f2a8a02a6af485b37912cad1171e23d", + "python/sglang/srt/sampling/penaltylib/__init__.py": "75ad2cf0aabb156ec1aecffdeb906058f2fbf5669d258fefc420e50a27b0c7ba", + "python/sglang/srt/sampling/penaltylib/frequency_penalty.py": "1f17d9124d963bdc428016f856a1715743b3d803cf55de2e8fad41550e5d8a61", + "python/sglang/srt/sampling/penaltylib/min_new_tokens.py": "96e372550b022ba0bbba853f3c95966e2f0d3b7b799ac0f4082df58198befe97", + "python/sglang/srt/sampling/penaltylib/orchestrator.py": "829be20bdfad1d6f92c9eb830f320602a92203ebbf692c7d92a325bfdc0dd2a9", + "python/sglang/srt/sampling/penaltylib/presence_penalty.py": "f9f5d234903c1084b49905521b8e0ce9cc35a22d1c3e4c047c0cb4d189c291d7", + "python/sglang/srt/sampling/penaltylib/repetition_penalty.py": "4f5948005615eacae25ae3f606699d1322e376a3bd4d2f54dc422be6a73bf157", + "python/sglang/srt/sampling/sampling_batch_info.py": "05f88297e6ca48aa187d0585dcd212c89b2918f61e1020879cd4537bc9768889", + "python/sglang/srt/sampling/sampling_params.py": "9437125033cd7abe001689cef162ba558454fb455f577e7b36b4eaa4d3f95c24", + "python/sglang/srt/server_args.py": "557d26f31c473e0cd382efce9ed2bfe8702b5ad0adc750da1250df13bb3231ef", + "python/sglang/srt/server_args_config_parser.py": "3966b1206230239aa81def9fd0008d0eab68e5ce11b7bc39f369f5570287a1e6", + "python/sglang/srt/session/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/session/session_controller.py": "ceb4398ecf4fb24c10d8256797aca06db1c353dfa2acd9577e46f01ea1093ccb", + "python/sglang/srt/session/streaming_session.py": "1243ecf5ef521d9a9e9d9bea1bddd519400826a3fe16e5073cd3cb95f5acadb3", + "python/sglang/srt/speculative/adaptive_runtime_state.py": "d4e0b6bb5a3f83f6b6eaf298e08424816ef463b5f0a7a0406fa066cfd3122496", + "python/sglang/srt/speculative/adaptive_spec_params.py": "ccf74d364972786f4debc95f8da1315313b904f5ae9389c4ed1570642dcf4de7", + "python/sglang/srt/speculative/base_spec_worker.py": "214eb3b4e19ca39438d010066cc21b15c083b656a75a5322a7b0c9ef7dc87745", + "python/sglang/srt/speculative/cpp_ngram/.clang-format": "1df5c7d8812e21f15b1bebf09f61e40fcd3887678496a4f8005e9742bd55730d", + "python/sglang/srt/speculative/cpp_ngram/external_corpus.py": "1de174578c7791bec10666f1ed8df525f1f95125f25bc0a78e81e5e54dd229d2", + "python/sglang/srt/speculative/cpp_ngram/ngram_corpus.py": "bb3fef5b318f74bb8bde9eb8917ea01c222739c017bd2509bf2ecb7621cff605", + "python/sglang/srt/speculative/decoupled_spec_io.py": "e4e0951b45d720538c26784b9dd05817f0a9e76d748cecb3efdf9a6d1acbdff5", + "python/sglang/srt/speculative/dflash_info.py": "8b11954327d01955478d97cf36c514f39ca9457d37941a2be561d03a27391a1a", + "python/sglang/srt/speculative/dflash_info_v2.py": "2cc95adae184717c208e9c7f42ae5a08e81c9d4b94c907a020d5cc249c05b1fc", + "python/sglang/srt/speculative/dflash_utils.py": "a508ee114d939aa235e405e21d8b40bf3112f4534c1e3c34f7e591fbd5ed5f04", + "python/sglang/srt/speculative/dflash_worker_v2.py": "99a606e7b5e16747237a7278ef8af74317ddd28a7d08a6030fc1e34ac9e2e575", + "python/sglang/srt/speculative/draft_utils.py": "0f9981d20765169518c5031d92de81830ebfbed8256a1ad82c7f8edfb6bc7284", + "python/sglang/srt/speculative/draft_worker_common.py": "72256f9cf886248e1414339b8288340ebfdb86ab458afc13b439a42ba2dffdba", + "python/sglang/srt/speculative/dspark_components/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/speculative/dspark_components/dspark_block_accept_estimator.py": "cb475d64d5d10329ba4aca51a64ab9ff925e17dd573ca42d13be139f3be2004c", + "python/sglang/srt/speculative/dspark_components/dspark_config.py": "a4aa2d41bd4144024afadbc720ed712f24ec34b6b95732bd5e43abe3f0d8ea7c", + "python/sglang/srt/speculative/dspark_components/dspark_draft.py": "0c3dd5e26135d59f2eb9a94aa92d80da51ece28d95d9f80b2c6e9b2171a70200", + "python/sglang/srt/speculative/dspark_components/dspark_draft_sampler.py": "d00aa4a01c85b2f09b30582ddf94c3447cf3e213be3cc979d73c52ad9d5cdd32", + "python/sglang/srt/speculative/dspark_components/dspark_kv_inject.py": "74a8ea9e90211b45fa24ad5a0d28c116839a87c59644de42e3636b6e665dae95", + "python/sglang/srt/speculative/dspark_components/dspark_observability.py": "19d885307d7eb8c5c686a4e568f8a4817f8aa7128ea7e0febf6032c35517833d", + "python/sglang/srt/speculative/dspark_components/dspark_planner.py": "2986adb17dccd7ff35c0374b10ca9c3ec5829d77711d30cd364d3371e4e64443", + "python/sglang/srt/speculative/dspark_components/dspark_sps.py": "c87a7f72ad1299cbb9bb337e0ffc3bb34de2c02624e423c717c41fc41c73ee08", + "python/sglang/srt/speculative/dspark_components/dspark_sts.py": "49b0ebd5fdee14dcbb527b24d6d682d8c9e27de769e87552cbed1bc7942bd06a", + "python/sglang/srt/speculative/dspark_components/dspark_verify.py": "9f98e504eea440ab12e0f81b8301d3489992311dc65981018fc6dedabe9f604b", + "python/sglang/srt/speculative/dspark_components/dspark_worker_v2.py": "f2aceff3a360d25f55df5b87ec77d503b3aacad2bd479235a2ffd15e2fdf3425", + "python/sglang/srt/speculative/dspark_disaggregation.py": "b93b797dd537696f957fdb8fcc2ab66435d184906871beb0ce8fb2a71f31f840", + "python/sglang/srt/speculative/eagle_disaggregation.py": "8b035325c40b2c6a430df2824f6b2f4e181ba6f1556922c59c7e4ee4b47b18c4", + "python/sglang/srt/speculative/eagle_draft_cuda_graph_runner.py": "9cafd331bebca55e67d4156d3da698fe0e728e22d48fea57b2cf1babcb9e6376", + "python/sglang/srt/speculative/eagle_draft_extend_cuda_graph_runner.py": "437d3d7090ae8f5fa0f84dbb61de071b64afa65fd088be8844e542aca3649dbe", + "python/sglang/srt/speculative/eagle_info.py": "a4f2f663db7e26dcbdf4b8b08788492f04d7c6f26546a7abadfce739b9854638", + "python/sglang/srt/speculative/eagle_utils.py": "87e9dc749e94f5899140457393389397840a2258978c021fd3ac490e9da4c053", + "python/sglang/srt/speculative/eagle_worker_common.py": "7d5bc17da41ad34230dfd76da34024496983eae5453f8b1c650a9f5f924e4934", + "python/sglang/srt/speculative/eagle_worker_v2.py": "9a66d31868385646b9fb9f78053730f55d2e885e72382a8c8dc6db9f07709271", + "python/sglang/srt/speculative/external_corpus_manager.py": "6ba215fd34397ab487aa7331ae8fb157a7a084b83fe6554eddf9468a302a5287", + "python/sglang/srt/speculative/frozen_kv_mtp_cuda_graph_runner.py": "bf74eac380ab19726f34c0d568dd6aa61ad5535da759390de3f05906e8acd01c", + "python/sglang/srt/speculative/frozen_kv_mtp_info.py": "5e5b944d39a2eac1836c9bf835c5fb588ba729d1af5a77fcea52d5367f8c267c", + "python/sglang/srt/speculative/frozen_kv_mtp_utils.py": "ef46e173c4deefc85efc74b436a381479b6dfb73648fc62a6c5630604c7f8bf6", + "python/sglang/srt/speculative/frozen_kv_mtp_worker_v2.py": "f98aebcfe52c72d0becedebbf5d36596aa40b22f82bcdec2157f0599042c02f9", + "python/sglang/srt/speculative/multi_layer_eagle_draft_extend_cuda_graph_runner.py": "1ace015e04fa6706170b16967e7b7f8850397aaed481f1595bb9e8e522479515", + "python/sglang/srt/speculative/multi_layer_eagle_utils.py": "b3236abbb4b52d39fc6ff3a111ce1aad7d2f1f4d7a064271150b73a08a41f264", + "python/sglang/srt/speculative/multi_layer_eagle_worker_v2.py": "ade61a47a47d58add7884305940281ca42dd2fdbadec219d5d14d46c64a0b640", + "python/sglang/srt/speculative/ngram_info.py": "4b8886e17ca55bba9b6706ae025eed45fae307cf42a5e98e26a08c0b7313e25d", + "python/sglang/srt/speculative/ngram_worker.py": "c042a1611193b977cb9e21297589facc57bc026600e57a7abcb4d483df860172", + "python/sglang/srt/speculative/ragged_verify.py": "5226da18ce2fd3e21ef32863ee4971f70c8c82ac6b6369d58b87f1eeca1ddded", + "python/sglang/srt/speculative/spec_info.py": "f5b9ae4b4612fdb816985c54740b5791cc8cfc096389777b6fbcc2194a63b568", + "python/sglang/srt/speculative/spec_registry.py": "1242e3fa12bd64cd3aa88efeed2cb8db2962a948c2eec047d4ba423f2b7096cd", + "python/sglang/srt/speculative/spec_utils.py": "09c51c9462b99b55f588a0adc16dda2673d64b5bed8c3dcf68e15cefced98473", + "python/sglang/srt/speculative/standalone_worker_v2.py": "1f8ee2c3e6f3d071901f9774c0a90e60acad2742682d55c4fe74b1723b35465e", + "python/sglang/srt/state_capturer/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/srt/state_capturer/base.py": "b3dde776672ba7ac6f79ea1afcd4d482c04b3544a7e29cd05fac2aeed2ef0798", + "python/sglang/srt/state_capturer/indexer_topk.py": "5f4d0275cc07720fd62365d18c403a9a0d0aefba4cd0f41a87718ebbe98d1f79", + "python/sglang/srt/state_capturer/routed_experts.py": "08da734ff1b792236663b62833a0f33fa096de48ede12326d70a593e518c5e47", + "python/sglang/srt/tokenizer/tiktoken_tokenizer.py": "6a2147ecc62b0860780ba9ccacc55ef0a93f50a282fdacf0c5661b4fac15ef8b", + "python/sglang/srt/utils/__init__.py": "ceea07a199caadc8b0172d756baa7951af26614ebb41423fd3d2f449f123a5ea", + "python/sglang/srt/utils/aio_rwlock.py": "db32ca27e0d7ca53859a17c65464dddef6420f8dd971d9659f7671ce9f88cf6c", + "python/sglang/srt/utils/aiter.py": "83a040078acd0bf41fc4e4e89e4d39e698b5cda00bf0d44897e4810c47a87425", + "python/sglang/srt/utils/async_probe.py": "fe654a2186fdb6c2974425b4946fdc82dc53194fc19339eb87cd3ab4b895d417", + "python/sglang/srt/utils/auth.py": "016734a0263cbc2bd6657481ab11535f1cac073efb7eed4bcdbf66f81dfd3ef7", + "python/sglang/srt/utils/bench_utils.py": "323c12e868d0fd850b5d33f07322b3244c8ce6f0db18f96a3d423d4731dccfb3", + "python/sglang/srt/utils/common.py": "daa9e93e9d4aee0990560eeec60ac236757112613f7dd17b805d641c2d947072", + "python/sglang/srt/utils/cuda_ipc_transport_utils.py": "2c6a043be16879ec351ae1e803c303413315eee61125d1af1391736c182d1348", + "python/sglang/srt/utils/cuda_vmm_transport_utils.py": "a2322085fde9e9183cbbd73cae5c78eeffadd09dd846aacb83284924e49fa4ef", + "python/sglang/srt/utils/cudacore_pyspy_dump_utils.py": "5ed36362bf994a75c0f23db2a40d58a9df3ff8c731853d4c8c5823f43812c427", + "python/sglang/srt/utils/custom_op.py": "ffe4447fe63be8cc9abb47d8e277ba128e7d3d2368b05378529845caccb8f135", + "python/sglang/srt/utils/device_timer.py": "e9fea4957d945e67a1e6eef31edb9ea6a178558aff721b55bdbf32a01549b2d8", + "python/sglang/srt/utils/field_validators.py": "98ebb92fbcdbdaaac5733e10eb2cbe3cc74f370092003c8f62beba3ba46b01a5", + "python/sglang/srt/utils/flatten.py": "3a62ae210a13ca536b1f5381c4de0a7f631dbedccfc8c57f4e7d86360f7baa77", + "python/sglang/srt/utils/gauge_histogram.py": "8ab119aaf7e1c5ae497948ac51d6656e5676e4659edd410c5e940b5ed68e21db", + "python/sglang/srt/utils/hf_transformers/__init__.py": "bd270b1977cdd6e52932b7d06397f925f30887713b490357e550b52e2c9478b0", + "python/sglang/srt/utils/hf_transformers/common.py": "b65aeed19332be514a0af226d7c3c002dc20e411d2fe04f58e480bc358325738", + "python/sglang/srt/utils/hf_transformers/config.py": "c87fa91cdc8dd7e0fcd6093c751d4a5a24bfb2e895480d8b83f2b109bb92265f", + "python/sglang/srt/utils/hf_transformers/gguf_native.py": "67a1976c796179a9da0e071b14de52c7d5ec3d2fa37437152662d3a7e2cf0c0a", + "python/sglang/srt/utils/hf_transformers/mistral_utils.py": "27b383c40e9e07abb1ee60c6d080eb18f0dab8b6770b5ee9f32d1de255b83932", + "python/sglang/srt/utils/hf_transformers/processor.py": "975f78a291e9a3dc12c2848789d088b5298b419e9eab8b53d0dde3b233322ad5", + "python/sglang/srt/utils/hf_transformers/tokenizer.py": "1150719b60247ea837f4a4035688462625c55c003eca487c2f56a0afa0884e6a", + "python/sglang/srt/utils/hf_transformers_patches.py": "75656fa6d4eae5f57b9be09a153178f319cf0be78843f721ea15f3b1157282a4", + "python/sglang/srt/utils/hf_transformers_utils.py": "7936a23e92f552e8c854af19134a8e19d512998cf8d1c897fe56b30af6751f78", + "python/sglang/srt/utils/host_shared_memory.py": "d2d3b7a8c95b98422cd755ef748ec107402d1f8679866f6f584904c9abb8be53", + "python/sglang/srt/utils/http_middleware_patch.py": "8aea067707a600bf8c38b1778c6468c480e4b9890b53110f4f2a171e8b20ed6b", + "python/sglang/srt/utils/invariants.py": "05a8c4a2a7b5aa57e9099c177000b026b84f3916f2c3f0fec51ed0aefdb5d928", + "python/sglang/srt/utils/json_response.py": "779bbfd1a53433fd3f82cb5eb73839c7178b42c53a5fc393f13670d53cf77cb6", + "python/sglang/srt/utils/log_utils.py": "aa0c540a2c171c54412ab07655705fd057feeef9c45e67b0fc5f30dcedb066f7", + "python/sglang/srt/utils/model_file_verifier.py": "1ea58843dbf5d688ac870d79d8c9e1abbd5a4da6292b291793d1c148e41c42b7", + "python/sglang/srt/utils/msgspec_utils.py": "488b2a3fd0bb582d6a89c7fee668a0fc0731b8447b013b6998cd510f0dc2f1ff", + "python/sglang/srt/utils/multi_stream_utils.py": "bc0c190113d146dcdcd4d977b3c450955b62ba1a03cdb018b1584d6f2f06172f", + "python/sglang/srt/utils/network.py": "e5fa85f769b8d4cdfaddebf8944e4a1bdb92f11a8e2cdf62d2af58ba56906ae1", + "python/sglang/srt/utils/numa_utils.py": "33dbebb26f5fe420b31eda14a7f041d52fa9fb4469df7f727a42f57f08fe9f01", + "python/sglang/srt/utils/nvjpeg_decoder.py": "54b918dd2d892877dfabd7f5ef6e902eb8181e1967121597bf4b89bf2f1d1791", + "python/sglang/srt/utils/nvtx_pytorch_hooks.py": "ba2bfbfb3d6c0c4bb1a9886b2bcf846c27fc79fb1da6ae4f1607da1a07875152", + "python/sglang/srt/utils/nvtx_utils.py": "c97d6b542d463f37b54c6e983b0d6ac40ca57f0402b17584ea35103339fd5775", + "python/sglang/srt/utils/offloader.py": "1d89240584d56990174e22f31f1dd89d8585075607e14f6491a943dbd44aabed", + "python/sglang/srt/utils/patch_tokenizer.py": "97ea6b88e3a53d620b145cdff4ca2f6c217b390898fd122154813474290f02cc", + "python/sglang/srt/utils/patch_torch.py": "642b5369a7e0d09e8976e7b118bfedc574d43046170be5beff2a270834309c71", + "python/sglang/srt/utils/phase_checker.py": "0cf1b7fe0dc1145a65b88cad304a190e43f5f06767b0bb5fa13b879da275468b", + "python/sglang/srt/utils/poll_based_barrier.py": "f6f8e7df644e952b9e124ec4b998d6294aeb2fb5d547d289b125658864d807fe", + "python/sglang/srt/utils/profile_merger.py": "6ef9f3fb21cc6fbcc713506fd3d24a802818658d67e21fd42bb5b3db03409aba", + "python/sglang/srt/utils/profile_utils.py": "6ad8067398af3bf3314c375e0bb4a6703e2270043cd455cb531467f96a04eaae", + "python/sglang/srt/utils/request_logger.py": "ef9551a9b941102c59a8f4959bea2a2385898561a732728b6c846e4b6e0b5778", + "python/sglang/srt/utils/rpd_utils.py": "051f87f26cecf4a603a7c72b7c87b3a5de9510d16514b20edb316aa7f193e5c9", + "python/sglang/srt/utils/runai_utils.py": "fa0f6349a489b86ff61b7ab976ee583616e8e65b60b12cbe540b719d2522a2c8", + "python/sglang/srt/utils/scheduler_status_logger.py": "c3c31b7ad76a8041f2dd790b06cc458c621dee70cc9598e264825d236a36a071", + "python/sglang/srt/utils/slow_rank_detector.py": "f35f8a5e9df7c1ebe4e231b642e4e1b1cd7b7cb76675e328bb1c157d25ec7227", + "python/sglang/srt/utils/stale_shm_cleanup.py": "7a9047c6108ac87db752d947ec632d00f5be433b9b51cbf57178959a4b2c1896", + "python/sglang/srt/utils/tensor_bridge.py": "e2928916f851d0ea70110753a6d385c40bf9b3e904e1787aad4d65d3efc9fd14", + "python/sglang/srt/utils/token_sequence_matcher.py": "392c9c96d5832a1c1ea1b05b30cc4a0cd94151f919d30cf589e75fd858c386c9", + "python/sglang/srt/utils/torch_memory_saver_adapter.py": "196266b5ac6c7a805b36c9953fcdd9cafb0dcc3ac7a9e25aae6edf34a8c6fba9", + "python/sglang/srt/utils/torch_npu_patch_utils.py": "dc2a5d7bc2f3ed09df93bcac3159016b0884fee42693c6f70d6c7a24b1b66a0e", + "python/sglang/srt/utils/triton_load_watch.py": "f1d5ba3b5d61173e475885bade2dfe18ab2d73d7875797ccb5e62d0ebceba8f5", + "python/sglang/srt/utils/video_decoder.py": "c797bc40320a0485736c5f44df2dc1745e925ca2dce5e4eac4ca5375b9baff16", + "python/sglang/srt/utils/watchdog.py": "79a9f3b5b8a9942692ad1dfec0f8371ffb8cd5712f952cc23beee0ddc2917da1", + "python/sglang/srt/utils/weight_checker.py": "6829692cf99225a184062b1e35970ee35020621694e499829422b2a5d09c9e38", + "python/sglang/srt/utils/weight_checker_comparator.py": "78cecbe9a63036622217c1e029093ed58e8d9f6725f8a7e00cfb4029d3af0dcc", + "python/sglang/srt/weight_cache/__init__.py": "d42c3173b6fdb66de79e399d0cb85cce6d4006eff5812ea17d4c853160a1c1e1", + "python/sglang/srt/weight_cache/daemon.py": "d27b31e30c5acd81604fc245c748ba5d175ab0b2ccf0da5fc2bc5c3e7576182b", + "python/sglang/srt/weight_cache/ipc_loader.py": "a916a9d33fb9a02abe3693575473223497aac418d4718fb84e86396388ebeacc", + "python/sglang/srt/weight_cache/protocol.py": "e687631db8e443a5da97b1d6c05ab6a1cadc84e327a6c4c4fb1ea3080befde96", + "python/sglang/srt/weight_sync/tensor_bucket.py": "fc50064ea51c338262394ff0b7a849100e7c46761099e27a4478e9db0ea08cc2", + "python/sglang/srt/weight_sync/utils.py": "94c4747ddca2450dc55e6b2d58842cfd288a869d67c7e6c28beaf398562154ec", + "python/sglang/test/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/accuracy_test_runner.py": "53f692a81406c5df403bb96529767d4a0557b3df4201e317128d43798f80b9eb", + "python/sglang/test/ascend/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/ascend/disaggregation_utils.py": "5de7e9a90b9b0303b23c43499b600b40beb9208318888dab649aecce262eba2c", + "python/sglang/test/ascend/e2e/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/ascend/e2e/gen_dataset_fixed_len.py": "4da5d2a09d12ffce67b97a78bc87a4990d1a5085493c7f091b495d638c942006", + "python/sglang/test/ascend/e2e/k8s_multi_pd_mix.yaml.jinja2": "d84d1fdf00ee743294f511f62ce42665805c407a65897d19f555285d0ab223b4", + "python/sglang/test/ascend/e2e/k8s_multi_pd_mix_green.yaml.jinja2": "ccab6413054a14af98bd94a24e854de8a164d6c354d84afe62f4e055e75038e8", + "python/sglang/test/ascend/e2e/k8s_multi_pd_separation.yaml.jinja2": "21b606b5cd01d8f6c37529dcb4f0269a86abd7b451eba30719d598cdb7aa5118", + "python/sglang/test/ascend/e2e/k8s_multi_pd_separation_green.yaml.jinja2": "ce53a0d0f2318191cd59fca1c2f1e67c760d3e22d8a5c8c5db4cbde56e972cb9", + "python/sglang/test/ascend/e2e/k8s_single.yaml.jinja2": "0d624a88575d7c1b30502c8487545c5e7773df176151a451e058ed806cd1e516", + "python/sglang/test/ascend/e2e/run_evalscope.sh": "67ef6e317cc0d604a4a0b4a25da4ef4a09ecfe74bb4a2156fa6075e67393a32c", + "python/sglang/test/ascend/e2e/run_npu_e2e_test.py": "574e0e3577a4a5fc35186fd1c827cac30127b793a9b8c9a4502d92b6b8d13cd0", + "python/sglang/test/ascend/e2e/run_npu_testcase.sh": "5e7ee45cee29b04ca2cd5bc4366e5443df5276e38ed351ead0aefcfd631c0090", + "python/sglang/test/ascend/e2e/test_npu_accuracy_utils.py": "04c89c28cc112eba7cf2aafa7d5d4c7026fa7a4fb8d6e37adde1865e5134a6d3", + "python/sglang/test/ascend/e2e/test_npu_multi_node_utils.py": "5888991bbba44bae42d9dbed8b809b6cb217cafe70fba84edf5184c47edd6476", + "python/sglang/test/ascend/e2e/test_npu_performance_utils.py": "78cdff791ba3bfd4400c14eb47384b9b9887f478ab1c09cb669323d7b5316cbb", + "python/sglang/test/ascend/gsm8k_ascend_mixin.py": "312df800a466752899f879f82b20067fde73097ac8294dca5eb982c1c4fd6f4e", + "python/sglang/test/ascend/npu_eval_accuracy_kit.py": "b17ca43f03d1968d70a76cf331c318118fd47e50f3f7d57f148cf45754828266", + "python/sglang/test/ascend/output_capturer.py": "cab2cad35280e6f8886665dade4faec04dfd55a5d6d34735f4021df9d5d78993", + "python/sglang/test/ascend/run_eval.py": "4fdbe4d42dc329c365fe0b512770b4191f9aed4432a6875b5e0b71c86d2cba04", + "python/sglang/test/ascend/simple_eval_mmlu.py": "38ef544ff8e6705a34fd5e90400452ba0483854ff076af1f543694c80fc836d8", + "python/sglang/test/ascend/test_ascend_utils.py": "6b3af0a9658298f9e507c962459e54a4b79226f3ff84169d2c5092db4da6c08f", + "python/sglang/test/ascend/test_embedding_base.py": "c28e5cfd4e85d43729deebb929ecb6c6875a543ccc4c8667eb5a09226a4e1530", + "python/sglang/test/ascend/test_mmlu.py": "7af841a8cd68a32d8155d2b1f653e11805d5a77e45e9790e6346d1749730d4d0", + "python/sglang/test/ascend/test_no_hf_reward_base.py": "7bc043e499b999f5376b15119176571e6a7b14ad89a67ba9f6b7b7dbca695884", + "python/sglang/test/ascend/test_npu_logging.py": "b501b946dc4fad0db29d0cf5c88955fdc0c583ae9a35be43b3b18be7b2210eae", + "python/sglang/test/ascend/vlm_utils.py": "fa6742865d00e73c7a529a00389aeed12ac3b45a9dded733f25d9167025866ca", + "python/sglang/test/cache_consistency_jitter.py": "a0fd9e0aa0efdcfefb1aa693952af263710f7f241f483aa76aa0650909691d99", + "python/sglang/test/chunked_prefill_test_utils.py": "73d47ef760ad9781374e4c1a89d52cd5fcb56013d61d76d0ec874051cc04d61b", + "python/sglang/test/ci/__init__.py": "592afe0e73bfcf4a7b75dd7b6cb4feaa7abcb821e4ddcd1e700ceb9f8163705b", + "python/sglang/test/ci/ci_register.py": "697fffeb402a782a7213009036f0dc65f204004ced0defb3579eef95264ad201", + "python/sglang/test/ci/ci_stress_utils.py": "5e390af02e06d8c09e8e2180fe2d708aa2919e9f7847e4df8e321c2ff9b061cd", + "python/sglang/test/ci/ci_utils.py": "4247b3ccecf006b9521cb87f30bfb6f39c4aa243f4bfadce31affb7f9ca65a9c", + "python/sglang/test/cpu_test_utils.py": "2f8f0c29dc7249c1ee1e7e5d98d8f8d5d9d28dea8e16a5717ee0f4e9d4cde490", + "python/sglang/test/doc_patch.py": "ad2f38b3ecd27814209e5c06554cd381514cf75db896f9e7b72367b731942dc8", + "python/sglang/test/external_models/custom_qwen2_vl.py": "78dcf3f22c157703e49370c75b7efb3d261aa97aa15c32c34f2d5ad0c4f90828", + "python/sglang/test/few_shot_gsm8k.py": "769552ebf727fed84efad1f06a96dcf3c6b47f1f092e419e828de2a6cf8cf2fb", + "python/sglang/test/few_shot_gsm8k_engine.py": "89ebe193344e063e228e9bc0b37cc43e2253c2c654ecbeeb28bee75ad2ec6840", + "python/sglang/test/gpt_oss_common.py": "cd917f99740ed7e8259631ae5deac5e01763fca760439987197eab51af05f72f", + "python/sglang/test/hicache_spec_storage_common.py": "310fcb7e8d83a1f3eb5f68299711c8c8c1905266f820b7ab779493e0e8b3cb43", + "python/sglang/test/kernels/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kernels/deepseek_v4/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kernels/deepseek_v4/common.py": "47fc8910c9b9136556d7890acfb20439e59c936f6c8a5165e9cbbcf13be3686d", + "python/sglang/test/kernels/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kernels/kv_canary/_canary_helpers.py": "bfcbfbd529148c74300fd7b56a8acd66a81de9758a500aee691e134216584f44", + "python/sglang/test/kernels/kv_canary/_constants.py": "a99f6da2171e195462e5a2a8f527b642d9fee84d45a05657d1e65d449e290c43", + "python/sglang/test/kernels/kv_canary/_differential.py": "ed39578f31377edfb051f7dd89bf35dfa100d44115115ab8e08e34dd2165aa17", + "python/sglang/test/kernels/kv_canary/_fixtures.py": "d1a04de8486032e6ace0ba6368746ec91acc63162be79bd9f2e02b5c1b9e6181", + "python/sglang/test/kernels/kv_canary/_fuzz_driver.py": "ce71b3ee13dc7b4bc03b56af4789723f5ae02408f234a29a7bb0cc3f171f68ce", + "python/sglang/test/kernels/kv_canary/_hand_oracle.py": "348a9c460689d762aff5b1ba4d40da9c6e6f5b1bf9b62dd69afdbb571973ea45", + "python/sglang/test/kernels/kv_canary/_invariants.py": "b7e2572ff9c8011dad91b4f456b644e3b23d92b197712228f7382dae09f6a2de", + "python/sglang/test/kernels/utils.py": "f524ddeb157d2f69f58e4b011e0eff4ac06ff41f3658a1adaa4389da601bf300", + "python/sglang/test/kits/abort_timeout_kit.py": "a45688c87ed84d10b202034724ae181f251fed66bdd98e37f11c5c183feeb731", + "python/sglang/test/kits/anthropic_messages_kit.py": "e01f7d7fd7de5f62992132f8cb62f749e9cb72df9065916f48d18511e2cc6cde", + "python/sglang/test/kits/attention_unittest/__init__.py": "766d5a7a5cc6e1498034f5e0bf673dc3f2f032cca1a54dfa791dd10ff86500f9", + "python/sglang/test/kits/attention_unittest/attention_methods/__init__.py": "3153177d9b08069119c6378d229022d3d61f616bd918df230fd57b7fcaf317ec", + "python/sglang/test/kits/attention_unittest/attention_methods/dense_attention.py": "33349f5da9a2ce52cc3b2296f117a7c21021fca9384101f2ddae3a5fc803fcb4", + "python/sglang/test/kits/attention_unittest/attention_methods/dsa_attention.py": "857d8fafc6dcdb65f43d96dd2edf22d41c7501559b9b307c22290a9337589e56", + "python/sglang/test/kits/attention_unittest/attention_methods/dsv4_attention.py": "a159c26c15f158546dc53017bc607ed526ea0757e1efe2eb4dac953f77ca48af", + "python/sglang/test/kits/attention_unittest/attention_methods/dual_chunk_attention.py": "a3595b42f8a0ed7e0b3c0b9133a1e09d9543cf85f2ad6591110687d7bcf93d24", + "python/sglang/test/kits/attention_unittest/attention_methods/gdn_attention.py": "f7df7659b8e904d704ce04021e00a6fc20fdaf99f88e5828cbed09980bff786d", + "python/sglang/test/kits/attention_unittest/attention_methods/kda_attention.py": "6ff3ba80a90718971c20be63cec34bef649ab16322e60b508c2d7de951f8b709", + "python/sglang/test/kits/attention_unittest/attention_methods/lightning_attention.py": "0bd85009229b975772edc058a43e39c5fd3e6101994673c60ee8255188f32f6c", + "python/sglang/test/kits/attention_unittest/attention_methods/mamba2_attention.py": "abf71406f312974c78cf61b248d9ae6859742e2a7d4d17d0fbc8ed22af93aa74", + "python/sglang/test/kits/attention_unittest/attention_methods/mla_attention.py": "1a5b0d4df7db39149c7479f9794b3ebf042b5a186bf87c5ce15699b02aec6d6e", + "python/sglang/test/kits/attention_unittest/runner_modes/__init__.py": "67b0bd82e6f07669cdbef004c2ebfab3b3885e99d0ef4c1c7d04d2a5ab5c8d73", + "python/sglang/test/kits/attention_unittest/runner_modes/cuda_graph_decode_runner.py": "96b135a452b315b6552c4c07424f00007a766ed5b08e2fb5e08a9008a05fec97", + "python/sglang/test/kits/attention_unittest/runner_modes/metadata_invariants.py": "7b38c084c715e221a8c1fb79846fdc997d9aa744fbcc6742be286d1fb2a7427d", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_cuda_graph_runner.py": "229d21a332b5a537a518ffac181494fc97b9fdd80ec63180cec40e0f47e344a0", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_draft_extend_runner.py": "07b8f21cdbffb169a6e225c769d4af55411920b67b1511e2eda578c202e4543a", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_draft_runner.py": "36fe939882a7f5688362bbc0f4327681f3de16a50435f425268d098791f63ffe", + "python/sglang/test/kits/attention_unittest/runner_modes/speculative_target_verify_runner.py": "c702279c8655be089573dd8a605c9d1e1780008cbbab36c55e2434076fbbf68a", + "python/sglang/test/kits/attention_unittest/runner_modes/split_op_runner.py": "d130f94b06f5e8244617ea6c574983666c2b464906a779b1dd4d256c7c45aecf", + "python/sglang/test/kits/basic_api_contract_kit.py": "12da293c9ac39eaf2d24b8d1a0ff92c1da90a3822b5a5c7cd0582c9d0a4d82f6", + "python/sglang/test/kits/basic_decode_correctness_kit.py": "b11161c1b46820899eb90606e7a374de0992a1bfb1957fe62e1bfc1b16eab893", + "python/sglang/test/kits/basic_scheduler_stress_kit.py": "e0139de97468cdfa514bca3dc3a2d8c7a35f6a798673ea7831b34c30e53dfedf", + "python/sglang/test/kits/cache_hit_kit.py": "180f3327a70457648fa42b620028f5043e2bfd458bf4441f04e048271742f401", + "python/sglang/test/kits/ebnf_constrained_kit.py": "a82b070f8d217493ae4e39ff3fda414f29905b2ff2e76028e5e78b80c200ee2d", + "python/sglang/test/kits/eval_accuracy_kit.py": "c66e48dc21fe072c94981694c8c86969c1057df593273db5874a33c9296509fa", + "python/sglang/test/kits/fwd_occupancy_kit.py": "5923ed5540cf401ee841b61a119957741c67e47ca0be7bf96d8bbcd547589b04", + "python/sglang/test/kits/hellaswag_kit.py": "444710eb25cdfdfc55d20b80d67cf8081d079d5a7c79ab5b25b6e5ea4d4efd56", + "python/sglang/test/kits/json_constrained_kit.py": "03571e095b07fc33b6da8ca2b760a505d54e9e923d36349fa88ad0ef4f4d1c49", + "python/sglang/test/kits/json_mode_kit.py": "bc06c240e51a456656e70f1804d5bbd2450e967267e1ed46924852716ec5dabb", + "python/sglang/test/kits/kl_divergence_kit.py": "43e268b628e794b3575921a66e8eb4e329f7623b520957ddb543c201f0488018", + "python/sglang/test/kits/lm_eval_kit.py": "960aa82f2dd609c102ff1f7e35afc1ff3d46c4ffacd571c9a93503d47935a8ba", + "python/sglang/test/kits/matched_stop_kit.py": "eb46044a2bdd12a9fa5d751af682eed5478ba33a786a1b5e104bd6c8e5150f1f", + "python/sglang/test/kits/mmmu_vlm_kit.py": "c403eab9055ef2ccc0ca7becafc6ec12a49a744083072ed1eb6b182fb6f79015", + "python/sglang/test/kits/pause_generation_kit.py": "90619f40caf6080878b0183a838dbb9d5a3abc1f387c644c89549c04894bd748", + "python/sglang/test/kits/prefix_cache_branching_kit.py": "988c5bc42886be7e71d240c089cbdf6bb7ae897b5d0a5e62512d3c6864674969", + "python/sglang/test/kits/radix_cache_server_kit.py": "a1dbf6aa2c2d8fd4a615f61e0ec660786d2303501137c10e86b328da273dc3b1", + "python/sglang/test/kits/reasoning_kit.py": "306cb78382e64aa0be24638516c93099394730def7e1937c1741c5bacaf8bf8a", + "python/sglang/test/kits/regex_constrained_kit.py": "3d0e81e11307fbedba4712d1923f953c222a88ff8680e6e0da77470b6f914a5f", + "python/sglang/test/kits/spec_decoding_kit.py": "76d3ba7b58e2bc616146dd4088707047601f42a7ae6a27c48c4cfeb688ad9dde", + "python/sglang/test/kits/spec_server_kits.py": "7f0e9a20a9761d4c595dbb598678a18390ef0730a81a1258f745e7d118ca5c5b", + "python/sglang/test/kits/streaming_session_kit.py": "47c3c03a51f20d49e0367ed68b2f6c663c01d079a9c3ab50ffe11fca08bb50f5", + "python/sglang/test/kits/unified_radix_cache_kit.py": "6d6981ec279339ca75197ece222ad72091555f3580939a970e48f54716d78f53", + "python/sglang/test/kl_multiturn_utils.py": "6e0f44b6a7e046e7759c3005bbcbfd81a4923628f92ff19dcd9f2b991445a9d7", + "python/sglang/test/kl_test_utils.py": "2222c57f45e0c4542b0c7c6e564869822265ac8cfce371eef6936af51d0a7bc6", + "python/sglang/test/kv_canary/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/kv_canary/consts.py": "38ba3fdb420336c66176968c991092397cb680da939b30e4ef8c5b901e228351", + "python/sglang/test/kv_canary/e2e_base.py": "491f61d4e2302649852c580091e968f9d8e75b5f797fceddd2a825e2e67841ee", + "python/sglang/test/kv_canary/fixtures.py": "167b68ae08819d0a7a509b331cb3eebecfad4fbc531867509257f1308e151080", + "python/sglang/test/kv_canary/mode_config.py": "9068fc4c3a5739c010a3e4f13d8e0f632cfa42cde1ffe1b90c228d6cf946d4bd", + "python/sglang/test/kv_canary/pd_fixture.py": "78eb12ccfefb73cf3fa4252cda596a1301d7c96a78297cd6131c87825788147b", + "python/sglang/test/kv_canary/pp_fixture.py": "8c7ac6a97775311c4598369c9ecd4496068f73080f91a7cc107c6ffe129e3b10", + "python/sglang/test/kv_canary/runner_test_base.py": "cb414740122c00e1f2f639fa280cba7b334848bc8a57cc2000ef9ea9b30c0da7", + "python/sglang/test/kv_canary/utils.py": "707f882bcc1027fefe39a9442ec3143e077407862cb74671dfc8adc161eefdad", + "python/sglang/test/kv_canary/violation_assert_mixin.py": "56d64ff645e6b22edd656a0fcce86035c90de7122e4ab708ce529638f0366d06", + "python/sglang/test/kv_canary/violation_log_utils.py": "71c36def7a1daf2e8e36feeac3f62c1cb2b1b95780f1a37a44258e438fe193c5", + "python/sglang/test/layer_ut_utils.py": "0a2402a6f7798bcf2f9e0d460c29f12788ce2b8c1ec5d326280b86f7b10b9198", + "python/sglang/test/logprob_test_utils.py": "08d839683e6271c7d4fd67357babd1d8ca679f5c4990c22bdbe034682124b5e1", + "python/sglang/test/long_prompt.txt": "37733cc60234aab491177a2eeff4237a02409bd444f63dfe810239f61cfcb085", + "python/sglang/test/lora_utils.py": "b40ede0791f2404ae66ae3ddea682fa7b93120ac1fc13881935fc0b46988837d", + "python/sglang/test/manual/disaggregation/test_chunked_prefill_abort.py": "8b32d6220f47c3f53d211ad40936198d5ec9e4df8d1a3052bfeea4ef46e641fa", + "python/sglang/test/manual/disaggregation/test_disaggregation_chunked_prefill_abort.py": "69a9c35e57a0e97d80a72486c6423f1853a38bf0a6f21d217e5ab5006369c5f3", + "python/sglang/test/manual/disaggregation/test_disaggregation_peer_liveness_abort.py": "64bacb67c2c0344a2c5024e15de3ae331a3fff1fda6c0e87cdb7250bb69a2e32", + "python/sglang/test/mock_model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/mock_model/perturb_e2e_base.py": "c20818c783010300f91ecf008f329cc887ea2388877130a78a682b6788a8a8ee", + "python/sglang/test/mock_model/utils.py": "cd3e4ff77c38ea0174e61ca2cf76b3ab867408eba42ee75f1cf801f843588138", + "python/sglang/test/nightly_bench_utils.py": "76af58d680f91d2ab10d7b09b2a95ddc570f88779ab4b0cf0ac6228f92166daa", + "python/sglang/test/nightly_utils.py": "9de169b6a285d42512eb8a52eb815a7209e5312404e68ea0fcac13fd192b7ea8", + "python/sglang/test/observability/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/observability/fake_ray.py": "0e4906334f03b9c300116c740dbd2a2da65db326871c66cfa24122b21d751639", + "python/sglang/test/otel_collector.py": "00491d1e5f3d1d8e5de0defe870c146515f2912cd335e222373d3e62da488fb0", + "python/sglang/test/performance_test_runner.py": "973f9c566424627430a9214a33dcd7536784571423c43a726578b9ecede4b761", + "python/sglang/test/precision_baseline_store.py": "c179147635b897046ae51a38b1a8560df4e4eec3a09946bf55171ff0f362b4d3", + "python/sglang/test/quant_ref_utils.py": "80c04a005e3242f1ccc5af93ae5bb79ee5893c7634f440bc793c6483e52b0040", + "python/sglang/test/run_combined_tests.py": "5854fb7686cee1107643ca057fd1a20e4bce12ed001ae87733ab839e371f1775", + "python/sglang/test/run_eval.py": "0ccae307af3ea0c6cfea9e27dbe6b60b63f7ca60a91e798a00be73187facf7cb", + "python/sglang/test/runners.py": "7a5691eb92a5e13bee014f3dcfb6c3347d446b97fd7de3bb5a5a2f37cf90e47a", + "python/sglang/test/scripted_runtime/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/scripted_runtime/background_http_poster.py": "8f29c2f03b6f1fa441e28897f5a5e3590ccdea7ddd9893fe64e9d40db70bba34", + "python/sglang/test/scripted_runtime/context/__init__.py": "d3572ec52cf1e3ae7956dc14d3d8096b2f14292d6b2c000e254050da580deeb6", + "python/sglang/test/scripted_runtime/context/api.py": "42710ca730cc29eb5ea102f539239291c4ce872a683019f0d1f385809d66b60d", + "python/sglang/test/scripted_runtime/context/engine.py": "6ee003e563df38261d4e3ed89cbccf1ed8da508b1b47f4c133c99798ca36c7c9", + "python/sglang/test/scripted_runtime/context/http_post.py": "8a3312128c20819dbe1120fa8a7a8f9f7d3c38dfb17475d2f2f817e158ef7bc9", + "python/sglang/test/scripted_runtime/context/kv_pool_exhauster.py": "c67f894b46252a4b63ae98398829b2820b2d5a982fba0dfd004a5f564a96acf1", + "python/sglang/test/scripted_runtime/context/lifecycle.py": "6b948df8881b2533b2df557af75884bad6e93a53faccad7addb269a6c1a02abd", + "python/sglang/test/scripted_runtime/context/lock_ref_exhauster.py": "6390b06b289b8df782c72ed4172e2a49c2253cc7e5469d15524bdc49809c467d", + "python/sglang/test/scripted_runtime/context/queries.py": "8d737f2d99c6e0c6be1e0f48183f39872418a76f2f222874b4b9793aae6b9f8b", + "python/sglang/test/scripted_runtime/context/radix.py": "89f0e283cecbd3085bee281b057fa78574d3bceb80c433f25483a6e6e2b687ac", + "python/sglang/test/scripted_runtime/context/req_starter.py": "f0e0ffdad547f706e0b50702f759f998193990cee97f69a221c495a6979a5e2d", + "python/sglang/test/scripted_runtime/http_server.py": "0dec1cc1b10db21eb525a11a66fb38e1b51d89a966c89b1acab749f7a5b1a2ee", + "python/sglang/test/scripted_runtime/io_struct.py": "5ac739259af031471c0719cfdbdc85f18da5592db05341c3e531b228b123380f", + "python/sglang/test/scripted_runtime/req_handle.py": "594877f5cf9f88a101728d07249ce77606d5cc076f4700266ee83890ec243e26", + "python/sglang/test/scripted_runtime/scheduler_hook.py": "4e4a13979168e3051196223704c947c182a216ecbe7a8b19a87c7b254b8a02cd", + "python/sglang/test/scripted_runtime/test_case.py": "e07bda24f8662c9b370a9b3e44c6dd9bb92572c5e13765a14fafb7126e7ae3e9", + "python/sglang/test/scripted_runtime/tokenizer_recv_proxy.py": "9ba8b8bdc1a403196d3f6b941cbfefab6b2a9d12492b73d8cd4d4c23fda61e53", + "python/sglang/test/scripted_runtime/utils.py": "65cabcf96f6dcb91364cc3b149ba9f687a33bfaa2c96a9cbca8d2978459e578d", + "python/sglang/test/scripted_runtime_chunked_helpers.py": "cf73bda447dfd82b0276564470f9d5691ffff653b19f41dd79e110aa37c34e6d", + "python/sglang/test/send_one.py": "77bc3b499742f4fa19557ccca0185ddb6ad7599a3286db6b98e9e818ccd4a3dc", + "python/sglang/test/server_fixtures/default_fixture.py": "a87f02aaf39f92c582231c78b7520772fc38dabc9f3489c508968728f9cb5253", + "python/sglang/test/server_fixtures/disaggregation_fixture.py": "b6af811f6d2a335cf0a17cfefdec889754741eb235730de85a83816c4522d1cd", + "python/sglang/test/server_fixtures/dsa_mtp_fixture.py": "2744c5356309ab12cacb2b45b3972c2faf9b64b3af79e76c3deb70a4cae2fd10", + "python/sglang/test/server_fixtures/eagle_fixture.py": "c61c67b5ab45d9d41dc4eb56b14d55a04aa2c621392744550c4b079a41b9c9fb", + "python/sglang/test/server_fixtures/hybrid_attn_backend_fixture.py": "b85b7e9d59b63daf60dee8cef0ede7f84c0c7aeae2762e326e945351a0cea722", + "python/sglang/test/server_fixtures/mmmu_fixture.py": "a8d3e51af235aa0383770c148e6ab2c79ee036f0dd6faafa43073b6f884cc7ad", + "python/sglang/test/server_fixtures/ngram_fixture.py": "92632ec57b742971eda37d6b0fff08b11621184c6f72f98cb115c21d3463079a", + "python/sglang/test/server_fixtures/pcg_spec_fixture.py": "9f90c1abcbfc6f26a4d2c4dac959b9e7c230511fc5af48ec8a0b601bec6e760f", + "python/sglang/test/server_fixtures/spec_eagle_fixture.py": "34e97921df46570466d23cb2cd983741600a1a27dfded3bd12dad6c3123e95b0", + "python/sglang/test/server_fixtures/standalone_fixture.py": "04cfd925f255f16c1b0219b210fe13d9515bd25badce13480bafe234fa44d921", + "python/sglang/test/server_fixtures/streaming_session_fixture.py": "f047ed2037607eca1e4f7d7dda9a3eee2f33f4f91c606ad1824d9de21c88a74a", + "python/sglang/test/simple_eval_aime25.py": "27963c56f4a4f4e0bd6f31079c4d17cb1ea38724e32b8d90dd34a44629ff938f", + "python/sglang/test/simple_eval_aime26.py": "a8847e0ed01e32e6ff0da16c4e9c57b4fdc41e06b769be93952e7a0b1704b892", + "python/sglang/test/simple_eval_common.py": "d5e97cc180fae031f73d73af8dd4ced974975df07651891e789ade09d0ad071f", + "python/sglang/test/simple_eval_gpqa.py": "2a1dacce92d75397490edfd88bb131dfc9fd0f5df39eacf0b668595228b4e436", + "python/sglang/test/simple_eval_humaneval.py": "d26f48589356bdfcccafd46705eecb2f19c7b058c8576a9c56d259394b2082bd", + "python/sglang/test/simple_eval_longbench_v2.py": "2cb6b7a80985f0f1751c60beb9b35c681e236b3db636164163aeeb2334c7e439", + "python/sglang/test/simple_eval_math.py": "cf6d04a5cdbe518dce86b9fb18974b98cc1d104c4c896140eb164585428b8640", + "python/sglang/test/simple_eval_mgsm.py": "41b3c1e7d6d02195903f4c9dfd855db56349335723a217714b82fa77ffe4f7b2", + "python/sglang/test/simple_eval_mixed_prefix_gsm8k.py": "582a15ab52728aa22b3190091f82e91a10e6c1a6f0eea82b37c86208abc51ebb", + "python/sglang/test/simple_eval_mmlu.py": "769a0837785460c622ba61f53ecb4c3a70db72e304acd982e1f10f3149268be6", + "python/sglang/test/simple_eval_mmmu_vlm.py": "78ede20949c24df27e1896ebd1565df44d2f672c23d6f6f28f9de50592ad97ed", + "python/sglang/test/test_deepep_utils.py": "ef8f72b1304637387aad850226185906d669783d797964de347602cad72f66d7", + "python/sglang/test/test_deterministic.py": "a9f2ff426a156a45b8f69ecfc24fbfbd6c699b4aa8cba40b26e331c0cde7664a", + "python/sglang/test/test_deterministic_utils.py": "69a9a8e8db112b96405c1bc682eedb2fa3fd5da5e43723d08fa237290bb5d2f1", + "python/sglang/test/test_marlin_utils.py": "e9911ab643ba2b793959fa4d0bf35f7f1acd490761e394dbf72fea0375379e2a", + "python/sglang/test/test_programs.py": "206edce50a73450714973cd8198729fee3abd223f8bbb5fda56c3c489d2bbe66", + "python/sglang/test/test_utils.py": "b25ac72188208942156cc1cc7a96ae5cbd0fd69111ab96ce47f5b1bfb3eac81e", + "python/sglang/test/tool_call_test_runner.py": "aafc61c33f86d2bf65355f51d4f131847196527b30a4d4de113fe17a5fcec871", + "python/sglang/test/vlm_utils.py": "8c8a770aa0c8daed2d36067480471dca8e29b070801263174c905bf6cb2e749b", + "python/sglang/test/xpu/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "python/sglang/test/xpu/simple_eval_gsm8k_xpu_mixin.py": "c41867f97e6142fa19fb3f0c1bbd6be155ed05ba7d16042f4b2b613590349ef6", + "python/sglang/test/xpu/test_xpu_utils.py": "742f270c42eb37e9680d05dc87b116114241b151139d4c202b87e52c23411df2", + "python/sglang/utils.py": "8e453ae5a32c045cc7f9ee842081e727fbede9ab9c88536ebb299eb122ad8ed8", + "python/sglang/version.py": "b10f7d9ea276972352b1e9de0eb0bbb47d8ebe64c29469e15ea016a12019bb22" +} diff --git a/provenance/invalid-token-failure.json b/provenance/invalid-token-failure.json index c774895..6200241 100644 --- a/provenance/invalid-token-failure.json +++ b/provenance/invalid-token-failure.json @@ -1,30 +1,71 @@ { - "status": "CPU-tested candidate only; not built, published, or deployed", - "base_git_commit": "93463c3466b0de9d21776fbeff95657285df8269", - "base_profile": "responses-compat-candidate", + "status": "CPU-tested and locally built candidate; not published or deployed", + "base_main_commit": "e5d93387e03c110de6f6f483a0ff5ed44d3a1a1e", + "original_pr8_head": "4059ace2b2faa2d7972f7704c8fdca0985a35b1a", + "reviewed_functional_head": "63f43b7ad68b40831f3b1a47e880a56a2db66a42", + "predecessor_profile": "qwen-multimodal-alias", "base_image": "kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404", - "base_inventory_sha256": "e574ce136e79576c3970da7f479b729b21d18ef8e4fe3e49ae3a5fd521866138", + "base_inventory": "qwen-multimodal-alias-runtime-files.json", + "base_inventory_sha256": "c88e18731d4ef0b4cd5a71c5f4b486def1677802c86303907ee50f2317714395", "patch": "0019-invalid-generated-token-failure.patch", - "patch_sha256": "e72fea4871a88e9d4fbffe06e2e6788e7b17992bc01cdf25f80ea4699e823742", + "patch_sha256": "4d1f7a71b2907d79d6075a9d2b1b9f0fd2dd96ec97c08bc8d246ba15979c6a75", + "series": [ + "0015-qwen-flash-next-effort-alias.patch", + "0016-responses-namespace-custom-boundary.patch", + "0017-responses-phase-order.patch", + "0018-qwen-flash-next-multimodal-alias.patch", + "0019-invalid-generated-token-failure.patch" + ], "files": { "python/sglang/srt/entrypoints/openai/serving_chat.py": { - "before": "6d881d19da2c4a7028b0fb179cf5cdb958480612d4192c1606dfd25f98a9ba56", - "after": "fafda72ae4ed93165917bfc1b0bb90a1b676837f9e5a7611b9f3e0be6b595f83" + "before": "07ccd04de5f716277d2df873f66bdc4c03d13f7e89aad105c6dcba979ff47931", + "after": "e36c887507fe94aa13cd2fc97930f253fd129339959cd846d3ec7ad4274b2824" + }, + "python/sglang/srt/entrypoints/openai/serving_completions.py": { + "before": "67f08075f21481b03e246327c7453f57ac001d0f3e78f5a9247caa553e1942e3", + "after": "0d21d557ef38d0639e4030bff764ecca8a266ef6d60284cf959c56d9dec751a1" }, "python/sglang/srt/entrypoints/openai/serving_responses.py": { - "before": "d46f648b557db07a430869471fcf4d7a898d50f99e495efd5eb01911c428f215", - "after": "3ffe860246810037ad58a6e79cd370fa0199bc130c1752cfe1feef4a11e87096" + "before": "e65084c831bb3755bcef6a3288587582c065538857b58d09c8d2c2bc3ecf696c", + "after": "a30b96b8b1393e8d1cf53fb180e602eeae07bd160bb88a3146eaafdf0ef0f4e7" }, "python/sglang/srt/managers/schedule_batch.py": { "before": "4965156c669a536b40250605794de9d9aa7582fde71d188ab2ecf22e766e755a", "after": "56b475c078d2aed7fc626dd7f41559b169498da285bf729d94b76e8abda13c42" } }, - "source_files": 4392, - "result_inventory_sha256": "83e45a5d191a3998a68a4c9bd41227d737e5a5e4d44513bcdebb2c713db6abd5", - "cpu_regression": { - "unpatched": "11 methods: 20 failures and 2 errors", - "patched": "11 methods passed", - "scope": "Scheduler classification and Chat, Anthropic Messages, and Responses propagation" - } + "source_files_before": 4392, + "source_files_after": 4392, + "inventory": "invalid-token-failure-runtime-files.json", + "inventory_sha256": "414b43dec378538ca1e5785f4855115947d824c2b42fe6fa4bcb2943815c05f3", + "validation": { + "invalid_token_runtime_tests": 15, + "invalid_token_packaging_tests": 4, + "responses_tests": 75, + "effort_tests": 14, + "multimodal_tests": 4, + "full_package_tests": 90, + "dedicated_packaging_tests": 17, + "exact_image_reconstructions": 2, + "exact_image_tree_digest_sha256": "f98edc6b100d20bfd993b0f02183e53ac8f5b7bf41c849779877ee2090878482", + "local_candidate_image_digest": "sha256:a4627d598748483bad601e53b7500940374d12b1226016d99a79a18569deec60", + "logs": { + "pr8-final-invalid-token-green.log": "d70f998e10597b3d33c9ee5ebbb5b69f03b71e96b97ef96a585db52289d3aa13", + "pr8-final-responses-75.log": "eeb2f440d737a0a5f0f1f686c7dfab7e9399733e45cad32110d9d9e33255719a", + "pr8-final-effort-14.log": "c91d898de13ded814c6abd96a7028c5d2cffa36db0c05709516009d76de12506", + "pr8-final-multimodal-4.log": "b0f726e94944c0035e02d80319aecd788d16c42e9346afdceb2643f7f8786b3d", + "pr8-final-full-package.log": "9584ca1c8725c16d69812491fe802f4345c0312d92366cf4d50856fb09079796", + "pr8-final-packaging-17.log": "f0ed380b08e2a24c2d2bfe7072f492a40d0f0600b2db7a605c66a032c5e6b58b", + "pr8-final-exact-image-reconstruction-twice.log": "b979d29167bb1e0f39275de0acac87e06e14abd5012e27376f792c895f3872ea", + "pr8-final-docker-build-readback.log": "c90c1240d352226a0467412353f2b8601aa203652a8c22528f1fedb72f617da1", + "pr8-final-compile-diff-security.log": "32cceb049709ca854a9a52c4b326e79c822f5d8b37a4f9d178b213c2f66eecbf" + } + }, + "scope": [ + "Scheduler invalid generated-token classification without faulty-token emission", + "Chat and Completions InvalidTokenError streaming propagation", + "Responses failed terminals, storage, retrieval, and pre-generation replay rejection", + "Graceful cancellation behavior preservation", + "PR5 Responses phase/order behavior and PR7 Qwen VL bytes preservation" + ] } diff --git a/provenance/pr8-final-compile-diff-security.log b/provenance/pr8-final-compile-diff-security.log new file mode 100644 index 0000000..f6321bc --- /dev/null +++ b/provenance/pr8-final-compile-diff-security.log @@ -0,0 +1,20 @@ +== base and provenance identities == +e5d93387e03c110de6f6f483a0ff5ed44d3a1a1e +4059ace2b2faa2d7972f7704c8fdca0985a35b1a fix(runtime): surface invalid generated token failures +63f43b7ad68b40831f3b1a47e880a56a2db66a42 fix(runtime): complete invalid token failure propagation +== staged diff check == +PASS +== Python and shell compile == +compiled 7 Python files +shell syntax PASS +== generated patch exact apply == +{"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": true} +== PR5/PR7 preservation == +qwen_vl b47003e1f0840a057519adff46fc72a9318a61e2eb3ef8cedfa9eab19e98b7f7 unchanged True +_make_qwen_ordered_output_items 2 +preserve_qwen_order=is_qwen 1 +_make_failed_previous_response_error 3 +ResponsePhasedOutputItemAddedEvent 2 +== added-line security scan == +{'hardcoded_secret': 0, 'shell_injection': 0, 'dangerous_eval_exec': 0, 'unsafe_pickle': 0, 'sql_formatting': 0} +PASS diff --git a/provenance/pr8-final-docker-build-readback.log b/provenance/pr8-final-docker-build-readback.log new file mode 100644 index 0000000..b6ec081 --- /dev/null +++ b/provenance/pr8-final-docker-build-readback.log @@ -0,0 +1,77 @@ +#0 building with "default" instance using docker driver + +#1 [internal] load build definition from Dockerfile.invalid-token-failure +#1 transferring dockerfile: 2.85kB done +#1 DONE 0.1s + +#2 [internal] load metadata for docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 +#2 ... + +#3 [auth] kanadaj/sglang-qwen38fn-sm120-turbo:pull token for registry-1.docker.io +#3 DONE 0.0s + +#2 [internal] load metadata for docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 +#2 DONE 0.8s + +#4 [internal] load .dockerignore +#4 transferring context: 134B done +#4 DONE 0.1s + +#5 [internal] load build context +#5 DONE 0.0s + +#6 [ 1/11] FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 +#6 resolve docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 0.1s done +#6 DONE 0.1s + +#5 [internal] load build context +#5 transferring context: 1.19MB done +#5 DONE 0.1s + +#6 [ 1/11] FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 +#6 CACHED + +#7 [ 2/11] COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py +#7 DONE 0.1s + +#8 [ 3/11] COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_completions.py +#8 DONE 0.1s + +#9 [ 4/11] COPY runtime/python/sglang/srt/entrypoints/openai/protocol.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py +#9 DONE 0.1s + +#10 [ 5/11] COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py +#10 DONE 0.1s + +#11 [ 6/11] COPY runtime/python/sglang/srt/entrypoints/openai/responses_compat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py +#11 DONE 0.1s + +#12 [ 7/11] COPY runtime/python/sglang/srt/function_call/qwen3_coder_detector.py /sgl-workspace/sglang/python/sglang/srt/function_call/qwen3_coder_detector.py +#12 DONE 0.1s + +#13 [ 8/11] COPY runtime/python/sglang/srt/multimodal/processors/qwen_vl.py /sgl-workspace/sglang/python/sglang/srt/multimodal/processors/qwen_vl.py +#13 DONE 0.1s + +#14 [ 9/11] COPY runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py /sgl-workspace/sglang/python/sglang/srt/managers/schedule_batch.py +#14 DONE 0.1s + +#15 [10/11] COPY provenance/invalid-token-failure-runtime-files.json /tmp/invalid-token-failure-runtime-files.json +#15 DONE 0.1s + +#16 [11/11] RUN python3 -B -c 'import hashlib,json,pathlib; root=pathlib.Path("/sgl-workspace/sglang"); expected=json.loads(pathlib.Path("/tmp/invalid-token-failure-runtime-files.json").read_text()); actual={str(p.relative_to(root)) for p in (root/"python/sglang").rglob("*") if p.is_file() and "__pycache__" not in p.parts and p.suffix != ".pyc"}; assert actual == set(expected), (len(actual), len(expected)); bad=[n for n,h in expected.items() if hashlib.sha256((root/n).read_bytes()).hexdigest()!=h]; assert not bad, bad; files=[root/"python/sglang/srt/entrypoints/openai"/n for n in ("serving_chat.py", "serving_completions.py", "protocol.py", "serving_responses.py", "responses_compat.py")]+[root/"python/sglang/srt/function_call/qwen3_coder_detector.py", root/"python/sglang/srt/multimodal/processors/qwen_vl.py", root/"python/sglang/srt/managers/schedule_batch.py"]; [compile(f.read_bytes(), str(f), "exec") for f in files]' && rm /tmp/invalid-token-failure-runtime-files.json +#16 DONE 0.6s + +#17 exporting to image +#17 exporting layers +#17 exporting layers 1.3s done +#17 exporting manifest sha256:480b15914d6577a96c49131e89555ae3a1153b306d4cdeeccbf0039becd3659f 0.0s done +#17 exporting config sha256:0043c762ee486c4f6f90bc0bd00dd5593b2d3952a3d23ada80443eb040af59b2 0.0s done +#17 exporting attestation manifest sha256:ca5c818b7cfb936ec2015313e53b42db1e564cac0993dba4eda5ff4d01b0aea9 0.0s done +#17 exporting manifest list sha256:a4627d598748483bad601e53b7500940374d12b1226016d99a79a18569deec60 +#17 exporting manifest list sha256:a4627d598748483bad601e53b7500940374d12b1226016d99a79a18569deec60 0.0s done +#17 naming to docker.io/library/sglang-pr8-final:local-candidate 0.0s done +#17 unpacking to docker.io/library/sglang-pr8-final:local-candidate +#17 unpacking to docker.io/library/sglang-pr8-final:local-candidate 0.4s done +#17 DONE 1.9s +sha256:a4627d598748483bad601e53b7500940374d12b1226016d99a79a18569deec60 local-pr8-candidate +{"source_files": 4392, "expected_files": 4392, "missing": 0, "extra": 0, "mismatched": 0} diff --git a/provenance/pr8-final-effort-14.log b/provenance/pr8-final-effort-14.log new file mode 100644 index 0000000..5912fb3 --- /dev/null +++ b/provenance/pr8-final-effort-14.log @@ -0,0 +1,28 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 14:08:50.350000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok +test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok +test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok +test_top_level_xhigh_reaches_real_tokenizer (runtime_chat_effort.ChatEffortTest.test_top_level_xhigh_reaches_real_tokenizer) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:1034: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field + "max_new_tokens": self.max_completion_tokens or self.max_tokens, +ok +test_anthropic_messages_effort_uses_shared_aliases (__main__.QwenAliasTest.test_anthropic_messages_effort_uses_shared_aliases) ... ok +test_chat_alias_tokens_and_literal_provenance (__main__.QwenAliasTest.test_chat_alias_tokens_and_literal_provenance) ... ok +test_invalid_values_still_fail (__main__.QwenAliasTest.test_invalid_values_still_fail) ... ok +test_processing_special_token_state_survives_render_copy (__main__.QwenAliasTest.test_processing_special_token_state_survives_render_copy) ... ok +test_responses_real_conversion_and_literal_effort (__main__.QwenAliasTest.test_responses_real_conversion_and_literal_effort) ... ok +test_server_default_and_absence_semantics (__main__.QwenAliasTest.test_server_default_and_absence_semantics) ... ok +test_supported_values_precedence_null_and_no_leak (__main__.QwenAliasTest.test_supported_values_precedence_null_and_no_leak) ... ok +test_tokenize_and_multimodal_render_paths (__main__.QwenAliasTest.test_tokenize_and_multimodal_render_paths) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py:875: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field + max_output_tokens = request.max_completion_tokens or request.max_tokens +ok +test_tokenize_precedence_null_and_provenance (__main__.QwenAliasTest.test_tokenize_precedence_null_and_provenance) ... ok +test_unrelated_model_native_efforts_are_not_aliased (__main__.QwenAliasTest.test_unrelated_model_native_efforts_are_not_aliased) ... ok + +---------------------------------------------------------------------- +Ran 14 tests in 2.532s + +OK diff --git a/provenance/pr8-final-exact-image-reconstruction-twice.log b/provenance/pr8-final-exact-image-reconstruction-twice.log new file mode 100644 index 0000000..245f40f --- /dev/null +++ b/provenance/pr8-final-exact-image-reconstruction-twice.log @@ -0,0 +1,6 @@ +{"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": true} +{"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": true} +{"run": 1, "files": 4392, "tree_digest_sha256": "f98edc6b100d20bfd993b0f02183e53ac8f5b7bf41c849779877ee2090878482"} +{"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": true} +{"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": true} +{"run": 2, "files": 4392, "tree_digest_sha256": "f98edc6b100d20bfd993b0f02183e53ac8f5b7bf41c849779877ee2090878482"} diff --git a/provenance/pr8-final-full-package.log b/provenance/pr8-final-full-package.log new file mode 100644 index 0000000..0a1ea8e --- /dev/null +++ b/provenance/pr8-final-full-package.log @@ -0,0 +1,96 @@ +{"clean_patch_apply": true, "verified_changed_paths": 36, "syntax_checked_python_files": 36} +test_baseline_compares_only_named_numeric_values (test_diagnostics.DiagnosticsTests.test_baseline_compares_only_named_numeric_values) ... ok +test_baseline_hundreds_digit_integer_is_unavailable (test_diagnostics.DiagnosticsTests.test_baseline_hundreds_digit_integer_is_unavailable) ... ok +test_baseline_tiny_positive_value_percentage_is_unavailable (test_diagnostics.DiagnosticsTests.test_baseline_tiny_positive_value_percentage_is_unavailable) ... ok +test_bounded_local_reads_and_command_failures_are_sanitized (test_diagnostics.DiagnosticsTests.test_bounded_local_reads_and_command_failures_are_sanitized) ... ok +test_cgroup_v2_and_v1_limits_and_counters_without_paths (test_diagnostics.DiagnosticsTests.test_cgroup_v2_and_v1_limits_and_counters_without_paths) ... ok +test_cli_bounds_and_errors_never_echo_sensitive_arguments (test_diagnostics.DiagnosticsTests.test_cli_bounds_and_errors_never_echo_sensitive_arguments) ... ok +test_container_allowlists_values_digest_effective_args_and_fixed_probe (test_diagnostics.DiagnosticsTests.test_container_allowlists_values_digest_effective_args_and_fixed_probe) ... ok +test_container_cgroup_counters_are_sampled_without_repeated_exec (test_diagnostics.DiagnosticsTests.test_container_cgroup_counters_are_sampled_without_repeated_exec) ... ok +test_current_driver_ansi_topology_and_singular_event_tags (test_diagnostics.DiagnosticsTests.test_current_driver_ansi_topology_and_singular_event_tags) ... ok +test_default_cli_writes_private_reports_without_network_or_docker (test_diagnostics.DiagnosticsTests.test_default_cli_writes_private_reports_without_network_or_docker) ... ok +test_docker_cgroup_does_not_guess_host_pid_inside_collector_container (test_diagnostics.DiagnosticsTests.test_docker_cgroup_does_not_guess_host_pid_inside_collector_container) ... ok +test_docker_pid_namespace_requires_visible_peer_and_matching_namespaces (test_diagnostics.DiagnosticsTests.test_docker_pid_namespace_requires_visible_peer_and_matching_namespaces) ... ok +test_docker_remote_environment_and_default_context_cannot_override_local_socket (test_diagnostics.DiagnosticsTests.test_docker_remote_environment_and_default_context_cannot_override_local_socket) ... ok +test_endpoint_typed_metrics_drop_nested_secrets_and_duplicate_series (test_diagnostics.DiagnosticsTests.test_endpoint_typed_metrics_drop_nested_secrets_and_duplicate_series) ... ok +test_gpu_xml_versions_units_and_identifier_redaction (test_diagnostics.DiagnosticsTests.test_gpu_xml_versions_units_and_identifier_redaction) ... ok +test_host_collection_reads_numeric_topology_pressure_and_counters (test_diagnostics.DiagnosticsTests.test_host_collection_reads_numeric_topology_pressure_and_counters) ... ok +test_http_opt_in_rejects_credentials_redirects_and_oversize (test_diagnostics.DiagnosticsTests.test_http_opt_in_rejects_credentials_redirects_and_oversize) ... ok +test_http_parent_allowlists_worker_errors_and_suppresses_launch_errors (test_diagnostics.DiagnosticsTests.test_http_parent_allowlists_worker_errors_and_suppresses_launch_errors) ... ok +test_http_protocol_errors_never_escape_or_reach_stderr (test_diagnostics.DiagnosticsTests.test_http_protocol_errors_never_escape_or_reach_stderr) ... ok +test_http_real_malformed_status_has_no_traceback_or_endpoint_output (test_diagnostics.DiagnosticsTests.test_http_real_malformed_status_has_no_traceback_or_endpoint_output) ... ok +test_http_total_deadline_includes_headers_and_slow_body (test_diagnostics.DiagnosticsTests.test_http_total_deadline_includes_headers_and_slow_body) ... ok +test_http_total_deadline_kills_and_reaps_stalled_dns_worker (test_diagnostics.DiagnosticsTests.test_http_total_deadline_kills_and_reaps_stalled_dns_worker) ... ok +test_http_total_deadline_terminates_trickled_headers (test_diagnostics.DiagnosticsTests.test_http_total_deadline_terminates_trickled_headers) ... ok +test_http_worker_inherits_auth_without_command_line_secrets_and_preserves_metrics (test_diagnostics.DiagnosticsTests.test_http_worker_inherits_auth_without_command_line_secrets_and_preserves_metrics) ... ok +test_http_worker_is_reaped_even_when_pipe_communication_fails (test_diagnostics.DiagnosticsTests.test_http_worker_is_reaped_even_when_pipe_communication_fails) ... ok +test_interval_rates_counter_resets_and_yield_are_not_global_iterations (test_diagnostics.DiagnosticsTests.test_interval_rates_counter_resets_and_yield_are_not_global_iterations) ... ok +test_sampler_executes_existing_load_reads_and_records_actual_intervals (test_diagnostics.DiagnosticsTests.test_sampler_executes_existing_load_reads_and_records_actual_intervals) ... ok +test_script_entrypoint_executes_as_a_real_local_process (test_diagnostics.DiagnosticsTests.test_script_entrypoint_executes_as_a_real_local_process) ... ok +test_selected_gpu_collection_filters_topology_and_capabilities (test_diagnostics.DiagnosticsTests.test_selected_gpu_collection_filters_topology_and_capabilities) ... ok +test_server_info_top_level_settings_are_allowlisted (test_diagnostics.DiagnosticsTests.test_server_info_top_level_settings_are_allowlisted) ... ok +test_v2_root_missing_limit_files_do_not_hide_child_limits (test_diagnostics.DiagnosticsTests.test_v2_root_missing_limit_files_do_not_hide_child_limits) ... ok +test_actual_shard_loader_reversed_pairs_late_global_scale (test_integration.IntegrationTests.test_actual_shard_loader_reversed_pairs_late_global_scale) ... ok +test_gather_normalizes_strided_ids_before_either_kernel (test_integration.IntegrationTests.test_gather_normalizes_strided_ids_before_either_kernel) ... ok +test_gather_rejects_noncontiguous_output_before_launch (test_integration.IntegrationTests.test_gather_rejects_noncontiguous_output_before_launch) ... ok +test_loader_finalization_rejects_wrong_configured_shard_count (test_integration.IntegrationTests.test_loader_finalization_rejects_wrong_configured_shard_count) ... ok +test_opt_in_constructs_only_meta_table_and_keeps_default_unchanged (test_integration.IntegrationTests.test_opt_in_constructs_only_meta_table_and_keeps_default_unchanged) ... ok +test_packed_loader_rejects_malformed_shards_before_buffering (test_integration.IntegrationTests.test_packed_loader_rejects_malformed_shards_before_buffering) ... ok +test_packed_loader_requires_complete_tp1_global_layout (test_integration.IntegrationTests.test_packed_loader_requires_complete_tp1_global_layout) ... ok +test_packed_loader_requires_exactly_128_complete_shard_pairs (test_integration.IntegrationTests.test_packed_loader_requires_exactly_128_complete_shard_pairs) ... ok +test_pinned_class_constructs_packed_and_gathers_to_prefetch_output (test_integration.IntegrationTests.test_pinned_class_constructs_packed_and_gathers_to_prefetch_output) ... ok +test_synthetic_128_shard_shapes_pass_source_validation (test_integration.IntegrationTests.test_synthetic_128_shard_shapes_pass_source_validation) ... ok +test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory (test_invalid_token_packaging.InvalidTokenPackagingTest.test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory) ... ok +test_manifest_chain_and_runtime_compile (test_invalid_token_packaging.InvalidTokenPackagingTest.test_manifest_chain_and_runtime_compile) ... ok +test_patch_and_inventory_drift_fail_closed (test_invalid_token_packaging.InvalidTokenPackagingTest.test_patch_and_inventory_drift_fail_closed) ... ok +test_runtime_drift_fails_closed (test_invalid_token_packaging.InvalidTokenPackagingTest.test_runtime_drift_fails_closed) ... ok +test_changed_runtime_hashes_match_manifest (test_packaging.PackagingTests.test_changed_runtime_hashes_match_manifest) ... ok +test_patch_path_coverage_is_exact (test_packaging.PackagingTests.test_patch_path_coverage_is_exact) ... ok +test_preimage_drift_is_rejected_before_patching (test_packaging.PackagingTests.test_preimage_drift_is_rejected_before_patching) ... ok +test_source_drift_is_rejected (test_packaging.PackagingTests.test_source_drift_is_rejected) ... ok +test_all_finite_positive_e4m3_scales_and_fp8_rounding_ties (test_packed_ple.PackedPLETests.test_all_finite_positive_e4m3_scales_and_fp8_rounding_ties) ... ok +test_kernel_all_nibbles_group_scales_global_and_row_selection (test_packed_ple.PackedPLETests.test_kernel_all_nibbles_group_scales_global_and_row_selection) ... ok +test_storage_rejects_changed_destination_bounds (test_packed_ple.PackedPLETests.test_storage_rejects_changed_destination_bounds) ... ok +test_storage_rejects_invalid_layout_scale_and_incomplete_load (test_packed_ple.PackedPLETests.test_storage_rejects_invalid_layout_scale_and_incomplete_load) ... ok +test_storage_retains_bytes_copies_overlap_and_preserves_global_scale (test_packed_ple.PackedPLETests.test_storage_retains_bytes_copies_overlap_and_preserves_global_scale) ... ok +test_synthetic_row_selection_and_optional_fp8_reference (test_packed_ple.PackedPLETests.test_synthetic_row_selection_and_optional_fp8_reference) ... ok +test_disabled_retains_exact_target (test_private_head.PrivateHeadTests.test_disabled_retains_exact_target) ... ok +test_private_shell_does_not_mutate_target_registries (test_private_head.PrivateHeadTests.test_private_shell_does_not_mutate_target_registries) ... ok +test_actual_mtp_method_preserves_tied_path_and_uses_private_for_untied (test_production.ProductionTests.test_actual_mtp_method_preserves_tied_path_and_uses_private_for_untied) ... ok +test_external_command_exact_tokens_and_environment (test_production.ProductionTests.test_external_command_exact_tokens_and_environment) ... ok +test_invalid_gate_rejected_and_default_shared (test_production.ProductionTests.test_invalid_gate_rejected_and_default_shared) ... ok +test_only_hf_path_correction_differs_between_profiles (test_production.ProductionTests.test_only_hf_path_correction_differs_between_profiles) ... ok +test_production_clean_reconstruction (test_production.ProductionTests.test_production_clean_reconstruction) ... ok +test_builds_do_not_package_defaults_launchers (test_quickstart.QuickstartTests.test_builds_do_not_package_defaults_launchers) ... ok +test_external_profile_matches_deployed_settings (test_quickstart.QuickstartTests.test_external_profile_matches_deployed_settings) ... ok +test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory (test_qwen_multimodal_packaging.QwenMultimodalPackagingTest.test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory) ... ok +test_inventory_drift_fails_closed (test_qwen_multimodal_packaging.QwenMultimodalPackagingTest.test_inventory_drift_fails_closed) ... ok +test_manifest_chain_and_runtime_compile (test_qwen_multimodal_packaging.QwenMultimodalPackagingTest.test_manifest_chain_and_runtime_compile) ... ok +test_patch_drift_fails_closed (test_qwen_multimodal_packaging.QwenMultimodalPackagingTest.test_patch_drift_fails_closed) ... ok +test_runtime_drift_fails_closed (test_qwen_multimodal_packaging.QwenMultimodalPackagingTest.test_runtime_drift_fails_closed) ... ok +test_all_five_mounted_sources_fail_on_drift (test_responses_packaging.ResponsesPackagingTest.test_all_five_mounted_sources_fail_on_drift) ... ok +test_full_manifest_chain_and_new_file_count (test_responses_packaging.ResponsesPackagingTest.test_full_manifest_chain_and_new_file_count) ... ok +test_packaged_source_drift_fails_closed (test_responses_packaging.ResponsesPackagingTest.test_packaged_source_drift_fails_closed) ... ok +test_patch_drift_fails_closed (test_responses_packaging.ResponsesPackagingTest.test_patch_drift_fails_closed) ... ok +test_both_ranks_64_local_128_global_and_padding (test_tp2.TP2Tests.test_both_ranks_64_local_128_global_and_padding) ... ok +test_constructor_allocates_only_local_padded_bytes (test_tp2.TP2Tests.test_constructor_allocates_only_local_padded_bytes) ... ok +test_crossing_shard_simulated_sum_matches_tp1_and_reference (test_tp2.TP2Tests.test_crossing_shard_simulated_sum_matches_tp1_and_reference) ... ok +test_duplicate_completed_offrank_tensor_rejected_immediately (test_tp2.TP2Tests.test_duplicate_completed_offrank_tensor_rejected_immediately) ... ok +test_malformed_source_identifiers_are_not_silently_ignored (test_tp2.TP2Tests.test_malformed_source_identifiers_are_not_silently_ignored) ... ok +test_missing_half_and_duplicate_pending_offrank_rejected (test_tp2.TP2Tests.test_missing_half_and_duplicate_pending_offrank_rejected) ... ok +test_missing_nonintersecting_pair_fails_global_finalization (test_tp2.TP2Tests.test_missing_nonintersecting_pair_fails_global_finalization) ... ok +test_offrank_malformed_dtype_rejected_before_buffering (test_tp2.TP2Tests.test_offrank_malformed_dtype_rejected_before_buffering) ... ok +test_offrank_shapes_scales_and_partition_boundaries_fail_closed (test_tp2.TP2Tests.test_offrank_shapes_scales_and_partition_boundaries_fail_closed) ... ok +test_pending_offrank_has_no_payload_and_local_budget_fails_closed (test_tp2.TP2Tests.test_pending_offrank_has_no_payload_and_local_budget_fails_closed) ... ok +test_synthetic_metadata_both_ranks_without_payload_allocation (test_tp2.TP2Tests.test_synthetic_metadata_both_ranks_without_payload_allocation) ... ok +test_trailing_newline_shards_rejected_before_local_or_offrank_loading (test_tp2.TP2Tests.test_trailing_newline_shards_rejected_before_local_or_offrank_loading) ... ok +test_normal_and_prefetch_reduce_exactly_once_or_reject_scattered (test_tp2_collectives.CollectiveSeamTests.test_normal_and_prefetch_reduce_exactly_once_or_reject_scattered) ... ok +test_fc1_padding_preserves_weights_scales_and_slices_before_bias (test_vision_cpu.VisionTests.test_fc1_padding_preserves_weights_scales_and_slices_before_bias) ... ok +test_fc1_rejects_wrong_group_layout (test_vision_cpu.VisionTests.test_fc1_rejects_wrong_group_layout) ... ok +test_fc2_rejects_unproven_output_padding (test_vision_cpu.VisionTests.test_fc2_rejects_unproven_output_padding) ... ok +test_fc2_restores_logical_order_and_handles_no_bias (test_vision_cpu.VisionTests.test_fc2_restores_logical_order_and_handles_no_bias) ... ok + +---------------------------------------------------------------------- +Ran 90 tests in 5.552s + +OK diff --git a/provenance/pr8-final-invalid-token-green.log b/provenance/pr8-final-invalid-token-green.log new file mode 100644 index 0000000..d0a1e37 --- /dev/null +++ b/provenance/pr8-final-invalid-token-green.log @@ -0,0 +1,57 @@ +/home/kanadaj/sglang-pr-fix-8-final > test -f /home/kanadaj/nas/models/gpu-workstation/huggingface/local-inference-lab/Qwen3.8-Flash-Next-NVFP4/tokenizer.json  +[OK] +/home/kanadaj/sglang-pr-fix-8-final > python3 /home/kanadaj/sglang-pr-fix-8-final/scripts/verify_responses_compat.py --tokenizer /home/kanadaj/nas/models/gpu-workstation/huggingface/local-inference-lab/Qwen3.8-Flash-Next-NVFP4  +{"profile": "responses-phase-order-candidate", "source_files": 4392, "full_tree_verified": false} +[OK] +/home/kanadaj/sglang-pr-fix-8-final > python3 /home/kanadaj/sglang-pr-fix-8-final/scripts/verify_qwen_multimodal_alias.py  +{"profile": "qwen-multimodal-alias", "source_files": 4392, "full_tree_verified": false} +[OK] +/home/kanadaj/sglang-pr-fix-8-final > python3 /home/kanadaj/sglang-pr-fix-8-final/scripts/verify_invalid_token_failure.py  +{"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": false} +[OK] +/home/kanadaj/sglang-pr-fix-8-final > python3 -m unittest -v /home/kanadaj/sglang-pr-fix-8-final/tests/test_invalid_token_packaging.py  +test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory (tests.test_invalid_token_packaging.InvalidTokenPackagingTest.test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory) ... ok +test_manifest_chain_and_runtime_compile (tests.test_invalid_token_packaging.InvalidTokenPackagingTest.test_manifest_chain_and_runtime_compile) ... ok +test_patch_and_inventory_drift_fail_closed (tests.test_invalid_token_packaging.InvalidTokenPackagingTest.test_patch_and_inventory_drift_fail_closed) ... ok +test_runtime_drift_fails_closed (tests.test_invalid_token_packaging.InvalidTokenPackagingTest.test_runtime_drift_fails_closed) ... ok + +---------------------------------------------------------------------- +Ran 4 tests in 0.067s + +OK +[OK] +/home/kanadaj/sglang-pr-fix-8-final > docker image inspect --format \{\{.Id\}\} kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404  +sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 +[OK] +/home/kanadaj/sglang-pr-fix-8-final > docker run --rm --pull never --network none --read-only --cap-drop all --security-opt no-new-privileges --cpus 4 --memory 12g --pids-limit 512 --user 1000:1000 --tmpfs /tmp:rw\,exec\,size=2g\,mode=1777\,uid=1000\,gid=1000 -e CUDA_VISIBLE_DEVICES= -e OMP_NUM_THREADS=1 -e MKL_NUM_THREADS=1 -e HOME=/tmp -e XDG_CACHE_HOME=/tmp/cache -e PYTHONDONTWRITEBYTECODE=1 -e QWEN_TOKENIZER_PATH=/home/kanadaj/nas/models/gpu-workstation/huggingface/local-inference-lab/Qwen3.8-Flash-Next-NVFP4 -v /home/kanadaj/nas/models/gpu-workstation/huggingface/local-inference-lab/Qwen3.8-Flash-Next-NVFP4:/home/kanadaj/nas/models/gpu-workstation/huggingface/local-inference-lab/Qwen3.8-Flash-Next-NVFP4:ro -v /home/kanadaj/sglang-pr-fix-8-final:/repo:ro -v /home/kanadaj/sglang-pr-fix-8-final/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_completions.py:ro -v /home/kanadaj/sglang-pr-fix-8-final/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py:ro -v /home/kanadaj/sglang-pr-fix-8-final/runtime/python/sglang/srt/entrypoints/openai/protocol.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:ro -v /home/kanadaj/sglang-pr-fix-8-final/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:ro -v /home/kanadaj/sglang-pr-fix-8-final/runtime/python/sglang/srt/entrypoints/openai/responses_compat.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py:ro -v /home/kanadaj/sglang-pr-fix-8-final/runtime/python/sglang/srt/function_call/qwen3_coder_detector.py:/sgl-workspace/sglang/python/sglang/srt/function_call/qwen3_coder_detector.py:ro -v /home/kanadaj/sglang-pr-fix-8-final/runtime/python/sglang/srt/multimodal/processors/qwen_vl.py:/sgl-workspace/sglang/python/sglang/srt/multimodal/processors/qwen_vl.py:ro -v /home/kanadaj/sglang-pr-fix-8-final/runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py:/sgl-workspace/sglang/python/sglang/srt/managers/schedule_batch.py:ro --entrypoint python3 kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 /repo/tests/runtime_invalid_token_failure.py -v  +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 14:06:57.123000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok +test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok +test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok +test_top_level_xhigh_reaches_real_tokenizer (runtime_chat_effort.ChatEffortTest.test_top_level_xhigh_reaches_real_tokenizer) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:1039: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field + "max_new_tokens": self.max_completion_tokens or self.max_tokens, +ok +test_abort_cleanup_handles_serialized_status (__main__.InvalidTokenFailureTest.test_abort_cleanup_handles_serialized_status) ... ok +test_chat_and_messages_stream_serialized_failure (__main__.InvalidTokenFailureTest.test_chat_and_messages_stream_serialized_failure) ... Forwarding upstream stream error (api_error): Generation produced an invalid token ID. +ok +test_completions_stream_graceful_abort_remains_choice (__main__.InvalidTokenFailureTest.test_completions_stream_graceful_abort_remains_choice) ... ok +test_completions_stream_serialized_failure_is_sse_error (__main__.InvalidTokenFailureTest.test_completions_stream_serialized_failure_is_sse_error) ... ok +test_failed_response_cannot_be_replayed_as_predecessor (__main__.InvalidTokenFailureTest.test_failed_response_cannot_be_replayed_as_predecessor) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1982: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_failed_response_retrieval_preserves_failure_and_partial_output (__main__.InvalidTokenFailureTest.test_failed_response_retrieval_preserves_failure_and_partial_output) ... ok +test_graceful_abort_remains_cancelled (__main__.InvalidTokenFailureTest.test_graceful_abort_remains_cancelled) ... ok +test_invalid_first_token_never_reaches_decode (__main__.InvalidTokenFailureTest.test_invalid_first_token_never_reaches_decode) ... ok +test_invalid_token_is_failure_even_past_length_cap (__main__.InvalidTokenFailureTest.test_invalid_token_is_failure_even_past_length_cap) ... ok +test_ordinary_scheduler_finishes_are_unchanged (__main__.InvalidTokenFailureTest.test_ordinary_scheduler_finishes_are_unchanged) ... ok +test_responses_full_and_stream_expose_failure (__main__.InvalidTokenFailureTest.test_responses_full_and_stream_expose_failure) ... ok + +---------------------------------------------------------------------- +Ran 15 tests in 0.799s + +OK +[OK] diff --git a/provenance/pr8-final-multimodal-4.log b/provenance/pr8-final-multimodal-4.log new file mode 100644 index 0000000..5e91453 --- /dev/null +++ b/provenance/pr8-final-multimodal-4.log @@ -0,0 +1,23 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 14:09:11.822000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_image_offset_positions_match_registered_architecture (__main__.QwenMultimodalAliasTest.test_image_offset_positions_match_registered_architecture) ... [transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} +[transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} +ok +test_preprocessed_video_preserves_metadata_and_sampling (__main__.QwenMultimodalAliasTest.test_preprocessed_video_preserves_metadata_and_sampling) ... [transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} +[transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} +[transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} +ok +test_release_processor_enables_existing_worker_policy (__main__.QwenMultimodalAliasTest.test_release_processor_enables_existing_worker_policy) ... [transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} +[transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} +ok +test_video_timestamp_positions_and_embedding_slices_match (__main__.QwenMultimodalAliasTest.test_video_timestamp_positions_and_embedding_slices_match) ... [transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} +[transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} +ok + +---------------------------------------------------------------------- +Ran 4 tests in 0.011s + +OK diff --git a/provenance/pr8-final-packaging-17.log b/provenance/pr8-final-packaging-17.log new file mode 100644 index 0000000..a64000f --- /dev/null +++ b/provenance/pr8-final-packaging-17.log @@ -0,0 +1,22 @@ +test_changed_runtime_hashes_match_manifest (tests.test_packaging.PackagingTests.test_changed_runtime_hashes_match_manifest) ... ok +test_patch_path_coverage_is_exact (tests.test_packaging.PackagingTests.test_patch_path_coverage_is_exact) ... ok +test_preimage_drift_is_rejected_before_patching (tests.test_packaging.PackagingTests.test_preimage_drift_is_rejected_before_patching) ... ok +test_source_drift_is_rejected (tests.test_packaging.PackagingTests.test_source_drift_is_rejected) ... ok +test_all_five_mounted_sources_fail_on_drift (tests.test_responses_packaging.ResponsesPackagingTest.test_all_five_mounted_sources_fail_on_drift) ... ok +test_full_manifest_chain_and_new_file_count (tests.test_responses_packaging.ResponsesPackagingTest.test_full_manifest_chain_and_new_file_count) ... ok +test_packaged_source_drift_fails_closed (tests.test_responses_packaging.ResponsesPackagingTest.test_packaged_source_drift_fails_closed) ... ok +test_patch_drift_fails_closed (tests.test_responses_packaging.ResponsesPackagingTest.test_patch_drift_fails_closed) ... ok +test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory (tests.test_qwen_multimodal_packaging.QwenMultimodalPackagingTest.test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory) ... ok +test_inventory_drift_fails_closed (tests.test_qwen_multimodal_packaging.QwenMultimodalPackagingTest.test_inventory_drift_fails_closed) ... ok +test_manifest_chain_and_runtime_compile (tests.test_qwen_multimodal_packaging.QwenMultimodalPackagingTest.test_manifest_chain_and_runtime_compile) ... ok +test_patch_drift_fails_closed (tests.test_qwen_multimodal_packaging.QwenMultimodalPackagingTest.test_patch_drift_fails_closed) ... ok +test_runtime_drift_fails_closed (tests.test_qwen_multimodal_packaging.QwenMultimodalPackagingTest.test_runtime_drift_fails_closed) ... ok +test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory (tests.test_invalid_token_packaging.InvalidTokenPackagingTest.test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory) ... ok +test_manifest_chain_and_runtime_compile (tests.test_invalid_token_packaging.InvalidTokenPackagingTest.test_manifest_chain_and_runtime_compile) ... ok +test_patch_and_inventory_drift_fail_closed (tests.test_invalid_token_packaging.InvalidTokenPackagingTest.test_patch_and_inventory_drift_fail_closed) ... ok +test_runtime_drift_fails_closed (tests.test_invalid_token_packaging.InvalidTokenPackagingTest.test_runtime_drift_fails_closed) ... ok + +---------------------------------------------------------------------- +Ran 17 tests in 0.188s + +OK diff --git a/provenance/pr8-final-responses-75.log b/provenance/pr8-final-responses-75.log new file mode 100644 index 0000000..024ae7e --- /dev/null +++ b/provenance/pr8-final-responses-75.log @@ -0,0 +1,162 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 14:08:23.679000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok +test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok +test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok +test_top_level_xhigh_reaches_real_tokenizer (runtime_chat_effort.ChatEffortTest.test_top_level_xhigh_reaches_real_tokenizer) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:1039: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field + "max_new_tokens": self.max_completion_tokens or self.max_tokens, +ok +test_background_requires_storage (__main__.MockHTTPTest.test_background_requires_storage) ... /usr/local/lib/python3.12/dist-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead. + from starlette.testclient import TestClient as TestClient # noqa +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:341: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(error)) +ok +test_direct_flat_result_retains_typed_api (__main__.MockHTTPTest.test_direct_flat_result_retains_typed_api) ... ok +test_empty_reasoning_implicit_tool_close_allows_renewal (__main__.MockHTTPTest.test_empty_reasoning_implicit_tool_close_allows_renewal) ... ok +test_failed_and_disconnected_stream_preserves_stored_identity (__main__.MockHTTPTest.test_failed_and_disconnected_stream_preserves_stored_identity) ... ok +test_fix2_custom_delimiter_limit_and_json_alternative (__main__.MockHTTPTest.test_fix2_custom_delimiter_limit_and_json_alternative) ... Parsed parameter 'other' is not defined in the tool parameters for tool 'patch', directly returning the string value. +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:696: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) +Parsed parameter 'other' is not defined in the tool parameters for tool 'patch', directly returning the string value. +ok +test_fix2_custom_history_rejects_embedded_function_after_gap (__main__.MockHTTPTest.test_fix2_custom_history_rejects_embedded_function_after_gap) ... ok +test_fix2_embedded_flat_and_history (__main__.MockHTTPTest.test_fix2_embedded_flat_and_history) ... ok +test_fix2_embedded_identity_rejection (__main__.MockHTTPTest.test_fix2_embedded_identity_rejection) ... ok +test_fix2_embedded_supported_and_custom_distinctions (__main__.MockHTTPTest.test_fix2_embedded_supported_and_custom_distinctions) ... ok +test_fix2_selected_single_required_multiple (__main__.MockHTTPTest.test_fix2_selected_single_required_multiple) ... ok +test_fix2_terminal_cardinality (__main__.MockHTTPTest.test_fix2_terminal_cardinality) ... ok +test_fix2_unsupported_embedded_forms (__main__.MockHTTPTest.test_fix2_unsupported_embedded_forms) ... ok +test_fix3_malformed_success_remains_rejected (__main__.MockHTTPTest.test_fix3_malformed_success_remains_rejected) ... ok +test_fix3_native_auto_terminal_text (__main__.MockHTTPTest.test_fix3_native_auto_terminal_text) ... ok +test_fix3_partial_no_store (__main__.MockHTTPTest.test_fix3_partial_no_store) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1974: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_fix3_partial_terminal_matrix (__main__.MockHTTPTest.test_fix3_partial_terminal_matrix) ... ok +test_fix3_terminal_text_and_no_store (__main__.MockHTTPTest.test_fix3_terminal_text_and_no_store) ... ok +test_fixer_conflicting_forced_representations_before_generation (__main__.MockHTTPTest.test_fixer_conflicting_forced_representations_before_generation) ... ok +test_fixer_descriptions_reach_rendered_prompt (__main__.MockHTTPTest.test_fixer_descriptions_reach_rendered_prompt) ... ok +test_fixer_generated_history_survives_output_only_and_multiple_turns (__main__.MockHTTPTest.test_fixer_generated_history_survives_output_only_and_multiple_turns) ... ok +test_fixer_image_history_survives_no_declaration_gaps (__main__.MockHTTPTest.test_fixer_image_history_survives_no_declaration_gaps) ... ok +test_fixer_pinned_sdk_client_terminal_roundtrip (__main__.MockHTTPTest.test_fixer_pinned_sdk_client_terminal_roundtrip) ... /usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...: 'call'}], format=None), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +/usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...tion', 'name': 'call'}]), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +/usr/local/lib/python3.12/dist-packages/pydantic/main.py:542: UserWarning: Pydantic serializer warnings: + PydanticSerializationUnexpectedValue(Expected `literal['function']` - serialized value may not be as expected [field_name='type', input_value='namespace', input_type=str]) + PydanticSerializationUnexpectedValue(Expected `FileSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ComputerTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `Mcp` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CodeInterpreter` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `ImageGeneration` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `LocalShell` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `CustomTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + PydanticSerializationUnexpectedValue(Expected `WebSearchPreviewTool` - serialized value may not be as expected [field_name='tools', input_value=FunctionTool(name='sdk', ...stom', 'name': 'call'}]), input_type=FunctionTool]) + return self.__pydantic_serializer__.to_json( +ok +test_fixer_pinned_sdk_output_and_event_roundtrip_replay (__main__.MockHTTPTest.test_fixer_pinned_sdk_output_and_event_roundtrip_replay) ... ok +test_fixer_whole_history_collision_parity (__main__.MockHTTPTest.test_fixer_whole_history_collision_parity) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:341: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(error)) +ok +test_implicit_tool_close_allows_renewed_reasoning (__main__.MockHTTPTest.test_implicit_tool_close_allows_renewed_reasoning) ... ok +test_mock_http_custom_literal_angles_preserve_order_and_payload (__main__.MockHTTPTest.test_mock_http_custom_literal_angles_preserve_order_and_payload) ... ok +test_mock_http_custom_native_empty_and_escaped (__main__.MockHTTPTest.test_mock_http_custom_native_empty_and_escaped) ... ok +test_mock_http_custom_raw_and_stateless_replay (__main__.MockHTTPTest.test_mock_http_custom_raw_and_stateless_replay) ... ok +test_mock_http_flat_history_without_active_tools (__main__.MockHTTPTest.test_mock_http_flat_history_without_active_tools) ... ok +test_mock_http_flat_regression (__main__.MockHTTPTest.test_mock_http_flat_regression) ... ok +test_mock_http_forced_choice_cannot_emit_other_declared_tool (__main__.MockHTTPTest.test_mock_http_forced_choice_cannot_emit_other_declared_tool) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:696: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response(str(e)) +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3102, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2993, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 121, in output_identity + raise ValueError("Generated tool call does not match forced tool choice") +ValueError: Generated tool call does not match forced tool choice +ok +test_mock_http_json_schema_and_explicit_nulls (__main__.MockHTTPTest.test_mock_http_json_schema_and_explicit_nulls) ... ok +test_mock_http_multimodal_tool_result_and_alias_provenance (__main__.MockHTTPTest.test_mock_http_multimodal_tool_result_and_alias_provenance) ... ok +test_mock_http_namespace_nonstream_and_stateful_replay (__main__.MockHTTPTest.test_mock_http_namespace_nonstream_and_stateful_replay) ... ok +test_mock_http_namespace_sse_lifecycle (__main__.MockHTTPTest.test_mock_http_namespace_sse_lifecycle) ... ok +test_mock_http_native_auto_and_required (__main__.MockHTTPTest.test_mock_http_native_auto_and_required) ... ok +test_mock_http_native_unknown_fails_closed (__main__.MockHTTPTest.test_mock_http_native_unknown_fails_closed) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. +Error while streaming /v1/responses +Traceback (most recent call last): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3102, in responses_stream_generator_non_harmony + for ev in _emit_tool_calls(opening): + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2993, in _emit_tool_calls + request._compat_registry.output_identity(state["name"]) + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 122, in output_identity + return self.identity(qualified) + ^^^^^^^^^^^^^^^^^^^^^^^^ + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 116, in identity + raise ValueError(f"Unknown generated tool identity: {qualified}") +ValueError: Unknown generated tool identity: workspace.NOT_DECLARED +ok +test_mock_http_parallel_dotted_and_duplicate_local_names (__main__.MockHTTPTest.test_mock_http_parallel_dotted_and_duplicate_local_names) ... ok +test_mock_http_rejected_call_cannot_be_replayed_from_store (__main__.MockHTTPTest.test_mock_http_rejected_call_cannot_be_replayed_from_store) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. +/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:1974: FastAPIDeprecationWarning: ORJSONResponse is deprecated, FastAPI now serializes data directly to JSON bytes via Pydantic when a return type or response model is set, which is faster and doesn't need a custom response class. Read more in the FastAPI docs: https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model and https://fastapi.tiangolo.com/tutorial/response-model/ + return self.create_error_response( +ok +test_mock_http_rejects_unknown_and_forced_invalid (__main__.MockHTTPTest.test_mock_http_rejects_unknown_and_forced_invalid) ... ok +test_mock_http_replay_cannot_forge_flat_dotted_identity (__main__.MockHTTPTest.test_mock_http_replay_cannot_forge_flat_dotted_identity) ... ok +test_mock_http_request_provenance_and_unrelated_model (__main__.MockHTTPTest.test_mock_http_request_provenance_and_unrelated_model) ... ok +test_native_tool_implicitly_closes_open_reasoning (__main__.MockHTTPTest.test_native_tool_implicitly_closes_open_reasoning) ... ok +test_native_tool_payload_markers_after_reasoning_remain_data (__main__.MockHTTPTest.test_native_tool_payload_markers_after_reasoning_remain_data) ... ok +test_nonstream_message_phase_matches_remaining_tool_calls (__main__.MockHTTPTest.test_nonstream_message_phase_matches_remaining_tool_calls) ... ok +test_qwen4_exp_is_negative_control_for_ordered_nonstream (__main__.MockHTTPTest.test_qwen4_exp_is_negative_control_for_ordered_nonstream) ... ok +test_qwen4_stream_reasoning_is_chunking_negative_control (__main__.MockHTTPTest.test_qwen4_stream_reasoning_is_chunking_negative_control) ... ok +test_qwen_adjacent_reasoning_blocks_remain_distinct (__main__.MockHTTPTest.test_qwen_adjacent_reasoning_blocks_remain_distinct) ... ok +test_qwen_literal_angle_brackets_survive_text_tool_text (__main__.MockHTTPTest.test_qwen_literal_angle_brackets_survive_text_tool_text) ... ok +test_qwen_nonstream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_renewed_reasoning_order) ... ok +test_qwen_nonstream_preserves_text_tool_text_order (__main__.MockHTTPTest.test_qwen_nonstream_preserves_text_tool_text_order) ... ok +test_qwen_ordered_nonstream_preserves_requested_logprobs (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_requested_logprobs) ... ok +test_qwen_ordered_nonstream_preserves_usage_details (__main__.MockHTTPTest.test_qwen_ordered_nonstream_preserves_usage_details) ... ok +test_qwen_second_reasoning_block_preserves_order (__main__.MockHTTPTest.test_qwen_second_reasoning_block_preserves_order) ... ok +test_qwen_stream_has_no_generic_angle_boundary_split (__main__.MockHTTPTest.test_qwen_stream_has_no_generic_angle_boundary_split) ... ok +test_qwen_stream_preserves_renewed_reasoning_order (__main__.MockHTTPTest.test_qwen_stream_preserves_renewed_reasoning_order) ... ok +test_qwen_stream_preserves_split_reasoning_marker_boundaries (__main__.MockHTTPTest.test_qwen_stream_preserves_split_reasoning_marker_boundaries) ... ok +test_qwen_stream_preserves_text_tool_text_order_for_any_chunking (__main__.MockHTTPTest.test_qwen_stream_preserves_text_tool_text_order_for_any_chunking) ... ok +test_qwen_tool_then_renewed_reasoning_preserves_order (__main__.MockHTTPTest.test_qwen_tool_then_renewed_reasoning_preserves_order) ... ok +test_required_json_marker_like_values_remain_data (__main__.MockHTTPTest.test_required_json_marker_like_values_remain_data) ... ok +test_text_streams_before_phase_is_resolved (__main__.MockHTTPTest.test_text_streams_before_phase_is_resolved) ... ok +test_collisions_and_malformed_members (__main__.ResponsesCompatTest.test_collisions_and_malformed_members) ... ok +test_custom_declaration_reaches_chat (__main__.ResponsesCompatTest.test_custom_declaration_reaches_chat) ... ok +test_custom_grammar_visible (__main__.ResponsesCompatTest.test_custom_grammar_visible) ... ok +test_harmony_same_request_call_replay (__main__.ResponsesCompatTest.test_harmony_same_request_call_replay) ... ok +test_image_result_preserved (__main__.ResponsesCompatTest.test_image_result_preserved) ... ok +test_message_phase_survives_response_models (__main__.ResponsesCompatTest.test_message_phase_survives_response_models) ... ok +test_namespace_declaration_reaches_chat (__main__.ResponsesCompatTest.test_namespace_declaration_reaches_chat) ... ok +test_qualified_replay (__main__.ResponsesCompatTest.test_qualified_replay) ... ok +test_qwen_replay_preserves_assistant_stage_order (__main__.ResponsesCompatTest.test_qwen_replay_preserves_assistant_stage_order) ... ok +test_stored_response_replays_reasoning_phase_and_call_together (__main__.ResponsesCompatTest.test_stored_response_replays_reasoning_phase_and_call_together) ... ok + +---------------------------------------------------------------------- +Ran 75 tests in 5.024s + +OK diff --git a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py index 74415ba..9234892 100644 --- a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py +++ b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py @@ -1072,7 +1072,7 @@ def _process_messages( """Process chat messages and apply chat template""" if self._uses_qwen_flash_next_effort_aliases(): # Rendering-only compatibility: retain literal API effort/provenance. - # This common path also serves Responses and message tokenization. + # This path also serves Responses, Anthropic Messages, and tokenization. request = request.model_copy() ctk = dict(request.chat_template_kwargs or {}) effort = ctk.pop("reasoning_effort", None) @@ -1080,7 +1080,9 @@ def _process_messages( effort = request.reasoning_effort if effort is None: effort = self.default_chat_template_kwargs.get("reasoning_effort") - if effort in ("high", "max"): + if effort == "minimal": + effort = "low" + elif effort in ("high", "max"): effort = "xhigh" request.reasoning_effort = effort request.chat_template_kwargs = ctk diff --git a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py index 05742d5..2a242a3 100644 --- a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -7,6 +7,7 @@ import asyncio import json import logging +import re import time from contextlib import AsyncExitStack from http import HTTPStatus @@ -18,7 +19,6 @@ from fastapi import Request from fastapi.responses import ORJSONResponse from openai.types.responses import ( - ResponseOutputMessage, ResponseOutputText, ResponseReasoningItem, ) @@ -61,6 +61,9 @@ MessageProcessingResult, PromptTokenUsageInfo, RequestResponseMetadata, + ResponseOutputMessage, + ResponsePhasedOutputItemAddedEvent, + ResponsePhasedOutputItemDoneEvent, ResponsesRequest, ResponsesResponse, Tool, @@ -140,6 +143,67 @@ def _should_emit_normal_text_as_message( return True +_QWEN_STRUCTURAL_MARKER_RE = re.compile( + r"(||||" + r"\r\n]+>||" + r"\r\n]+>|)" +) +_QWEN_FIXED_STRUCTURAL_MARKERS = ( + "", + "", + "", + "", + "", + "", +) +_QWEN_DYNAMIC_STRUCTURAL_PREFIXES = ("\r\n]", text[1:])) + for prefix in _QWEN_DYNAMIC_STRUCTURAL_PREFIXES + ) + + +class _QwenStructuralMarkerBuffer: + """Keep only possible split control markers between engine chunks.""" + + def __init__(self) -> None: + self.pending = "" + + def feed(self, text: str, *, final: bool) -> list[str]: + text = self.pending + text + self.pending = "" + parts: list[str] = [] + cursor = 0 + for match in _QWEN_STRUCTURAL_MARKER_RE.finditer(text): + if match.start() > cursor: + parts.append(text[cursor : match.start()]) + parts.append(match.group(0)) + cursor = match.end() + + remainder = text[cursor:] + if not final: + candidate_start = remainder.rfind("<") + if candidate_start >= 0 and _is_qwen_structural_marker_prefix( + remainder[candidate_start:] + ): + self.pending = remainder[candidate_start:] + remainder = remainder[:candidate_start] + if remainder: + parts.append(remainder) + return parts or ([""] if final else []) + + +def _split_qwen_structural_markers(text: str) -> list[str]: + """Split only Qwen parser control markers, not arbitrary angle brackets.""" + return _QwenStructuralMarkerBuffer().feed(text, final=True) + + class OpenAIServingResponses(OpenAIServingChat): """Handler for /v1/responses requests""" @@ -746,19 +810,56 @@ async def responses_full_generator( ) status = self._status_from_finish_reason(finish_reason) + final_text = final_res["text"] + model_type = self.tokenizer_manager.model_config.hf_config.model_type + leading_text, think_marker, trailing_text = final_text.partition("") + requires_tool_output = request.tool_choice == "required" or isinstance( + request.tool_choice, dict + ) + ordered_tool_boundary = ( + self.tool_call_parser == "qwen3_coder" + and request.tool_choice != "none" + and re.search( + r"\s*\s*\S", final_text, re.DOTALL + ) + ) + ordered_reasoning_boundary = ( + self.reasoning_parser in {"qwen3", "qwen3-thinking"} + and not ( + requires_tool_output and self.tool_call_parser != "qwen3_coder" + ) + and think_marker + and (leading_text.strip() or "" in trailing_text) + ) + needs_ordered_qwen_parse = ( + status == "completed" + and model_type + in {"qwen3_8_flash_next", "qwen3_8_flash_next_text"} + and (ordered_tool_boundary or ordered_reasoning_boundary) + ) output_logprobs = ( _build_output_text_logprobs(meta_info) if request.is_include_output_logprobs() and isinstance(meta_info, dict) else None ) - output = self._make_response_output_items( - request, - final_res["text"], - tokenizer, - output_logprobs=output_logprobs, - require_reasoning=require_reasoning, - status=status, - ) + if needs_ordered_qwen_parse: + output = self._make_qwen_ordered_output_items( + request, + tokenizer, + final_text, + output_logprobs=output_logprobs, + require_reasoning=require_reasoning, + status=status, + ) + else: + output = self._make_response_output_items( + request, + final_text, + tokenizer, + output_logprobs=output_logprobs, + require_reasoning=require_reasoning, + status=status, + ) if meta_info is not None: num_prompt_tokens = meta_info.get("prompt_tokens", 0) @@ -919,7 +1020,13 @@ def _make_response_output_items( status: str = "completed", ): chat_tools = self._response_tools_to_chat_tools(request) - if self.reasoning_parser: + is_required = request.tool_choice == "required" or isinstance( + request.tool_choice, dict + ) + uses_required_json = ( + bool(chat_tools) and is_required and self.tool_call_parser is None + ) + if self.reasoning_parser and not uses_required_json: reasoning_parser = ReasoningParser( model_type=self.reasoning_parser, stream_reasoning=False, @@ -967,7 +1074,6 @@ def _make_response_output_items( ) output_items.append(reasoning_item) - is_required = request.tool_choice == "required" or isinstance(request.tool_choice, dict) if status != "completed" and chat_tools and is_required: return output_items tool_call_items: list[ResponseFunctionToolCall] = [] @@ -1038,11 +1144,259 @@ def _make_response_output_items( role="assistant", status="completed", type="message", + phase="commentary" if tool_call_items else "final_answer", ) output_items.append(message) output_items.extend(tool_call_items) return output_items + def _make_qwen_ordered_output_items( + self, + request: ResponsesRequest, + tokenizer: Any, + final_output: str, + output_logprobs: Optional[list] = None, + *, + require_reasoning: bool, + status: str, + ) -> list: + """Parse completed Qwen structural markers into typed items in wire order.""" + chat_tools = self._response_tools_to_chat_tools(request) + tool_parser: Optional[FunctionCallParser] = None + if chat_tools and self.tool_call_parser and request.tool_choice != "none": + tool_parser = FunctionCallParser( + chat_tools, + self.tool_call_parser, + tokenizer=self.tokenizer_manager.tokenizer, + ) + assert tool_parser is not None + if hasattr(tool_parser.detector, "preserve_raw_input_tools"): + tool_parser.detector.preserve_raw_input_tools = ( + request._custom_tool_names + ) + + def new_reasoning_parser() -> ReasoningParser: + return ReasoningParser( + model_type=self.reasoning_parser, + stream_reasoning=True, + force_reasoning=( + self.template_manager.force_reasoning or require_reasoning + ), + request=request, + tokenizer=tokenizer, + tool_call_parser_active=tool_parser is not None, + ) + + reasoning_parser_obj: Optional[ReasoningParser] = ( + new_reasoning_parser() if self.reasoning_parser else None + ) + reasoning_block_closed = False + reasoning_block_started = False + inside_tool_call = False + + output_items: list = [] + message_text = "" + message_logprobs: list[Logprob] = [] + reasoning_text = "" + tool_states: dict[int, dict[str, str]] = {} + wants_summary = self._wants_reasoning_summary(request) + output_logprob_index = 0 + + def take_part_logprobs(part: str) -> list[Logprob]: + """Consume logprobs only when their tokens exactly cover this part.""" + nonlocal output_logprob_index + if output_logprobs is None or not part: + return [] + start = output_logprob_index + text = "" + entries: list[Logprob] = [] + while output_logprob_index < len(output_logprobs): + entry = output_logprobs[output_logprob_index] + candidate = text + entry.token + if not part.startswith(candidate): + output_logprob_index = start + return [] + text = candidate + entries.append(entry) + output_logprob_index += 1 + if text == part: + return entries + output_logprob_index = start + return [] + + def close_message(phase: Any) -> None: + nonlocal message_text, message_logprobs + if not message_text: + return + output_items.append( + ResponseOutputMessage( + id=f"msg_{random_uuid()}", + type="message", + role="assistant", + content=[ + ResponseOutputText( + type="output_text", + text=message_text, + annotations=[], + logprobs=( + message_logprobs + if output_logprobs is not None + else None + ), + ) + ], + status="completed", + phase=phase, + ) + ) + message_text = "" + message_logprobs = [] + + def close_reasoning() -> None: + nonlocal reasoning_text + if not reasoning_text: + return + output_items.append( + ResponseReasoningItem( + id=f"rs_{random_uuid()}", + type="reasoning", + summary=( + [ + ResponseReasoningSummary( + type="summary_text", text=reasoning_text + ) + ] + if wants_summary + else [] + ), + content=[ + ResponseReasoningTextContent( + type="reasoning_text", text=reasoning_text + ) + ], + status="completed", + ) + ) + reasoning_text = "" + + def close_tools(except_index: Optional[int] = None) -> None: + for tool_index in list(tool_states): + if tool_index == except_index: + continue + state = tool_states.pop(tool_index) + output_items.append( + ResponseFunctionToolCall( + arguments=state["arguments"], + call_id=state["call_id"], + name=state["name"], + type="function_call", + id=state["item_id"], + status="completed", + ) + ) + + def emit_calls(calls: list[ToolCallItem]) -> None: + if calls: + close_reasoning() + close_message("commentary") + for call in calls: + state = tool_states.get(call.tool_index) + if state is None: + close_tools() + state = { + "item_id": f"fc_{random_uuid()[:8]}", + "call_id": f"call_{random_uuid()[:24]}", + "name": call.name or "", + "arguments": "", + } + tool_states[call.tool_index] = state + elif call.name: + state["name"] = call.name + if call.parameters: + state["arguments"] += call.parameters + + def consume( + normal_text: str, + calls: list[ToolCallItem], + normal_logprobs: Optional[list[Logprob]] = None, + ) -> None: + nonlocal message_text, message_logprobs + continuing = [ + call for call in calls if call.tool_index in tool_states + ] + opening = [ + call for call in calls if call.tool_index not in tool_states + ] + emit_calls(continuing) + if normal_text and _should_emit_normal_text_as_message( + normal_text, + any_tool_call_in_progress=bool(tool_states), + ): + close_reasoning() + close_tools() + message_text += normal_text + message_logprobs.extend(normal_logprobs or []) + emit_calls(opening) + + for part in _split_qwen_structural_markers(final_output): + part_logprobs = take_part_logprobs(part) + entering_tool_call = tool_parser is not None and part == "" + if ( + part == "" + and not inside_tool_call + and reasoning_block_closed + and reasoning_parser_obj is not None + ): + close_reasoning() + reasoning_parser_obj = new_reasoning_parser() + reasoning_block_closed = False + reasoning_block_started = False + if part == "" and not inside_tool_call: + reasoning_block_started = True + if reasoning_parser_obj is not None and not inside_tool_call: + reasoning_chunk, normal = reasoning_parser_obj.parse_stream_chunk(part) + else: + reasoning_chunk, normal = None, part + if part == "" and not inside_tool_call: + reasoning_block_closed = True + reasoning_block_started = False + if reasoning_chunk: + close_message("commentary") + close_tools() + reasoning_text += reasoning_chunk + if entering_tool_call and (reasoning_block_started or reasoning_text): + reasoning_block_closed = True + reasoning_block_started = False + if entering_tool_call: + inside_tool_call = True + if tool_parser is not None: + normal_text, calls = tool_parser.parse_stream_chunk(normal) + consume(normal_text or "", list(calls), part_logprobs) + else: + consume(normal or "", [], part_logprobs) + if tool_parser is not None and part == "": + inside_tool_call = False + + if reasoning_parser_obj is not None: + end_reasoning, end_normal = reasoning_parser_obj.parse_stream_end() + if end_reasoning: + close_message("commentary") + reasoning_text += end_reasoning + else: + end_normal = "" + if tool_parser is not None: + normal_text, calls = tool_parser.parse_stream_chunk(end_normal or "") + end_text, end_calls = tool_parser.parse_stream_end() + consume((normal_text or "") + end_text, list(calls) + list(end_calls)) + else: + consume(end_normal or "", []) + + close_reasoning() + close_message("final_answer") + if status == "completed": + close_tools() + return output_items + def _make_response_output_items_with_harmony( self, context: HarmonyContext, @@ -1261,10 +1615,39 @@ def _output_message_text(output_item: Any) -> Optional[str]: @staticmethod def _merge_consecutive_assistant_messages( messages: list, + *, + preserve_qwen_order: bool = False, ) -> list: """Collapse runs of consecutive ``assistant`` dicts into one entry, joining ``content`` and concatenating ``tool_calls`` and ``reasoning_content`` so a logical turn renders as a single block.""" + + def compatible(left: dict, right: dict) -> bool: + left_phase, right_phase = left.get("phase"), right.get("phase") + if not preserve_qwen_order: + return left_phase == right_phase + if ( + left_phase is not None + and right_phase is not None + and left_phase != right_phase + ): + return False + if left_phase == "final_answer" and ( + right.get("reasoning_content") or right.get("tool_calls") + ): + return False + + # Qwen renders reasoning, then content, then calls within each block. + # A restarted sequence must remain in a separate assistant block. + fields = ("reasoning_content", "content", "tool_calls") + left_stages = [i for i, field in enumerate(fields) if left.get(field)] + right_stages = [i for i, field in enumerate(fields) if right.get(field)] + return ( + not left_stages + or not right_stages + or max(left_stages) <= min(right_stages) + ) + merged: list = [] for msg in messages: if ( @@ -1273,8 +1656,16 @@ def _merge_consecutive_assistant_messages( and merged and isinstance(merged[-1], dict) and merged[-1].get("role") == "assistant" + and compatible(merged[-1], msg) ): prev = merged[-1] = dict(merged[-1]) + # Reasoning and calls have no phase; retain the text item's phase. + if ( + preserve_qwen_order + and prev.get("phase") is None + and msg.get("phase") is not None + ): + prev["phase"] = msg["phase"] # Lift mixed str/list content to list parts so non-text parts # (e.g. image_url) survive when the two sides differ in shape. new_content = msg.get("content") @@ -1334,13 +1725,9 @@ def _construct_input_messages( messages.extend(prev_msg) for output_item in prev_response.output: - if isinstance(output_item, ResponseFunctionToolCall): - messages.append(self._normalize_response_message_for_chat(output_item)) - continue - assistant_text = self._output_message_text(output_item) - if assistant_text is None: - continue - messages.append({"role": "assistant", "content": assistant_text}) + normalized = self._normalize_response_message_for_chat(output_item) + if normalized is not None: + messages.append(normalized) # Append the new input # Responses API supports simple text inputs without chat format @@ -1355,7 +1742,14 @@ def _construct_input_messages( # One Responses-API assistant turn maps to multiple input items # (message + function_call(s)); collapse them into one chat message # so chat templates render a single assistant block per turn. - messages = self._merge_consecutive_assistant_messages(messages) + is_qwen = self.tokenizer_manager.model_config.hf_config.model_type in { + "qwen3_8_flash_next", + "qwen3_8_flash_next_text", + } + messages = self._merge_consecutive_assistant_messages( + messages, + preserve_qwen_order=is_qwen, + ) # Most chat templates expect a single leading ``system`` message; # coalesce any ``instructions`` + interleaved ``developer`` entries. @@ -2115,9 +2509,8 @@ def _sanitize_response_dict(d: dict) -> dict: ) if hasattr(tool_parser.detector, "preserve_raw_input_tools"): tool_parser.detector.preserve_raw_input_tools = request._custom_tool_names - reasoning_parser_obj: Optional[ReasoningParser] = None - if self.reasoning_parser: - reasoning_parser_obj = ReasoningParser( + def new_reasoning_parser() -> ReasoningParser: + return ReasoningParser( model_type=self.reasoning_parser, stream_reasoning=True, # A template that prefills forces the parser open even @@ -2130,6 +2523,26 @@ def _sanitize_response_dict(d: dict) -> dict: tool_call_parser_active=isinstance(tool_parser, FunctionCallParser), ) + reasoning_parser_obj: Optional[ReasoningParser] = ( + new_reasoning_parser() + if self.reasoning_parser and not isinstance(tool_parser, JsonArrayParser) + else None + ) + reasoning_block_closed = False + reasoning_block_started = False + inside_tool_call = False + + # These parsers return separate text and call collections. Feed Qwen + # markup boundaries separately so their original order remains visible. + split_qwen_markup = ( + self.tokenizer_manager.model_config.hf_config.model_type + in {"qwen3_8_flash_next", "qwen3_8_flash_next_text"} + and self.reasoning_parser in {None, "qwen3", "qwen3-thinking"} + and self.tool_call_parser in {None, "qwen3_coder"} + and (reasoning_parser_obj is not None or tool_parser is not None) + ) + marker_splitter = _QwenStructuralMarkerBuffer() if split_qwen_markup else None + current_output_index = -1 reasoning_state = { "open": False, @@ -2250,7 +2663,7 @@ def _open_message_item() -> str: ) return item_id - def _close_message_item(): + def _close_message_item(phase: str = "final_answer"): if not message_state["open"]: return [] text = message_state["text"] @@ -2263,6 +2676,7 @@ def _close_message_item(): role="assistant", content=[text_content], status="completed", + phase=phase, ) events = [ _send_event( @@ -2287,7 +2701,7 @@ def _close_message_item(): ) ), _send_event( - openai_responses_types.ResponseOutputItemDoneEvent( + ResponsePhasedOutputItemDoneEvent( type="response.output_item.done", sequence_number=-1, output_index=message_state["output_index"], @@ -2374,241 +2788,325 @@ def _close_tool_call_state(tool_index: int): ) flushed = flushed or flush - if reasoning_parser_obj is not None: - reasoning_chunk, delta = reasoning_parser_obj.parse_stream_chunk( - delta + parts = ( + marker_splitter.feed( + delta, + final=finish_reason is not None, ) - if flush: - end_reasoning, end_normal = ( - reasoning_parser_obj.parse_stream_end() - ) - if end_reasoning: - reasoning_chunk = (reasoning_chunk or "") + end_reasoning - if end_normal: - delta = (delta or "") + end_normal - else: - reasoning_chunk = None - - if reasoning_chunk: - if message_state["open"]: - for ev in _close_message_item(): + if marker_splitter is not None + else [delta] + ) + flush_chunk = flush + for part_index, delta in enumerate(parts): + # Flush parser state once, after the terminal piece. + flush = flush_chunk and part_index == len(parts) - 1 + structural_part = delta + entering_tool_call = ( + marker_splitter is not None + and tool_parser is not None + and structural_part == "" + ) + if ( + marker_splitter is not None + and delta == "" + and not inside_tool_call + and reasoning_block_closed + and reasoning_parser_obj is not None + ): + for ev in _close_reasoning_item(): yield ev - if not reasoning_state["open"]: - item_id = _open_reasoning_item() - yield _send_event( - openai_responses_types.ResponseOutputItemAddedEvent( - type="response.output_item.added", - sequence_number=-1, - output_index=reasoning_state["output_index"], - item=ResponseReasoningItem( - id=item_id, - type="reasoning", - summary=[], - content=[], - status="in_progress", - ), - ) + reasoning_parser_obj = new_reasoning_parser() + reasoning_block_closed = False + reasoning_block_started = False + if ( + marker_splitter is not None + and structural_part == "" + and not inside_tool_call + ): + reasoning_block_started = True + if reasoning_parser_obj is not None and not inside_tool_call: + reasoning_chunk, delta = reasoning_parser_obj.parse_stream_chunk( + delta ) - # Clients that opt into ``reasoning.summary`` render - # off the ``reasoning_summary_text.*`` event stream, - # so mirror the trace into a summary part. - if wants_summary: - yield _send_event( - openai_responses_types.ResponseReasoningSummaryPartAddedEvent( - type="response.reasoning_summary_part.added", - item_id=item_id, - output_index=reasoning_state["output_index"], - summary_index=0, - part=ResponseReasoningSummaryAddedPart( - type="summary_text", text="" - ), - sequence_number=-1, - ) + if flush: + end_reasoning, end_normal = ( + reasoning_parser_obj.parse_stream_end() ) - reasoning_state["text"] += reasoning_chunk - if wants_summary: - yield _send_event( - openai_responses_types.ResponseReasoningSummaryTextDeltaEvent( - type="response.reasoning_summary_text.delta", - item_id=reasoning_state["item_id"], - output_index=reasoning_state["output_index"], - summary_index=0, - delta=reasoning_chunk, - sequence_number=-1, - ) - ) + if end_reasoning: + reasoning_chunk = (reasoning_chunk or "") + end_reasoning + if end_normal: + delta = (delta or "") + end_normal else: - yield _send_event( - openai_responses_types.ResponseReasoningTextDeltaEvent( - type="response.reasoning_text.delta", - item_id=reasoning_state["item_id"], - output_index=reasoning_state["output_index"], - content_index=0, - delta=reasoning_chunk, - sequence_number=-1, - ) - ) - - if not delta and not flush: - continue - - if isinstance(tool_parser, JsonArrayParser): - required_buffer += delta - normal_text, tool_calls = "", [] - if flush and required_buffer.strip(): - tool_calls = [ - ToolCallItem(tool_index=index, name=name, parameters=arguments) - for index, (name, arguments) in enumerate( - validated_json_calls(required_buffer, {tool.function.name for tool in chat_tools}) - ) - ] - elif tool_parser is not None: - normal_text, tool_calls = tool_parser.parse_stream_chunk(delta) - if flush: - end_text, end_calls = tool_parser.parse_stream_end() - normal_text = (normal_text or "") + end_text - tool_calls = list(tool_calls) + end_calls - else: - normal_text, tool_calls = delta, [] + reasoning_chunk = None + if ( + marker_splitter is not None + and structural_part == "" + and not inside_tool_call + ): + reasoning_block_closed = True + reasoning_block_started = False - def _emit_tool_calls(calls): - nonlocal current_output_index - if calls: - if reasoning_state["open"]: - for ev in _close_reasoning_item(): - yield ev + if reasoning_chunk: if message_state["open"]: - for ev in _close_message_item(): + for ev in _close_message_item(phase="commentary"): yield ev - - for call in calls: - tool_index = call.tool_index - state = tool_call_states.get(tool_index) - if state is None or state.get("done"): - # Close other open calls first, so their - # output_item.done precedes the next added. - for other_index in list(tool_call_states): - if other_index != tool_index: - for ev in _close_tool_call_state(other_index): - yield ev - current_output_index += 1 - item_id = f"fc_{random_uuid()[:8]}" - call_id = f"call_{random_uuid()[:24]}" - state = { - "item_id": item_id, - "call_id": call_id, - "output_index": current_output_index, - "name": call.name or "", - "arguments": "", - "added": False, - "done": False, - } - tool_call_states[tool_index] = state - if not state["added"]: - if request._compat_registry is not None: - request._compat_registry.output_identity(state["name"]) - state["added"] = True + for tool_index in list(tool_call_states): + for ev in _close_tool_call_state(tool_index): + yield ev + if not reasoning_state["open"]: + item_id = _open_reasoning_item() yield _send_event( openai_responses_types.ResponseOutputItemAddedEvent( type="response.output_item.added", sequence_number=-1, - output_index=state["output_index"], - item=ResponseFunctionToolCall( - arguments="", - call_id=state["call_id"], - name=state["name"], - type="function_call", - id=state["item_id"], + output_index=reasoning_state["output_index"], + item=ResponseReasoningItem( + id=item_id, + type="reasoning", + summary=[], + content=[], status="in_progress", ), ) ) - if call.parameters: - state["arguments"] += call.parameters + # Clients that opt into ``reasoning.summary`` render + # off the ``reasoning_summary_text.*`` event stream, + # so mirror the trace into a summary part. + if wants_summary: + yield _send_event( + openai_responses_types.ResponseReasoningSummaryPartAddedEvent( + type="response.reasoning_summary_part.added", + item_id=item_id, + output_index=reasoning_state["output_index"], + summary_index=0, + part=ResponseReasoningSummaryAddedPart( + type="summary_text", text="" + ), + sequence_number=-1, + ) + ) + reasoning_state["text"] += reasoning_chunk + if wants_summary: yield _send_event( - openai_responses_types.ResponseFunctionCallArgumentsDeltaEvent( - type="response.function_call_arguments.delta", + openai_responses_types.ResponseReasoningSummaryTextDeltaEvent( + type="response.reasoning_summary_text.delta", + item_id=reasoning_state["item_id"], + output_index=reasoning_state["output_index"], + summary_index=0, + delta=reasoning_chunk, sequence_number=-1, - item_id=state["item_id"], - output_index=state["output_index"], - delta=call.parameters, ) ) - - def _emit_normal_text(): - if normal_text and _should_emit_normal_text_as_message( - normal_text, - any_tool_call_in_progress=any( - not s.get("done") for s in tool_call_states.values() - ), - ): - if reasoning_state["open"]: - for ev in _close_reasoning_item(): - yield ev - for tool_index in list(tool_call_states): - for ev in _close_tool_call_state(tool_index): - yield ev - if not message_state["open"]: - item_id = _open_message_item() + else: yield _send_event( - openai_responses_types.ResponseOutputItemAddedEvent( - type="response.output_item.added", + openai_responses_types.ResponseReasoningTextDeltaEvent( + type="response.reasoning_text.delta", + item_id=reasoning_state["item_id"], + output_index=reasoning_state["output_index"], + content_index=0, + delta=reasoning_chunk, sequence_number=-1, - output_index=message_state["output_index"], - item=ResponseOutputMessage( - id=item_id, - type="message", - role="assistant", - content=[], - status="in_progress", - ), ) ) + if entering_tool_call and ( + reasoning_block_started or reasoning_state["open"] + ): + reasoning_block_closed = True + reasoning_block_started = False + + if entering_tool_call: + inside_tool_call = True + + if not delta and not flush: + continue + + if isinstance(tool_parser, JsonArrayParser): + required_buffer += delta + normal_text, tool_calls = "", [] + if flush and required_buffer.strip(): + try: + validated_calls = list( + validated_json_calls( + required_buffer, + {tool.function.name for tool in chat_tools}, + ) + ) + except ValueError: + # Public Responses validation below emits the + # established streaming error for malformed or + # unknown required output. + validated_calls = [] + tool_calls = [ + ToolCallItem( + tool_index=index, + name=name, + parameters=arguments, + ) + for index, (name, arguments) in enumerate( + validated_calls + ) + ] + elif tool_parser is not None: + normal_text, tool_calls = tool_parser.parse_stream_chunk(delta) + if flush: + end_text, end_calls = tool_parser.parse_stream_end() + normal_text = (normal_text or "") + end_text + tool_calls = list(tool_calls) + end_calls + else: + normal_text, tool_calls = delta, [] + + def _emit_tool_calls(calls): + nonlocal current_output_index + if calls: + if reasoning_state["open"]: + for ev in _close_reasoning_item(): + yield ev + if message_state["open"]: + for ev in _close_message_item(phase="commentary"): + yield ev + + for call in calls: + tool_index = call.tool_index + state = tool_call_states.get(tool_index) + if state is None or state.get("done"): + # Close other open calls first, so their + # output_item.done precedes the next added. + for other_index in list(tool_call_states): + if other_index != tool_index: + for ev in _close_tool_call_state(other_index): + yield ev + current_output_index += 1 + item_id = f"fc_{random_uuid()[:8]}" + call_id = f"call_{random_uuid()[:24]}" + state = { + "item_id": item_id, + "call_id": call_id, + "output_index": current_output_index, + "name": call.name or "", + "arguments": "", + "added": False, + "done": False, + } + tool_call_states[tool_index] = state + if not state["added"]: + if request._compat_registry is not None: + request._compat_registry.output_identity(state["name"]) + state["added"] = True + yield _send_event( + openai_responses_types.ResponseOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=state["output_index"], + item=ResponseFunctionToolCall( + arguments="", + call_id=state["call_id"], + name=state["name"], + type="function_call", + id=state["item_id"], + status="in_progress", + ), + ) + ) + if call.parameters: + state["arguments"] += call.parameters + yield _send_event( + openai_responses_types.ResponseFunctionCallArgumentsDeltaEvent( + type="response.function_call_arguments.delta", + sequence_number=-1, + item_id=state["item_id"], + output_index=state["output_index"], + delta=call.parameters, + ) + ) + + def _emit_normal_text(): + if normal_text and _should_emit_normal_text_as_message( + normal_text, + any_tool_call_in_progress=any( + not s.get("done") for s in tool_call_states.values() + ), + ): + if reasoning_state["open"]: + for ev in _close_reasoning_item(): + yield ev + for tool_index in list(tool_call_states): + for ev in _close_tool_call_state(tool_index): + yield ev + if not message_state["open"]: + item_id = _open_message_item() + yield _send_event( + ResponsePhasedOutputItemAddedEvent( + type="response.output_item.added", + sequence_number=-1, + output_index=message_state["output_index"], + item=ResponseOutputMessage( + id=item_id, + type="message", + role="assistant", + content=[], + status="in_progress", + # Later reasoning or a tool call may make + # this message commentary. + phase=( + None + if tool_parser is not None + or reasoning_parser_obj is not None + else "final_answer" + ), + ), + ) + ) + yield _send_event( + openai_responses_types.ResponseContentPartAddedEvent( + type="response.content_part.added", + sequence_number=-1, + output_index=message_state["output_index"], + item_id=message_state["item_id"], + content_index=0, + part=openai_responses_types.ResponseOutputText( + type="output_text", + text="", + annotations=[], + logprobs=None, + ), + ) + ) + message_state["text"] += normal_text yield _send_event( - openai_responses_types.ResponseContentPartAddedEvent( - type="response.content_part.added", + openai_responses_types.ResponseTextDeltaEvent( + type="response.output_text.delta", sequence_number=-1, + content_index=0, output_index=message_state["output_index"], item_id=message_state["item_id"], - content_index=0, - part=openai_responses_types.ResponseOutputText( - type="output_text", - text="", - annotations=[], - logprobs=None, - ), + delta=normal_text, + logprobs=[], ) ) - message_state["text"] += normal_text - yield _send_event( - openai_responses_types.ResponseTextDeltaEvent( - type="response.output_text.delta", - sequence_number=-1, - content_index=0, - output_index=message_state["output_index"], - item_id=message_state["item_id"], - delta=normal_text, - logprobs=[], - ) - ) - - # The parser's (text, calls) tuple is unordered, but positions - # are recoverable: continuing arguments precede this delta's - # text, a newly opened call follows it. Classify first -- - # emitting mutates tool_call_states. - def _is_continuing(call): - state = tool_call_states.get(call.tool_index) - return state is not None and not state.get("done") - continuing = [c for c in tool_calls if _is_continuing(c)] - opening = [c for c in tool_calls if not _is_continuing(c)] - - for ev in _emit_tool_calls(continuing): - yield ev - for ev in _emit_normal_text(): - yield ev - for ev in _emit_tool_calls(opening): - yield ev + # The parser's (text, calls) tuple is unordered, but positions + # are recoverable: continuing arguments precede this delta's + # text, a newly opened call follows it. Classify first -- + # emitting mutates tool_call_states. + def _is_continuing(call): + state = tool_call_states.get(call.tool_index) + return state is not None and not state.get("done") + + continuing = [c for c in tool_calls if _is_continuing(c)] + opening = [c for c in tool_calls if not _is_continuing(c)] + + for ev in _emit_tool_calls(continuing): + yield ev + for ev in _emit_normal_text(): + yield ev + for ev in _emit_tool_calls(opening): + yield ev + if ( + marker_splitter is not None + and tool_parser is not None + and structural_part == "" + ): + inside_tool_call = False except Exception: logger.exception("Error while streaming /v1/responses") failed = _sanitize_response_dict( diff --git a/scripts/test_invalid_token_failure.sh b/scripts/test_invalid_token_failure.sh index 38b5d2a..ba3432b 100755 --- a/scripts/test_invalid_token_failure.sh +++ b/scripts/test_invalid_token_failure.sh @@ -1,5 +1,5 @@ #!/usr/bin/env bash -# CPU-only local validation; no build, GPU devices, network, or publication. +# CPU-only local validation; no GPU devices, network, publication, or deployment. set -euo pipefail RED='\033[0;31m' @@ -36,7 +36,9 @@ fi IMAGE='kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404' run python3 "$ROOT/scripts/verify_responses_compat.py" --tokenizer "$QWEN_TOKENIZER_PATH" +run python3 "$ROOT/scripts/verify_qwen_multimodal_alias.py" run python3 "$ROOT/scripts/verify_invalid_token_failure.py" +run python3 -m unittest -v "$ROOT/tests/test_invalid_token_packaging.py" run docker image inspect --format '{{.Id}}' "$IMAGE" run docker run --rm --pull never --network none --read-only --cap-drop all \ --security-opt no-new-privileges --cpus 4 --memory 12g --pids-limit 512 \ @@ -52,5 +54,6 @@ run docker run --rm --pull never --network none --read-only --cap-drop all \ -v "$ROOT/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py:ro" \ -v "$ROOT/runtime/python/sglang/srt/entrypoints/openai/responses_compat.py:/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py:ro" \ -v "$ROOT/runtime/python/sglang/srt/function_call/qwen3_coder_detector.py:/sgl-workspace/sglang/python/sglang/srt/function_call/qwen3_coder_detector.py:ro" \ + -v "$ROOT/runtime/python/sglang/srt/multimodal/processors/qwen_vl.py:/sgl-workspace/sglang/python/sglang/srt/multimodal/processors/qwen_vl.py:ro" \ -v "$ROOT/runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py:/sgl-workspace/sglang/python/sglang/srt/managers/schedule_batch.py:ro" \ --entrypoint python3 "$IMAGE" /repo/tests/runtime_invalid_token_failure.py -v diff --git a/scripts/verify_invalid_token_failure.py b/scripts/verify_invalid_token_failure.py index 15fa9db..564b741 100755 --- a/scripts/verify_invalid_token_failure.py +++ b/scripts/verify_invalid_token_failure.py @@ -1,21 +1,23 @@ #!/usr/bin/env python3 -"""Verify the invalid generated-token failure profile.""" +"""Verify the cumulative invalid generated-token failure profile.""" + import argparse import hashlib import json from pathlib import Path import subprocess -from verify_chat_effort import verify as verify_chat_effort +from verify_qwen_multimodal_alias import package_records as multimodal_package_records +from verify_qwen_multimodal_alias import verify as verify_multimodal ROOT = Path(__file__).resolve().parents[1] -def digest(path): +def digest(path: Path) -> str: return hashlib.sha256(path.read_bytes()).hexdigest() -def verify_tree_inventory(tree, inventory): +def verify_tree_inventory(tree: Path, inventory: dict[str, str]) -> None: actual = { str(path.relative_to(tree)) for path in (tree / "python/sglang").rglob("*") @@ -28,73 +30,93 @@ def verify_tree_inventory(tree, inventory): raise ValueError("Source hash mismatch: " + name) -def apply_patch(tree, patch): +def apply_patch(tree: Path, patch: Path) -> None: subprocess.run(["git", "apply", "--check", str(patch)], cwd=tree, check=True) subprocess.run(["git", "apply", str(patch)], cwd=tree, check=True) def package_records(): - manifest = json.loads((ROOT / "provenance/invalid-token-failure.json").read_text()) - base_inventory = ROOT / "provenance/responses-compat-runtime-files.json" - if digest(base_inventory) != manifest["base_inventory_sha256"]: + manifest_path = ROOT / "provenance/invalid-token-failure.json" + manifest = json.loads(manifest_path.read_text()) + predecessor_manifest, predecessor = multimodal_package_records() + + base_inventory_path = ROOT / "provenance" / manifest["base_inventory"] + if digest(base_inventory_path) != manifest["base_inventory_sha256"]: raise ValueError("Base inventory digest mismatch") - inventory = json.loads(base_inventory.read_text()) - responses = json.loads((ROOT / "provenance/responses-compat.json").read_text()) - alias = json.loads((ROOT / "provenance/qwen-effort-alias.json").read_text()) - if responses["inventory_sha256"] != manifest["base_inventory_sha256"]: - raise ValueError("Responses inventory identity mismatch") - for predecessor in (alias, responses): - predecessor_patch = ROOT / "patches" / predecessor["patch"] - if digest(predecessor_patch) != predecessor["patch_sha256"]: - raise ValueError("Predecessor patch hash mismatch") - predecessor_series = (ROOT / "patches/series.responses-compat").read_text().splitlines() - if predecessor_series != [alias["patch"], responses["patch"]]: - raise ValueError("Predecessor patch order differs") - for name in ( - "python/sglang/srt/entrypoints/openai/protocol.py", - "python/sglang/srt/entrypoints/openai/responses_compat.py", - "python/sglang/srt/function_call/qwen3_coder_detector.py", - ): - if digest(ROOT / "runtime" / name) != inventory[name]: - raise ValueError("Packaged predecessor runtime mismatch: " + name) + inventory = json.loads(base_inventory_path.read_text()) + if inventory != predecessor: + raise ValueError("Base inventory differs from multimodal verifier") + if manifest["base_inventory_sha256"] != predecessor_manifest["inventory_sha256"]: + raise ValueError("Predecessor inventory identity mismatch") + + expected_series = [ + "0015-qwen-flash-next-effort-alias.patch", + "0016-responses-namespace-custom-boundary.patch", + "0017-responses-phase-order.patch", + "0018-qwen-flash-next-multimodal-alias.patch", + manifest["patch"], + ] + if manifest["series"] != expected_series: + raise ValueError("Manifest patch order differs") + if (ROOT / "patches/series.invalid-token-failure").read_text().splitlines() != expected_series: + raise ValueError("Invalid-token patch order differs") + for name, hashes in manifest["files"].items(): if inventory.get(name) != hashes["before"]: raise ValueError("Invalid-token preimage mismatch: " + name) - if digest(ROOT / "runtime.invalid-token-failure" / name) != hashes["after"]: + runtime_path = ROOT / "runtime.invalid-token-failure" / name + if digest(runtime_path) != hashes["after"]: raise ValueError("Packaged runtime mismatch: " + name) inventory[name] = hashes["after"] + patch = ROOT / "patches" / manifest["patch"] if digest(patch) != manifest["patch_sha256"]: raise ValueError("Invalid-token patch hash mismatch") - series = (ROOT / "patches/series.invalid-token-failure").read_text().splitlines() - if series != [ - "0015-qwen-flash-next-effort-alias.patch", - "0016-responses-namespace-custom-boundary.patch", - manifest["patch"], - ]: - raise ValueError("Invalid-token patch order differs") - encoded = (json.dumps(dict(sorted(inventory.items())), indent=2) + "\n").encode() - if hashlib.sha256(encoded).hexdigest() != manifest["result_inventory_sha256"]: - raise ValueError("Result inventory digest mismatch") + + inventory_path = ROOT / "provenance" / manifest["inventory"] + recorded_inventory = json.loads(inventory_path.read_text()) + if recorded_inventory != dict(sorted(inventory.items())): + raise ValueError("Full candidate inventory differs from predecessor chain") + if digest(inventory_path) != manifest["inventory_sha256"]: + raise ValueError("Candidate inventory digest mismatch") + if manifest["source_files_before"] != len(predecessor): + raise ValueError("Predecessor source count mismatch") + if manifest["source_files_after"] != len(inventory): + raise ValueError("Result source count mismatch") + + qwen_path = "python/sglang/srt/multimodal/processors/qwen_vl.py" + if inventory[qwen_path] != predecessor[qwen_path]: + raise ValueError("PR7 qwen_vl changed") + if digest(ROOT / "runtime" / qwen_path) != predecessor[qwen_path]: + raise ValueError("Packaged PR7 qwen_vl mismatch") + + validation = manifest["validation"] + expected_counts = { + "invalid_token_runtime_tests": 15, + "invalid_token_packaging_tests": 4, + "responses_tests": 75, + "effort_tests": 14, + "multimodal_tests": 4, + "full_package_tests": 90, + "dedicated_packaging_tests": 17, + "exact_image_reconstructions": 2, + } + if {name: validation.get(name) for name in expected_counts} != expected_counts: + raise ValueError("Validation count contract differs") + for name, expected in validation["logs"].items(): + if digest(ROOT / "provenance" / name) != expected: + raise ValueError("Evidence hash mismatch: " + name) + return manifest, inventory -def verify(tree, apply=False, from_image=False): +def verify(tree: Path, apply: bool = False, from_image: bool = False) -> int: manifest, inventory = package_records() - base_inventory = json.loads( - (ROOT / "provenance/responses-compat-runtime-files.json").read_text() - ) if from_image: - verify_chat_effort(tree) - for name in ( - "0015-qwen-flash-next-effort-alias.patch", - "0016-responses-namespace-custom-boundary.patch", - ): - apply_patch(tree, ROOT / "patches" / name) - verify_tree_inventory(tree, base_inventory) + verify_multimodal(tree, from_image=True) + apply_patch(tree, ROOT / "patches" / manifest["patch"]) elif apply: - verify_tree_inventory(tree, base_inventory) - if apply or from_image: + verify_multimodal(tree) apply_patch(tree, ROOT / "patches" / manifest["patch"]) verify_tree_inventory(tree, inventory) return len(inventory) diff --git a/tests/test_invalid_token_packaging.py b/tests/test_invalid_token_packaging.py index ccc6ee0..56c1620 100644 --- a/tests/test_invalid_token_packaging.py +++ b/tests/test_invalid_token_packaging.py @@ -1,4 +1,5 @@ """Fail-closed packaging tests for invalid generated-token failures.""" + import importlib.util from pathlib import Path import sys @@ -18,10 +19,13 @@ class InvalidTokenPackagingTest(unittest.TestCase): def test_manifest_chain_and_runtime_compile(self): manifest, inventory = verifier.package_records() self.assertEqual(len(inventory), 4392) + self.assertEqual(manifest["source_files_before"], 4392) + self.assertEqual(manifest["source_files_after"], 4392) self.assertEqual( list(manifest["files"]), [ "python/sglang/srt/entrypoints/openai/serving_chat.py", + "python/sglang/srt/entrypoints/openai/serving_completions.py", "python/sglang/srt/entrypoints/openai/serving_responses.py", "python/sglang/srt/managers/schedule_batch.py", ], @@ -33,6 +37,30 @@ def test_manifest_chain_and_runtime_compile(self): "exec", ) + def test_dockerfile_mounts_cumulative_overlay_and_verifies_inventory(self): + dockerfile = (ROOT / "Dockerfile.invalid-token-failure").read_text() + copied = { + line.split()[1] + for line in dockerfile.splitlines() + if line.startswith("COPY runtime") + } + self.assertEqual( + copied, + { + "runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py", + "runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py", + "runtime/python/sglang/srt/entrypoints/openai/protocol.py", + "runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py", + "runtime/python/sglang/srt/entrypoints/openai/responses_compat.py", + "runtime/python/sglang/srt/function_call/qwen3_coder_detector.py", + "runtime/python/sglang/srt/multimodal/processors/qwen_vl.py", + "runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py", + }, + ) + self.assertIn("invalid-token-failure-runtime-files.json", dockerfile) + self.assertIn("assert actual == set(expected)", dockerfile) + self.assertIn("assert not bad", dockerfile) + def test_runtime_drift_fails_closed(self): original = verifier.digest @@ -45,14 +73,20 @@ def changed(path): with self.assertRaisesRegex(ValueError, "Packaged runtime mismatch"): verifier.package_records() - def test_patch_drift_fails_closed(self): + def test_patch_and_inventory_drift_fail_closed(self): original = verifier.digest + cases = ( + ("0019-invalid-generated-token-failure.patch", "patch hash mismatch"), + ("invalid-token-failure-runtime-files.json", "inventory digest mismatch"), + ("pr8-final-responses-75.log", "Evidence hash mismatch"), + ) + for target, message in cases: + with self.subTest(target=target): + def changed(path, target=target): + if path.name == target: + return "0" * 64 + return original(path) - def changed(path): - if path.name.startswith("0019-"): - return "0" * 64 - return original(path) - - with patch.object(verifier, "digest", side_effect=changed): - with self.assertRaisesRegex(ValueError, "patch hash mismatch"): - verifier.package_records() + with patch.object(verifier, "digest", side_effect=changed): + with self.assertRaisesRegex(ValueError, message): + verifier.package_records() From fae68fbcc0037aab2a3a580727e69d706a6cd0c7 Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 15:42:54 +0100 Subject: [PATCH 18/20] fix(responses): emit Harmony failure terminal event --- docs/invalid-token-failure.md | 15 +++-- ...0019-invalid-generated-token-failure.patch | 35 +++++++++++- .../invalid-token-failure-runtime-files.json | 2 +- provenance/invalid-token-failure.json | 36 ++++++------ .../pr8-final-compile-diff-security.log | 2 +- .../pr8-final-docker-build-readback.log | 55 +++++++++---------- provenance/pr8-final-effort-14.log | 6 +- ...final-exact-image-reconstruction-twice.log | 4 +- provenance/pr8-final-full-package.log | 2 +- provenance/pr8-final-invalid-token-green.log | 7 ++- provenance/pr8-final-multimodal-4.log | 2 +- provenance/pr8-final-packaging-17.log | 2 +- provenance/pr8-final-responses-75.log | 12 ++-- provenance/pr8-harmony-terminal-red.log | 22 ++++++++ .../entrypoints/openai/serving_responses.py | 21 ++++++- scripts/verify_invalid_token_failure.py | 2 +- tests/runtime_invalid_token_failure.py | 43 ++++++++++++++- 17 files changed, 190 insertions(+), 78 deletions(-) create mode 100644 provenance/pr8-harmony-terminal-red.log diff --git a/docs/invalid-token-failure.md b/docs/invalid-token-failure.md index b84f6f4..75b69ba 100644 --- a/docs/invalid-token-failure.md +++ b/docs/invalid-token-failure.md @@ -19,8 +19,10 @@ to overwrite that error. - **Completions:** uses the same integer-status and error-type behavior, emits `[DONE]`, and returns before any ordinary abort choice or usage event. - **Responses:** non-stream and stream terminals use `status=failed`, attach a - `server_error`, retain partial output, and emit `response.failed`. Stored failed - responses remain retrievable. A failed response used as + `server_error`, retain partial output, and emit `response.failed`, including + the Harmony streaming path. Incomplete, failed/cancelled, and completed + Harmony terminals now select the same event classes as non-Harmony. Stored + failed responses remain retrievable. A failed response used as `previous_response_id` is rejected with HTTP 400 and `param=previous_response_id` before registry replay, preprocessing, or generation. @@ -46,7 +48,7 @@ effort behavior. The PR #7 `qwen_vl.py` bytes remain unchanged at SHA-256 The four post-0019 runtime files, including `serving_completions.py`, are under `runtime.invalid-token-failure/`. The full 4,392-file result inventory is `provenance/invalid-token-failure-runtime-files.json`; its SHA-256 is -`414b43dec378538ca1e5785f4855115947d824c2b42fe6fa4bcb2943815c05f3`. +`f7293cc004161bcad39bc3772939fd868f8fc9d6f09d2cdb7b7ffd5a23333e1d`. `provenance/invalid-token-failure.json` binds base/head identities, patch and inventory hashes, every changed-file preimage/result, test counts, and evidence log hashes. The verifier fails closed on chain, series, runtime, patch, @@ -57,7 +59,8 @@ inventory, PR #7 byte, count, or evidence drift. Pinned tokenizer/config metadata came from the recorded local release snapshot. CPU/GPU-disabled checks completed against the exact base image: -- 15 focused runtime tests for scheduler/API error behavior; +- 16 focused runtime tests for scheduler/API error behavior, including the + Harmony terminal-event regression captured RED before the runtime fix; - 4 invalid-token packaging contract tests; - 75 cumulative Responses tests; - 14 effort tests; @@ -66,10 +69,10 @@ CPU/GPU-disabled checks completed against the exact base image: - 17 dedicated packaging tests; - two independent exact-image reconstructions, each checking all 4,392 source files and producing tree digest - `f98edc6b100d20bfd993b0f02183e53ac8f5b7bf41c849779877ee2090878482`; + `72d547ccf24958a58b97a931b8535b97327f4b8bfc03ef368e478d5abd58a490`; - local Docker build plus image readback: 4,392 expected, 4,392 present, zero missing, extra, or mismatched source files. The recorded candidate build digest - is `sha256:a4627d598748483bad601e53b7500940374d12b1226016d99a79a18569deec60`. + is `sha256:6122dbac2c26cb7852b9e8e44787e95ade096de82929dc9d2d93d53a86aaa227`. Run the focused gate: diff --git a/patches/0019-invalid-generated-token-failure.patch b/patches/0019-invalid-generated-token-failure.patch index 13c6c59..d0e0968 100644 --- a/patches/0019-invalid-generated-token-failure.patch +++ b/patches/0019-invalid-generated-token-failure.patch @@ -59,7 +59,7 @@ index d5587765bd73ab98afa51643ae0382aa22ec31f8..1f701086f196ddc593e02809a63ba744 choice_data = CompletionResponseStreamChoice( index=index, diff --git a/python/sglang/srt/entrypoints/openai/serving_responses.py b/python/sglang/srt/entrypoints/openai/serving_responses.py -index 844e0114bf269a864666c98a0e39c57127834580..2a242a3640181ae753d6b884a47f9a00c8ac64fb 100644 +index 844e0114bf269a864666c98a0e39c57127834580..b37663dc191991c53d29248c275d4fa6dbbf1153 100644 --- a/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -315,6 +315,10 @@ class OpenAIServingResponses(OpenAIServingChat): @@ -176,7 +176,36 @@ index 844e0114bf269a864666c98a0e39c57127834580..2a242a3640181ae753d6b884a47f9a00 async def responses_stream_generator( self, request: ResponsesRequest, -@@ -3125,6 +3164,7 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -2372,9 +2411,26 @@ class OpenAIServingResponses(OpenAIServingChat): + # OpenAI SDK's Tool union may not know extended types; drop echo. + response_dict["tools"] = [] + ++ status = final_response.status ++ terminal_event = ( ++ openai_responses_types.ResponseIncompleteEvent if status == "incomplete" ++ else ( ++ openai_responses_types.ResponseFailedEvent ++ if status in ("failed", "cancelled") ++ else openai_responses_types.ResponseCompletedEvent ++ ) ++ ) ++ terminal_type = ( ++ "response.incomplete" if status == "incomplete" ++ else ( ++ "response.failed" ++ if status in ("failed", "cancelled") ++ else "response.completed" ++ ) ++ ) + yield _send_event( +- openai_responses_types.ResponseCompletedEvent( +- type="response.completed", ++ terminal_event( ++ type=terminal_type, + sequence_number=-1, + response=response_dict, + ) +@@ -3125,6 +3181,7 @@ class OpenAIServingResponses(OpenAIServingChat): status=status, usage=usage, ) @@ -184,7 +213,7 @@ index 844e0114bf269a864666c98a0e39c57127834580..2a242a3640181ae753d6b884a47f9a00 if request.store: async with self.response_store_lock: stored = self.response_store.get(final_response.id) -@@ -3136,12 +3176,19 @@ class OpenAIServingResponses(OpenAIServingChat): +@@ -3136,12 +3193,19 @@ class OpenAIServingResponses(OpenAIServingChat): terminal_event = ( openai_responses_types.ResponseIncompleteEvent if status == "incomplete" diff --git a/provenance/invalid-token-failure-runtime-files.json b/provenance/invalid-token-failure-runtime-files.json index 5d221f2..c1eba6d 100644 --- a/provenance/invalid-token-failure-runtime-files.json +++ b/provenance/invalid-token-failure-runtime-files.json @@ -2488,7 +2488,7 @@ "python/sglang/srt/entrypoints/openai/serving_completions.py": "0d21d557ef38d0639e4030bff764ecca8a266ef6d60284cf959c56d9dec751a1", "python/sglang/srt/entrypoints/openai/serving_embedding.py": "cf1b283df88e1286b7f803f2173bf89499c65e25c93462bc299b2c64539d77b8", "python/sglang/srt/entrypoints/openai/serving_rerank.py": "5242cd42c8ccba74fbdf13e2c7eee63b5551e3d6bef09933aba213d690cb3329", - "python/sglang/srt/entrypoints/openai/serving_responses.py": "a30b96b8b1393e8d1cf53fb180e602eeae07bd160bb88a3146eaafdf0ef0f4e7", + "python/sglang/srt/entrypoints/openai/serving_responses.py": "b971172798d974217a43127f3a831d28974bbad6c36f2dc8754ca940edf6e4d2", "python/sglang/srt/entrypoints/openai/serving_score.py": "203748c564cd979d03d54dee44140c63caef59490d1ca508ccb1aca3f69ffccd", "python/sglang/srt/entrypoints/openai/serving_tokenize.py": "f1791dbe89245cf80f2ae3c3f052e944c0b602deaf45909a31d2e4aabfc95711", "python/sglang/srt/entrypoints/openai/serving_transcription.py": "0f15eac62ea22d5cd531f19e9419a5db61f6a3109a25f0e6d87e84d215c4128d", diff --git a/provenance/invalid-token-failure.json b/provenance/invalid-token-failure.json index 6200241..2f1f959 100644 --- a/provenance/invalid-token-failure.json +++ b/provenance/invalid-token-failure.json @@ -8,7 +8,7 @@ "base_inventory": "qwen-multimodal-alias-runtime-files.json", "base_inventory_sha256": "c88e18731d4ef0b4cd5a71c5f4b486def1677802c86303907ee50f2317714395", "patch": "0019-invalid-generated-token-failure.patch", - "patch_sha256": "4d1f7a71b2907d79d6075a9d2b1b9f0fd2dd96ec97c08bc8d246ba15979c6a75", + "patch_sha256": "21c16814e9e3cfa3bc521ad1ee60cc6a9fe99a320b0b2c2717ba51e08b637e71", "series": [ "0015-qwen-flash-next-effort-alias.patch", "0016-responses-namespace-custom-boundary.patch", @@ -27,7 +27,7 @@ }, "python/sglang/srt/entrypoints/openai/serving_responses.py": { "before": "e65084c831bb3755bcef6a3288587582c065538857b58d09c8d2c2bc3ecf696c", - "after": "a30b96b8b1393e8d1cf53fb180e602eeae07bd160bb88a3146eaafdf0ef0f4e7" + "after": "b971172798d974217a43127f3a831d28974bbad6c36f2dc8754ca940edf6e4d2" }, "python/sglang/srt/managers/schedule_batch.py": { "before": "4965156c669a536b40250605794de9d9aa7582fde71d188ab2ecf22e766e755a", @@ -37,9 +37,9 @@ "source_files_before": 4392, "source_files_after": 4392, "inventory": "invalid-token-failure-runtime-files.json", - "inventory_sha256": "414b43dec378538ca1e5785f4855115947d824c2b42fe6fa4bcb2943815c05f3", + "inventory_sha256": "f7293cc004161bcad39bc3772939fd868f8fc9d6f09d2cdb7b7ffd5a23333e1d", "validation": { - "invalid_token_runtime_tests": 15, + "invalid_token_runtime_tests": 16, "invalid_token_packaging_tests": 4, "responses_tests": 75, "effort_tests": 14, @@ -47,25 +47,27 @@ "full_package_tests": 90, "dedicated_packaging_tests": 17, "exact_image_reconstructions": 2, - "exact_image_tree_digest_sha256": "f98edc6b100d20bfd993b0f02183e53ac8f5b7bf41c849779877ee2090878482", - "local_candidate_image_digest": "sha256:a4627d598748483bad601e53b7500940374d12b1226016d99a79a18569deec60", + "exact_image_tree_digest_sha256": "72d547ccf24958a58b97a931b8535b97327f4b8bfc03ef368e478d5abd58a490", + "local_candidate_image_digest": "sha256:6122dbac2c26cb7852b9e8e44787e95ade096de82929dc9d2d93d53a86aaa227", "logs": { - "pr8-final-invalid-token-green.log": "d70f998e10597b3d33c9ee5ebbb5b69f03b71e96b97ef96a585db52289d3aa13", - "pr8-final-responses-75.log": "eeb2f440d737a0a5f0f1f686c7dfab7e9399733e45cad32110d9d9e33255719a", - "pr8-final-effort-14.log": "c91d898de13ded814c6abd96a7028c5d2cffa36db0c05709516009d76de12506", - "pr8-final-multimodal-4.log": "b0f726e94944c0035e02d80319aecd788d16c42e9346afdceb2643f7f8786b3d", - "pr8-final-full-package.log": "9584ca1c8725c16d69812491fe802f4345c0312d92366cf4d50856fb09079796", - "pr8-final-packaging-17.log": "f0ed380b08e2a24c2d2bfe7072f492a40d0f0600b2db7a605c66a032c5e6b58b", - "pr8-final-exact-image-reconstruction-twice.log": "b979d29167bb1e0f39275de0acac87e06e14abd5012e27376f792c895f3872ea", - "pr8-final-docker-build-readback.log": "c90c1240d352226a0467412353f2b8601aa203652a8c22528f1fedb72f617da1", - "pr8-final-compile-diff-security.log": "32cceb049709ca854a9a52c4b326e79c822f5d8b37a4f9d178b213c2f66eecbf" + "pr8-final-invalid-token-green.log": "13bba3308630c9f717e34471232baa9de7b98a76f67dd8580f9adc6ade814169", + "pr8-final-responses-75.log": "632433f45858173ad07267127c83600cee6605c759c4e6d4e7e4e5eef49dbfa7", + "pr8-final-effort-14.log": "ee686891fc42e268d9e8b0d9b7f013c6dec903c4665b7873d7ed4a44c0c57d8f", + "pr8-final-multimodal-4.log": "971be1d1103932de55cb49a92c42a3b5b7f4409a1cfb1c182c80523ce6de9aca", + "pr8-final-full-package.log": "9bd74e7c9de43b61156ad6b547c9e8bf6f5838afd4a79d153785b427896d8847", + "pr8-final-packaging-17.log": "28f8f82e4e95c8de296c75f35c475104d9a92e86e629d8a21828389144fbbed3", + "pr8-final-exact-image-reconstruction-twice.log": "8d70ea13623e3bf30992790819581bbd632ce4eb57a78e09ddc935f14be73dae", + "pr8-final-docker-build-readback.log": "cd5a2a86f239f79ac002b1f40bb9ed73683839d2006ee3d1c40ed235dfba5950", + "pr8-final-compile-diff-security.log": "80e47f0993b198cf1ab22695be8415e11d52df3e95a13875f9dc74b0631cf892", + "pr8-harmony-terminal-red.log": "cb00fd10231239dca54a539de85143dea571a27639025bc7acf22f220b8e47e3" } }, "scope": [ "Scheduler invalid generated-token classification without faulty-token emission", "Chat and Completions InvalidTokenError streaming propagation", - "Responses failed terminals, storage, retrieval, and pre-generation replay rejection", + "Responses failed terminals (Harmony and non-Harmony), storage, retrieval, and pre-generation replay rejection", "Graceful cancellation behavior preservation", "PR5 Responses phase/order behavior and PR7 Qwen VL bytes preservation" - ] + ], + "terminal_event_fix_base_head": "cb8a491af7ad664e207fe2fb7d7bded4fd8a4dbb" } diff --git a/provenance/pr8-final-compile-diff-security.log b/provenance/pr8-final-compile-diff-security.log index f6321bc..4f4d382 100644 --- a/provenance/pr8-final-compile-diff-security.log +++ b/provenance/pr8-final-compile-diff-security.log @@ -5,7 +5,7 @@ e5d93387e03c110de6f6f483a0ff5ed44d3a1a1e == staged diff check == PASS == Python and shell compile == -compiled 7 Python files +compiled 10 Python files shell syntax PASS == generated patch exact apply == {"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": true} diff --git a/provenance/pr8-final-docker-build-readback.log b/provenance/pr8-final-docker-build-readback.log index b6ec081..ef5025e 100644 --- a/provenance/pr8-final-docker-build-readback.log +++ b/provenance/pr8-final-docker-build-readback.log @@ -1,8 +1,11 @@ #0 building with "default" instance using docker driver +#1 [internal] load build definition from Dockerfile.invalid-token-failure +#1 DONE 0.0s + #1 [internal] load build definition from Dockerfile.invalid-token-failure #1 transferring dockerfile: 2.85kB done -#1 DONE 0.1s +#1 DONE 0.0s #2 [internal] load metadata for docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 #2 ... @@ -15,33 +18,27 @@ #4 [internal] load .dockerignore #4 transferring context: 134B done -#4 DONE 0.1s - -#5 [internal] load build context -#5 DONE 0.0s - -#6 [ 1/11] FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 -#6 resolve docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 0.1s done -#6 DONE 0.1s +#4 DONE 0.0s -#5 [internal] load build context -#5 transferring context: 1.19MB done +#5 [ 1/11] FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 +#5 resolve docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 0.0s done #5 DONE 0.1s -#6 [ 1/11] FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 -#6 CACHED +#6 [internal] load build context +#6 transferring context: 762.62kB done +#6 DONE 0.0s #7 [ 2/11] COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_chat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_chat.py -#7 DONE 0.1s +#7 CACHED #8 [ 3/11] COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_completions.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_completions.py -#8 DONE 0.1s +#8 CACHED #9 [ 4/11] COPY runtime/python/sglang/srt/entrypoints/openai/protocol.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py -#9 DONE 0.1s +#9 CACHED #10 [ 5/11] COPY runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py -#10 DONE 0.1s +#10 DONE 0.2s #11 [ 6/11] COPY runtime/python/sglang/srt/entrypoints/openai/responses_compat.py /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py #11 DONE 0.1s @@ -53,25 +50,25 @@ #13 DONE 0.1s #14 [ 9/11] COPY runtime.invalid-token-failure/python/sglang/srt/managers/schedule_batch.py /sgl-workspace/sglang/python/sglang/srt/managers/schedule_batch.py -#14 DONE 0.1s +#14 DONE 0.2s #15 [10/11] COPY provenance/invalid-token-failure-runtime-files.json /tmp/invalid-token-failure-runtime-files.json #15 DONE 0.1s #16 [11/11] RUN python3 -B -c 'import hashlib,json,pathlib; root=pathlib.Path("/sgl-workspace/sglang"); expected=json.loads(pathlib.Path("/tmp/invalid-token-failure-runtime-files.json").read_text()); actual={str(p.relative_to(root)) for p in (root/"python/sglang").rglob("*") if p.is_file() and "__pycache__" not in p.parts and p.suffix != ".pyc"}; assert actual == set(expected), (len(actual), len(expected)); bad=[n for n,h in expected.items() if hashlib.sha256((root/n).read_bytes()).hexdigest()!=h]; assert not bad, bad; files=[root/"python/sglang/srt/entrypoints/openai"/n for n in ("serving_chat.py", "serving_completions.py", "protocol.py", "serving_responses.py", "responses_compat.py")]+[root/"python/sglang/srt/function_call/qwen3_coder_detector.py", root/"python/sglang/srt/multimodal/processors/qwen_vl.py", root/"python/sglang/srt/managers/schedule_batch.py"]; [compile(f.read_bytes(), str(f), "exec") for f in files]' && rm /tmp/invalid-token-failure-runtime-files.json -#16 DONE 0.6s +#16 DONE 0.7s #17 exporting to image #17 exporting layers -#17 exporting layers 1.3s done -#17 exporting manifest sha256:480b15914d6577a96c49131e89555ae3a1153b306d4cdeeccbf0039becd3659f 0.0s done -#17 exporting config sha256:0043c762ee486c4f6f90bc0bd00dd5593b2d3952a3d23ada80443eb040af59b2 0.0s done -#17 exporting attestation manifest sha256:ca5c818b7cfb936ec2015313e53b42db1e564cac0993dba4eda5ff4d01b0aea9 0.0s done -#17 exporting manifest list sha256:a4627d598748483bad601e53b7500940374d12b1226016d99a79a18569deec60 -#17 exporting manifest list sha256:a4627d598748483bad601e53b7500940374d12b1226016d99a79a18569deec60 0.0s done -#17 naming to docker.io/library/sglang-pr8-final:local-candidate 0.0s done +#17 exporting layers 1.0s done +#17 exporting manifest sha256:09b43f06656a861959404cfdb0e7f20b73c943ba5208874beffc97ecdf4f4007 0.0s done +#17 exporting config sha256:12b4a9ac4ca963f4d96bb2f790019c6d349cc38d54e035a2cb46b58f333d7a19 0.0s done +#17 exporting attestation manifest sha256:ff0569694bd9f9f2b4cab8b9968df03712f5e69487408180486c5fe42cc59be4 0.0s done +#17 exporting manifest list sha256:6122dbac2c26cb7852b9e8e44787e95ade096de82929dc9d2d93d53a86aaa227 +#17 exporting manifest list sha256:6122dbac2c26cb7852b9e8e44787e95ade096de82929dc9d2d93d53a86aaa227 0.0s done +#17 naming to docker.io/library/sglang-pr8-final:local-candidate done #17 unpacking to docker.io/library/sglang-pr8-final:local-candidate -#17 unpacking to docker.io/library/sglang-pr8-final:local-candidate 0.4s done -#17 DONE 1.9s -sha256:a4627d598748483bad601e53b7500940374d12b1226016d99a79a18569deec60 local-pr8-candidate +#17 unpacking to docker.io/library/sglang-pr8-final:local-candidate 0.3s done +#17 DONE 1.5s +sha256:6122dbac2c26cb7852b9e8e44787e95ade096de82929dc9d2d93d53a86aaa227 local-pr8-candidate revision=local-pr8-candidate {"source_files": 4392, "expected_files": 4392, "missing": 0, "extra": 0, "mismatched": 0} diff --git a/provenance/pr8-final-effort-14.log b/provenance/pr8-final-effort-14.log index 5912fb3..06e2173 100644 --- a/provenance/pr8-final-effort-14.log +++ b/provenance/pr8-final-effort-14.log @@ -2,11 +2,11 @@ warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") /sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") -W0914 14:08:50.350000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +W0914 14:33:11.444000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok -test_top_level_xhigh_reaches_real_tokenizer (runtime_chat_effort.ChatEffortTest.test_top_level_xhigh_reaches_real_tokenizer) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:1034: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field +test_top_level_xhigh_reaches_real_tokenizer (runtime_chat_effort.ChatEffortTest.test_top_level_xhigh_reaches_real_tokenizer) ... /sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/protocol.py:1039: DeprecationWarning: max_tokens is deprecated in favor of the max_completion_tokens field "max_new_tokens": self.max_completion_tokens or self.max_tokens, ok test_anthropic_messages_effort_uses_shared_aliases (__main__.QwenAliasTest.test_anthropic_messages_effort_uses_shared_aliases) ... ok @@ -23,6 +23,6 @@ test_tokenize_precedence_null_and_provenance (__main__.QwenAliasTest.test_tokeni test_unrelated_model_native_efforts_are_not_aliased (__main__.QwenAliasTest.test_unrelated_model_native_efforts_are_not_aliased) ... ok ---------------------------------------------------------------------- -Ran 14 tests in 2.532s +Ran 14 tests in 2.536s OK diff --git a/provenance/pr8-final-exact-image-reconstruction-twice.log b/provenance/pr8-final-exact-image-reconstruction-twice.log index 245f40f..fcddb75 100644 --- a/provenance/pr8-final-exact-image-reconstruction-twice.log +++ b/provenance/pr8-final-exact-image-reconstruction-twice.log @@ -1,6 +1,6 @@ {"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": true} {"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": true} -{"run": 1, "files": 4392, "tree_digest_sha256": "f98edc6b100d20bfd993b0f02183e53ac8f5b7bf41c849779877ee2090878482"} +{"run": 1, "files": 4392, "tree_digest_sha256": "72d547ccf24958a58b97a931b8535b97327f4b8bfc03ef368e478d5abd58a490"} {"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": true} {"profile": "invalid-token-failure", "source_files": 4392, "full_tree_verified": true} -{"run": 2, "files": 4392, "tree_digest_sha256": "f98edc6b100d20bfd993b0f02183e53ac8f5b7bf41c849779877ee2090878482"} +{"run": 2, "files": 4392, "tree_digest_sha256": "72d547ccf24958a58b97a931b8535b97327f4b8bfc03ef368e478d5abd58a490"} diff --git a/provenance/pr8-final-full-package.log b/provenance/pr8-final-full-package.log index 0a1ea8e..167aba9 100644 --- a/provenance/pr8-final-full-package.log +++ b/provenance/pr8-final-full-package.log @@ -91,6 +91,6 @@ test_fc2_rejects_unproven_output_padding (test_vision_cpu.VisionTests.test_fc2_r test_fc2_restores_logical_order_and_handles_no_bias (test_vision_cpu.VisionTests.test_fc2_restores_logical_order_and_handles_no_bias) ... ok ---------------------------------------------------------------------- -Ran 90 tests in 5.552s +Ran 90 tests in 5.471s OK diff --git a/provenance/pr8-final-invalid-token-green.log b/provenance/pr8-final-invalid-token-green.log index d0a1e37..d03acb4 100644 --- a/provenance/pr8-final-invalid-token-green.log +++ b/provenance/pr8-final-invalid-token-green.log @@ -16,7 +16,7 @@ test_patch_and_inventory_drift_fail_closed (tests.test_invalid_token_packaging.I test_runtime_drift_fails_closed (tests.test_invalid_token_packaging.InvalidTokenPackagingTest.test_runtime_drift_fails_closed) ... ok ---------------------------------------------------------------------- -Ran 4 tests in 0.067s +Ran 4 tests in 0.089s OK [OK] @@ -28,7 +28,7 @@ sha256:872a2bda228e39aa9c1af729b47cc28f7862e7859e448f1a8868b85a4051f404 warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") /sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") -W0914 14:06:57.123000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +W0914 14:32:17.456000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok @@ -45,13 +45,14 @@ test_failed_response_cannot_be_replayed_as_predecessor (__main__.InvalidTokenFai ok test_failed_response_retrieval_preserves_failure_and_partial_output (__main__.InvalidTokenFailureTest.test_failed_response_retrieval_preserves_failure_and_partial_output) ... ok test_graceful_abort_remains_cancelled (__main__.InvalidTokenFailureTest.test_graceful_abort_remains_cancelled) ... ok +test_harmony_responses_stream_failure_uses_failed_terminal_event (__main__.InvalidTokenFailureTest.test_harmony_responses_stream_failure_uses_failed_terminal_event) ... ok test_invalid_first_token_never_reaches_decode (__main__.InvalidTokenFailureTest.test_invalid_first_token_never_reaches_decode) ... ok test_invalid_token_is_failure_even_past_length_cap (__main__.InvalidTokenFailureTest.test_invalid_token_is_failure_even_past_length_cap) ... ok test_ordinary_scheduler_finishes_are_unchanged (__main__.InvalidTokenFailureTest.test_ordinary_scheduler_finishes_are_unchanged) ... ok test_responses_full_and_stream_expose_failure (__main__.InvalidTokenFailureTest.test_responses_full_and_stream_expose_failure) ... ok ---------------------------------------------------------------------- -Ran 15 tests in 0.799s +Ran 16 tests in 0.846s OK [OK] diff --git a/provenance/pr8-final-multimodal-4.log b/provenance/pr8-final-multimodal-4.log index 5e91453..5a3ea5c 100644 --- a/provenance/pr8-final-multimodal-4.log +++ b/provenance/pr8-final-multimodal-4.log @@ -2,7 +2,7 @@ warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") /sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") -W0914 14:09:11.822000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +W0914 14:33:21.085000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' test_image_offset_positions_match_registered_architecture (__main__.QwenMultimodalAliasTest.test_image_offset_positions_match_registered_architecture) ... [transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} [transformers] Unrecognized keys in `rope_parameters` for 'rope_type'='default': {'mrope_interleaved', 'mrope_section'} ok diff --git a/provenance/pr8-final-packaging-17.log b/provenance/pr8-final-packaging-17.log index a64000f..a243da1 100644 --- a/provenance/pr8-final-packaging-17.log +++ b/provenance/pr8-final-packaging-17.log @@ -17,6 +17,6 @@ test_patch_and_inventory_drift_fail_closed (tests.test_invalid_token_packaging.I test_runtime_drift_fails_closed (tests.test_invalid_token_packaging.InvalidTokenPackagingTest.test_runtime_drift_fails_closed) ... ok ---------------------------------------------------------------------- -Ran 17 tests in 0.188s +Ran 17 tests in 0.219s OK diff --git a/provenance/pr8-final-responses-75.log b/provenance/pr8-final-responses-75.log index 024ae7e..0f80eb1 100644 --- a/provenance/pr8-final-responses-75.log +++ b/provenance/pr8-final-responses-75.log @@ -2,7 +2,7 @@ warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") /sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") -W0914 14:08:23.679000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +W0914 14:32:59.050000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' test_direct_renderer_policy_unchanged (runtime_chat_effort.ChatEffortTest.test_direct_renderer_policy_unchanged) ... ok test_effort_matrix_and_no_cross_request_leak (runtime_chat_effort.ChatEffortTest.test_effort_matrix_and_no_cross_request_leak) ... ok test_invalid_effort_rejected_in_both_forms (runtime_chat_effort.ChatEffortTest.test_invalid_effort_rejected_in_both_forms) ... ok @@ -91,9 +91,9 @@ test_mock_http_forced_choice_cannot_emit_other_declared_tool (__main__.MockHTTPT return self.create_error_response(str(e)) Error while streaming /v1/responses Traceback (most recent call last): - File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3102, in responses_stream_generator_non_harmony + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3119, in responses_stream_generator_non_harmony for ev in _emit_tool_calls(opening): - File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2993, in _emit_tool_calls + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3010, in _emit_tool_calls request._compat_registry.output_identity(state["name"]) File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 121, in output_identity raise ValueError("Generated tool call does not match forced tool choice") @@ -107,9 +107,9 @@ test_mock_http_native_auto_and_required (__main__.MockHTTPTest.test_mock_http_na test_mock_http_native_unknown_fails_closed (__main__.MockHTTPTest.test_mock_http_native_unknown_fails_closed) ... Tool 'workspace.NOT_DECLARED' is not defined in the tools list. Error while streaming /v1/responses Traceback (most recent call last): - File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3102, in responses_stream_generator_non_harmony + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3119, in responses_stream_generator_non_harmony for ev in _emit_tool_calls(opening): - File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 2993, in _emit_tool_calls + File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/serving_responses.py", line 3010, in _emit_tool_calls request._compat_registry.output_identity(state["name"]) File "/sgl-workspace/sglang/python/sglang/srt/entrypoints/openai/responses_compat.py", line 122, in output_identity return self.identity(qualified) @@ -157,6 +157,6 @@ test_qwen_replay_preserves_assistant_stage_order (__main__.ResponsesCompatTest.t test_stored_response_replays_reasoning_phase_and_call_together (__main__.ResponsesCompatTest.test_stored_response_replays_reasoning_phase_and_call_together) ... ok ---------------------------------------------------------------------- -Ran 75 tests in 5.024s +Ran 75 tests in 5.002s OK diff --git a/provenance/pr8-harmony-terminal-red.log b/provenance/pr8-harmony-terminal-red.log new file mode 100644 index 0000000..f35abb5 --- /dev/null +++ b/provenance/pr8-harmony-terminal-red.log @@ -0,0 +1,22 @@ +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/awq/awq.py:52: UserWarning: Only CUDA, HIP and XPU support AWQ currently. + warnings.warn(f"Only CUDA, HIP and XPU support AWQ currently.") +/sgl-workspace/sglang/python/sglang/srt/layers/quantization/gguf.py:69: UserWarning: Only CUDA, MUSA and NPU support GGUF quantization currently. + warnings.warn(f"Only CUDA, MUSA and NPU support GGUF quantization currently.") +W0914 14:28:07.078000 1 torch/utils/cpp_extension.py:178] No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda' +test_harmony_responses_stream_failure_uses_failed_terminal_event (__main__.InvalidTokenFailureTest.test_harmony_responses_stream_failure_uses_failed_terminal_event) ... FAIL + +====================================================================== +FAIL: test_harmony_responses_stream_failure_uses_failed_terminal_event (__main__.InvalidTokenFailureTest.test_harmony_responses_stream_failure_uses_failed_terminal_event) +---------------------------------------------------------------------- +Traceback (most recent call last): + File "/repo/tests/runtime_invalid_token_failure.py", line 386, in test_harmony_responses_stream_failure_uses_failed_terminal_event + self.assertEqual(events[-1]["type"], "response.failed") +AssertionError: 'response.completed' != 'response.failed' +- response.completed ++ response.failed + + +---------------------------------------------------------------------- +Ran 1 test in 0.430s + +FAILED (failures=1) diff --git a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py index 2a242a3..b37663d 100644 --- a/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/runtime.invalid-token-failure/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -2411,9 +2411,26 @@ async def empty_async_generator(): # OpenAI SDK's Tool union may not know extended types; drop echo. response_dict["tools"] = [] + status = final_response.status + terminal_event = ( + openai_responses_types.ResponseIncompleteEvent if status == "incomplete" + else ( + openai_responses_types.ResponseFailedEvent + if status in ("failed", "cancelled") + else openai_responses_types.ResponseCompletedEvent + ) + ) + terminal_type = ( + "response.incomplete" if status == "incomplete" + else ( + "response.failed" + if status in ("failed", "cancelled") + else "response.completed" + ) + ) yield _send_event( - openai_responses_types.ResponseCompletedEvent( - type="response.completed", + terminal_event( + type=terminal_type, sequence_number=-1, response=response_dict, ) diff --git a/scripts/verify_invalid_token_failure.py b/scripts/verify_invalid_token_failure.py index 564b741..c2c0eb2 100755 --- a/scripts/verify_invalid_token_failure.py +++ b/scripts/verify_invalid_token_failure.py @@ -92,7 +92,7 @@ def package_records(): validation = manifest["validation"] expected_counts = { - "invalid_token_runtime_tests": 15, + "invalid_token_runtime_tests": 16, "invalid_token_packaging_tests": 4, "responses_tests": 75, "effort_tests": 14, diff --git a/tests/runtime_invalid_token_failure.py b/tests/runtime_invalid_token_failure.py index f7e73ba..c6644d0 100644 --- a/tests/runtime_invalid_token_failure.py +++ b/tests/runtime_invalid_token_failure.py @@ -11,7 +11,7 @@ from runtime_chat_effort import ChatEffortTest from sglang.srt.entrypoints.anthropic.protocol import AnthropicMessagesRequest from sglang.srt.entrypoints.anthropic.serving import AnthropicServing -from sglang.srt.entrypoints.context import SimpleContext +from sglang.srt.entrypoints.context import SimpleContext, StreamingHarmonyContext from sglang.srt.entrypoints.openai.protocol import ( ChatCompletionRequest, CompletionRequest, @@ -346,6 +346,47 @@ async def collect_responses(): ) self.assertFalse(any(event["type"] == "response.completed" for event in events)) + def test_harmony_responses_stream_failure_uses_failed_terminal_event(self): + request = ResponsesRequest( + model="fixture-qwen", input="Hi", stream=True, store=True + ) + metadata = RequestResponseMetadata(request_id=request.request_id) + self.responses.use_harmony = True + self.responses._make_response_output_items_with_harmony = lambda context: [] + context = StreamingHarmonyContext.__new__(StreamingHarmonyContext) + context.parser = SimpleNamespace(messages=[], last_content_delta=None) + context.is_expecting_start = lambda: False + context.is_assistant_action_turn = lambda: False + context.num_init_messages = 0 + context.num_prompt_tokens = 0 + context.num_cached_tokens = 0 + context.num_output_tokens = 0 + context.num_reasoning_tokens = 0 + context.finish_reason = invalid_finish(serialized=True) + + async def stream_result(): + yield context + + async def collect_responses(): + return [ + frame + async for frame in self.responses.responses_stream_generator( + request, + {}, + stream_result(), + context, + "fixture-qwen", + self.chat.tokenizer_manager.tokenizer, + metadata, + require_reasoning=False, + ) + ] + + events = data_payloads(asyncio.run(collect_responses())) + self.assertEqual(events[-1]["type"], "response.failed") + self.assertEqual(events[-1]["response"]["status"], "failed") + self.assertFalse(any(event["type"] == "response.completed" for event in events)) + def test_failed_response_retrieval_preserves_failure_and_partial_output(self): failed = self._store_failed_response() From dc9b10b22192e5877ba6feef3d6979e4fede03df Mon Sep 17 00:00:00 2001 From: Kanadaj Date: Mon, 14 Sep 2026 16:07:06 +0100 Subject: [PATCH 19/20] docs: record cumulative compatibility image publication --- README.md | 27 ++++---- docs/invalid-token-failure.md | 18 +++-- docs/production-cumulative-compat-20260914.md | 69 +++++++++++++++++++ 3 files changed, 93 insertions(+), 21 deletions(-) create mode 100644 docs/production-cumulative-compat-20260914.md diff --git a/README.md b/README.md index a6d6a7d..cd97be3 100644 --- a/README.md +++ b/README.md @@ -1,19 +1,18 @@ # Qwen TP2 packed-PLE vision on SM120 -**Unpublished CPU candidate:** [Responses compatibility and Qwen phase/order](docs/responses-compat.md) -adds separately attested boundary and streaming/nonstream ordering patches after the -effort-alias profile, including its `minimal` → `low` alias. The ordered nonstream -path constructs typed output directly and retains usage details and requested -logprobs; structural splitting is limited to recognized Qwen markers and the loaded -`qwen3_8_flash_next` / `_text` model types. The cumulative -[Qwen Flash-Next multimodal alias profile](docs/qwen-multimodal-alias.md) additionally -restores four existing Qwen VL processor paths under the release model type. The -[invalid generated-token failure profile](docs/invalid-token-failure.md) completes -the cumulative `0015` → `0016` → `0017` → `0018` → `0019` stack: scheduler -faults retain `InvalidTokenError` through Chat and Completions SSE, Responses -failures remain retrievable but cannot be replayed as `previous_response_id`, and -graceful cancellations are unchanged. -Historical production profiles below are unchanged; no deployment is implied. +**Published cumulative compatibility runtime:** +[`production-cumulative-compat-20260914-v3`](docs/production-cumulative-compat-20260914.md) +contains the ordered `0015` → `0016` → `0017` → `0018` → `0019` stack at +`docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:f2859d1ccf824a5295088cf578eba89b0f3eeefff6ae7679c3f5d64af0689458`. +It includes the Qwen effort aliases, [Responses namespace/custom and phase/order +compatibility](docs/responses-compat.md), [Flash-Next multimodal processor +aliases](docs/qwen-multimodal-alias.md), and [invalid generated-token failure +propagation](docs/invalid-token-failure.md). The image was rebuilt from clean +`main`, verified against all 4,392 source hashes, and anonymously pulled by tag +and digest. Publication does not imply production deployment. + +Historical production profiles below remain available as rollback and audit +records. Publishable source and deployment package for the locally accepted Qwen3.8 Flash-Next LIL NVFP4 stack. **No model weights, container archives, credentials, diff --git a/docs/invalid-token-failure.md b/docs/invalid-token-failure.md index 75b69ba..02a556e 100644 --- a/docs/invalid-token-failure.md +++ b/docs/invalid-token-failure.md @@ -1,10 +1,12 @@ -# Invalid generated-token failures — cumulative local candidate +# Invalid generated-token failures — published cumulative runtime -This profile is rebased onto main -`e5d93387e03c110de6f6f483a0ff5ed44d3a1a1e`. It transplants original PR #8 -head `4059ace2b2faa2d7972f7704c8fdca0985a35b1a` and the reviewed functional -corrections from `63f43b7ad68b40831f3b1a47e880a56a2db66a42`. Nothing was pushed, -merged, published, deployed, or applied to a running service. +This profile is merged into `main` at +`facd7be72dc5abcfc8d99c9e6fa750e73ad8e350`. It preserves original PR #8 +head `4059ace2b2faa2d7972f7704c8fdca0985a35b1a`, the reviewed functional +corrections, and the final Harmony terminal-event fix. The cumulative image is +published at the immutable digest documented in +[`production-cumulative-compat-20260914.md`](production-cumulative-compat-20260914.md). +It has not been deployed to the running production service. ## Behavior @@ -101,4 +103,6 @@ docker build --pull=false \ No GPU generation was forced to produce an invalid token. The change makes the existing fatal condition visible and replay-safe; it does not attempt generation -recovery. The image is local only and has not been published or deployed. +recovery. The published image passed exact source, CPU, package, and anonymous +registry-transfer checks, but has not been booted with the production model or +deployed. diff --git a/docs/production-cumulative-compat-20260914.md b/docs/production-cumulative-compat-20260914.md new file mode 100644 index 0000000..ae76ccf --- /dev/null +++ b/docs/production-cumulative-compat-20260914.md @@ -0,0 +1,69 @@ +# Published cumulative compatibility runtime — 2026-09-14 + +## Immutable image + +```text +docker.io/kanadaj/sglang-qwen38fn-sm120-turbo:production-cumulative-compat-20260914-v3 +docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:f2859d1ccf824a5295088cf578eba89b0f3eeefff6ae7679c3f5d64af0689458 +``` + +Source revision: `facd7be72dc5abcfc8d99c9e6fa750e73ad8e350`. +Registry config digest: +`sha256:751a89104df49a9777ad577dc48aa4c2ed833c4f86b373c633f96ac5fc1756bb`. + +The runtime keeps serving arguments external. It does not embed a production +launcher, model path, checkpoint, route, or GPUStack configuration. + +## Included compatibility stack + +The image applies, in order: + +1. `0015-qwen-flash-next-effort-alias.patch` +2. `0016-responses-namespace-custom-boundary.patch` +3. `0017-responses-phase-order.patch` +4. `0018-qwen-flash-next-multimodal-alias.patch` +5. `0019-invalid-generated-token-failure.patch` + +This includes Qwen-only effort aliases, Responses namespace/custom-tool and +phase/order behavior, release-name multimodal processor paths, and consistent +invalid-token failure propagation through Chat, Completions, non-Harmony +Responses, and Harmony Responses. + +## Verification + +The image was built from a fresh clean clone using: + +```bash +docker buildx build --load --provenance=false --network=none \ + --no-cache --pull \ + --build-arg SOURCE_REVISION=facd7be72dc5abcfc8d99c9e6fa750e73ad8e350 \ + -f Dockerfile.invalid-token-failure \ + -t docker.io/kanadaj/sglang-qwen38fn-sm120-turbo:production-cumulative-compat-20260914-v3 . +``` + +Verification completed both from the clean source revision and inside the built +image: + +- invalid-token runtime: 16 tests; +- Responses compatibility: 75 tests; +- effort aliases: 14 tests; +- multimodal aliases: 4 tests; +- full package: 90 tests; +- dedicated packaging: 17 tests; +- two independent complete source reconstructions; +- 4,392 expected and present source files, with zero missing, extra, or + mismatched files. + +The source-revision label, entrypoint, command, manifest, registry config, and +canonical manifest bytes were checked. Anonymous manifest access and pulls by +both tag and digest succeeded. + +## Evidence boundary + +This is a source, CPU/package, image, and registry-publication result. It is not +a production rollout. No GPU model boot, invalid-token fault injection in a +live speculative engine, or semantic video-order qualification was performed +for this published image. + +Local publication receipts were retained outside the repository at +`/home/kanadaj/sglang-publication-20260914`. From b6c8bcc48c6c6f9446f7dcecac0752dced8df526 Mon Sep 17 00:00:00 2001 From: ktsaou <2662304+ktsaou@users.noreply.github.com> Date: Mon, 14 Sep 2026 20:14:10 +0000 Subject: [PATCH 20/20] fix(hicache): restore Qwen companion state and backport ordering fixes --- Dockerfile.hicache-wip | 14 + README.md | 5 + docs/hicache-wip.md | 247 ++++++++++ patches/0020-hicache-ple-state.patch | 308 +++++++++++++ patches/0021-hicache-file-integrity.patch | 67 +++ patches/0022-hicache-qsa-sidecar.patch | 228 ++++++++++ ...0023-qsa-sparse-gather-memory-safety.patch | 146 ++++++ patches/0024-router-pdl-bias-order.patch | 34 ++ patches/0025-hicache-load-order.patch | 65 +++ patches/0026-qsa-short-extend-bounds.patch | 10 + patches/series.hicache-wip | 7 + provenance/hicache-wip.json | 219 +++++++++ scripts/test_hicache_wip.sh | 48 ++ scripts/verify_hicache_wip.py | 126 ++++++ tests/test_hicache_wip_packaging.py | 82 ++++ .../hicache/test_hicache_file_gpu_local.py | 42 ++ validation/hicache/test_hicache_file_local.py | 237 ++++++++++ validation/hicache/test_hicache_load_order.py | 79 ++++ .../hicache/test_hicache_load_order_gpu.py | 84 ++++ .../hicache/test_hicache_ple_gpu_local.py | 192 ++++++++ validation/hicache/test_hicache_ple_local.py | 420 ++++++++++++++++++ .../hicache/test_hicache_qsa_gpu_local.py | 163 +++++++ validation/hicache/test_hicache_qsa_local.py | 254 +++++++++++ validation/hicache/test_qsa_short_extend.py | 50 +++ .../hicache/test_qsa_strided_zero_fill.py | 192 ++++++++ validation/hicache/validate_router_pdl_gpu.py | 47 ++ 26 files changed, 3366 insertions(+) create mode 100644 Dockerfile.hicache-wip create mode 100644 docs/hicache-wip.md create mode 100644 patches/0020-hicache-ple-state.patch create mode 100644 patches/0021-hicache-file-integrity.patch create mode 100644 patches/0022-hicache-qsa-sidecar.patch create mode 100644 patches/0023-qsa-sparse-gather-memory-safety.patch create mode 100644 patches/0024-router-pdl-bias-order.patch create mode 100644 patches/0025-hicache-load-order.patch create mode 100644 patches/0026-qsa-short-extend-bounds.patch create mode 100644 patches/series.hicache-wip create mode 100644 provenance/hicache-wip.json create mode 100755 scripts/test_hicache_wip.sh create mode 100755 scripts/verify_hicache_wip.py create mode 100644 tests/test_hicache_wip_packaging.py create mode 100644 validation/hicache/test_hicache_file_gpu_local.py create mode 100644 validation/hicache/test_hicache_file_local.py create mode 100644 validation/hicache/test_hicache_load_order.py create mode 100644 validation/hicache/test_hicache_load_order_gpu.py create mode 100644 validation/hicache/test_hicache_ple_gpu_local.py create mode 100644 validation/hicache/test_hicache_ple_local.py create mode 100644 validation/hicache/test_hicache_qsa_gpu_local.py create mode 100644 validation/hicache/test_hicache_qsa_local.py create mode 100644 validation/hicache/test_qsa_short_extend.py create mode 100644 validation/hicache/test_qsa_strided_zero_fill.py create mode 100644 validation/hicache/validate_router_pdl_gpu.py diff --git a/Dockerfile.hicache-wip b/Dockerfile.hicache-wip new file mode 100644 index 0000000..5a30592 --- /dev/null +++ b/Dockerfile.hicache-wip @@ -0,0 +1,14 @@ +# EXPERIMENTAL: opt-in HiCache profile, isolated from the default images. +# Configuration-specific qualification is recorded in docs/hicache-wip.md. +FROM docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:f2859d1ccf824a5295088cf578eba89b0f3eeefff6ae7679c3f5d64af0689458 +ARG SOURCE_REVISION +LABEL org.opencontainers.image.source="https://github.com/kanadaj/sglang" \ + org.opencontainers.image.revision="${SOURCE_REVISION}" \ + org.opencontainers.image.description="Opt-in Qwen HiCache state-transfer profile; qualify the deployment configuration" +COPY patches/0020-hicache-ple-state.patch patches/0021-hicache-file-integrity.patch patches/0022-hicache-qsa-sidecar.patch patches/0023-qsa-sparse-gather-memory-safety.patch patches/0024-router-pdl-bias-order.patch patches/0025-hicache-load-order.patch patches/0026-qsa-short-extend-bounds.patch patches/series.hicache-wip /opt/qwen-hicache-wip/patches/ +COPY provenance/invalid-token-failure-runtime-files.json provenance/hicache-wip.json /opt/qwen-hicache-wip/provenance/ +COPY scripts/verify_hicache_wip.py /opt/qwen-hicache-wip/scripts/verify_hicache_wip.py +RUN python3 -B /opt/qwen-hicache-wip/scripts/verify_hicache_wip.py \ + --tree /sgl-workspace/sglang --apply +ENTRYPOINT ["python3", "-m", "sglang.launch_server"] +CMD ["--help"] diff --git a/README.md b/README.md index cd97be3..5d7668b 100644 --- a/README.md +++ b/README.md @@ -11,6 +11,11 @@ propagation](docs/invalid-token-failure.md). The image was rebuilt from clean `main`, verified against all 4,392 source hashes, and anonymously pulled by tag and digest. Publication does not imply production deployment. +**Opt-in HiCache profile:** [Qwen RAM/file state transfer](docs/hicache-wip.md) +adds companion-state handling and upstream QSA, router and restore-order fixes +after the cumulative runtime. See the configuration-specific live results and +remaining limits before enabling it; default images and patch series are unchanged. + Historical production profiles below remain available as rollback and audit records. diff --git a/docs/hicache-wip.md b/docs/hicache-wip.md new file mode 100644 index 0000000..43961fe --- /dev/null +++ b/docs/hicache-wip.md @@ -0,0 +1,247 @@ +# Qwen HiCache state transfer — opt-in profile + +## Status + +**The documented TP2/MTP3 RAM-and-file configuration passed runtime qualification.** +The profile remains opt-in; other configurations require their own qualification. +The series preserves the Qwen-specific HiCache state transfers and adds missing +upstream QSA, router, and restore-order corrections. Historical candidates failed +with repeated punctuation; current-candidate results are recorded separately below. + +`Dockerfile.hicache-wip` and `patches/series.hicache-wip` are isolated from every +default and production profile. No repository launcher enables HiCache, and the ordinary `Dockerfile` does not +install this work. The documented TP2 trial uses an explicitly selected derived image. + +## Defects addressed by the patch series + +The Qwen Flash-Next runtime has state outside the ordinary full-attention KV and +Mamba recurrent buffers. Restoring only the existing host-pool components can +therefore reuse a prefix with incomplete model state. + +1. `0020-hicache-ple-state.patch` adds the PLE short-convolution and N-gram + slot tensors to Mamba host checkpoints. It includes their bytes in host-pool + sizing, carries them through RAM and flat page representations, and waits for + the first relevant transfer event before an early PLE read. +2. `0021-hicache-file-integrity.patch` treats missing, truncated, or unreadable + file pages as cache misses so a prefetch worker can continue. It permits the + complete PLE checkpoint format only with the tested built-in file backend; + other storage backends remain rejected. +3. `0022-hicache-qsa-sidecar.patch` adds a required page-aligned sidecar for + compressed QSA index keys, including packed MTP draft layers. It budgets the + index inside the KV share of the existing host limit, requires complete pages, + and waits for the corresponding layer transfer before QSA reads the index. + +The patch preimages match the 4,392-file cumulative compatibility inventory and +the immutable base image published from current `main`: + +```text +kanadaj/sglang-qwen38fn-sm120-turbo@sha256:f2859d1ccf824a5295088cf578eba89b0f3eeefff6ae7679c3f5d64af0689458 +``` + +This parent already contains patches 0015–0019 for Responses, effort aliases, +multimodal aliases, and invalid-token failures. `provenance/hicache-wip.json` +records every hash transition, the ordered patch hashes, and the resulting +4,393-file inventory digest. The one new source file is +`python/sglang/srt/mem_cache/qsa_pool_host.py`. + +## Retained evidence + +These historical results were collected on the preserved pre-rebase candidate. +They establish the patch behavior because all eight HiCache preimages are +byte-identical in the cumulative parent, but they do not replace fresh tests of +the rebuilt cumulative candidate: + +| Gate | Result | What it establishes | +|---|---:|---| +| Packaged CPU PLE/file/QSA fixtures | 55 passed | Layout, sizing, lifecycle, file-error, sidecar, and wait behavior | +| PLE transfer cases | 24 per GPU | Real kernel copies for the companion slot state | +| Combined PLE/Mamba/target/draft checkpoint | 1 passed | Repeated asynchronous relocation and event-ring reuse | +| File reconstruction checkpoint | 1 passed | GPU→RAM→file→RAM→GPU with a reconstructed backend | +| QSA relocation | 4 per GPU | Target and draft indices, two layouts, RAM and reconstructed files | +| Exact live restore fixture | cold 4/4; storage 4/4; GPU replay 4/4 | Positive storage and H2D use after a flush | +| Ordinary 200-tool catalogue/replay | **32/48** | **Blocking end-to-end corruption remains** | + +The PLE GPU result covers the kernel transfer backend. Six direct-copy cases +were deselected after the unmodified parent failed them with the same invalid +argument error; this profile makes no direct-backend qualification claim. + +The live restore transferred 81,788,928 more bytes than the preceding build, +exactly 832 bytes per restored KV token. This matches the added QSA index state +and supports the omitted-state diagnosis for that fixture. + +The later 32/48 failure recorded no new host or storage reads. That means the +failure cannot be attributed solely to corrupt data restored by these patches. +Instrumented diagnostics also observed NaNs in CUDA-graph draft extension, but +they did not establish whether that path caused the emitted punctuation. This +draft contains no draft-extension workaround. + +## Verification and CPU fixtures + +The standard package test remains unchanged. Verify the isolated patch hashes, +declared transitions, and result inventory: + +```bash +python3 scripts/verify_hicache_wip.py +python3 -m unittest tests/test_hicache_wip_packaging.py -v +``` + +Build the experimental image only for investigation: + +```bash +docker build --pull=false -f Dockerfile.hicache-wip \ + --build-arg SOURCE_REVISION="$(git rev-parse HEAD)" \ + -t qwen-hicache:wip . +HICACHE_WIP_IMAGE=qwen-hicache:wip bash scripts/test_hicache_wip.sh +``` + +The runner uses no network or GPUs. It executes the 67 CPU cases from +`validation/hicache/` inside the candidate image. The three GPU files are retained +for review and require an explicitly isolated GPU environment; the runner does +not claim or acquire an available GPU. + +To verify and apply the patch series to a complete export of the exact base +image: + +```bash +python3 scripts/verify_hicache_wip.py --tree /path/to/sglang --apply +``` + +The verifier checks the complete base inventory before applying anything and +the complete result inventory afterward. The Docker build runs this mode, so a +clean application against the exact parent is required to produce an image. + +## Qualification scope and limits + +- Results apply to the documented TP2/MTP3 configuration and exact runtime + inventory. They do not establish support for every HiCache backend or layout. +- The built-in file backend and kernel transfer path are covered. Other storage + backends remain intentionally rejected when PLE companion state is present; + the direct transfer path is not qualified. +- The prior punctuation failures remain in the historical record. Current + component regressions and full-model results are recorded below; passing them + does not prove that every historical failure had one identical cause. +- RAM-only pressure tests did not establish a host hit. The combined file path + did exercise RAM-to-GPU restoration with correct answers. +- Best-effort prefetch does not guarantee a disk hit for every request, and one + observed tier report attributed a prefetched prefix to device cache. +- Very short video ordering remains a known limitation. The multi-frame video + and image tests below use eight frames per color at four frames per second. +- Full-model disk persistence passed after restarting the same image:4/4 correct + answers, two explicit16384-token disk-hit reports and49152 KV tokens restored + per rank. Best-effort misses and the tier-attribution limitation remain as above. + +### Upstream QSA and router corrections (2026-09-14) + +Patch0023 backports merged [upstream38851](https://github.com/sgl-project/sglang/pull/38851). +The two runtime files preserve the upstream change; only surrounding formatting +needed adaptation. The upstream GPU regression is retained in +`validation/hicache/test_qsa_strided_zero_fill.py`. This fixes page-strided scratch +initialization, integer address width and FP8 gather conversion. It is a general +QSA correction, not a HiCache state-transfer feature; final publication should +keep that distinction. Component negatives establish the specific defects; full-model outcomes follow below. + +The main-based RAM-only candidate without0023 failed32/48 ordinary tool/replay +cases; disabling scheduler overlap still failed8/48. Single replay and a reduced +mixed replay then completed without the punctuation cascade. These findings do +not qualify the configuration or establish that streaming serialization is broken. + +Patch0024 adapts merged [upstream38290](https://github.com/sgl-project/sglang/pull/38290) +by moving PDL waits before bias loads in the Triton and radix router kernels. +It retains the existing bias API; the separate zero-bias optimization is not +required. Compiled PTX on SM120 shows pre-fix first bias load before the wait +and post-fix loads after it, for softmax and sigmoid. Both versions pass settled +routing numerics; the regression distinguishes dependency ordering. Standalone +GPU validation: `python3 validation/hicache/validate_router_pdl_gpu.py` in the +candidate runtime. Current cold-start and full-model results follow below. + +### Upstream restore ordering + +Patch 0025 adapts merged upstream PR36738 (H2D fencing behind in-flight forwards) +and open PR36743 (final-layer restore completion before deferred Mamba whole-slot +copy). Both waits preserve asynchronous GPU execution; they order dependent work +without disabling scheduler overlap or CUDA graphs. The controller's stream is +wired by the scheduler after cache assembly. The recurrent wait is a no-op without +a registered transfer counter or active load. CPU tests cover fence-before-submit, +empty queues, both checkpoint copy paths and cache-off behavior. A delayed GPU +restore regression fails on candidate3 with all3072 copied elements stale. +Candidate5 full-model and restoration results follow below. + +### Short cached extensions + +Patch0026 reuses upstream PR39446's bounds clamp before compressed-key gather. +A cached prefix can leave1–3 tokens, while padded compression groups still contain +four gather indices and write only reserved slot0. The prior fallback raises +IndexError and the fused kernel reads outside the source rows. The regression uses +the actual write planner and indexer method:1/2/3 rows fail before the patch; +4/5/8-row complete-group controls pass. Valid complete-group averages must remain +unchanged. Runtime restoration remains a separate qualification gate. + +## Current candidate results (2026-09-14) + +Candidate5 contains patches0020–0026 on the pinned cumulative parent. Its full +4393-file inventory passed clean application verification;67 CPU cache cases, +5 packaging cases and95 repository tests passed. Real GPU delayed-copy tests +cover both whole-slot restoration and reuse after an in-flight forward. QSA +strided gather and router dependency-order checks also passed. + +The TP2 runtime retains MTP3, scheduler overlap, target/draft CUDA graphs,64 +request slots,524288 context and image/video inputs. GPU fraction is0.92 with +4342208 KV tokens. Host allocation is30GB per rank, including companion state; +file payload cap is256GB per rank. This produces2541440 host KV tokens and371 +Mamba checkpoint slots per rank. The RAM37 trial was stopped by a52GiB available +RAM threshold; the smaller host allocation preserves additional headroom. + +| Current-candidate check | Observed result | +|---|---| +| RAM-only cold tool catalogue/replay |48/48| +| RAM-only mixed efforts |96/96| +| RAM-only pressure/retrieval |Correct answers; no host restoration observed, so this does not qualify RAM hits| +| Combined-cache cold retrieval |4/4| +| After idle GPU/RAM flush |4/4 correct; two explicit16384-token disk hits;49152 KV tokens restored per rank| +| Post-restoration tool catalogue/replay |48/48| +| Post-restoration mixed efforts |96/96| +| Image-bearing tool results |16/16| +| Direct Responses client streaming |1033 text updates across9.925s, completed final answer| +| Disk persistence across full restart |4/4 correct; positive disk hits and H2D restoration| +| Final post-restart tool replay |48/48| +| Mixed-load qualification |603.414s passed;64 actual active;72 background requests without client errors; clean cancellation/drain; media32/32;523264-token retrieval; six tool rounds288/288| + +The strict disk harness did not pass its100% hit-rate assertion. The configured +`best_effort` prefetch policy allows a request to proceed without waiting for disk: +one case recomputed, and another reported a device hit despite a logged disk +prefetch. Two distinct cases explicitly reported disk-only hits and returned +exact expected answers. Transfer counters independently confirm H2D activity. +Do not report four disk hits or use correct recomputation alone as restoration +evidence. An earlier harness run also waited for more backup tokens than its +per-case restore criterion required; that failed invocation is retained. + +### Short-prompt decode performance + +The pinned benchmark measured30 seconds at each concurrency with HiCache enabled, +MTP3, normal target/draft graphs and scheduler overlap. Each cell reached its +requested active count, with no reported errors, detected loops, underfilling or +capacity limitation. These are measurements of this configuration, not a matched +cache-on/cache-off comparison. + +| Concurrent requests | Aggregate output tokens/s | +|---:|---:| +|1|249.1| +|2|443.9| +|4|711.0| +|8|1074.7| +|16|1551.2| +|32|2170.0| +|64|2843.0| + +No additional performance feature was disabled for this candidate. Prefill CUDA +graphs remain disabled as in the baseline; draft-extension graphs are enabled. + +The selected instance remained healthy and idle after the final48-case replay, +with no automatic restart and about68GiB RAM available. The minimum sampled +availability over the preceding combined-cache soak and benchmark was62.502GiB. +A configuration-specific systemd monitor checks available RAM every2s and stops +that instance below52GiB; this operational policy is external to the image. + +The tested image ID is`313128307b89435233cfd49a5470f710d66502c65daaa550441f5a3aa755483d`. +Qualification was performed before publication metadata was updated; all runtime +source hashes and patches remain unchanged. diff --git a/patches/0020-hicache-ple-state.patch b/patches/0020-hicache-ple-state.patch new file mode 100644 index 0000000..9d314fe --- /dev/null +++ b/patches/0020-hicache-ple-state.patch @@ -0,0 +1,308 @@ +--- a/python/sglang/srt/mem_cache/ple_state_pool.py ++++ b/python/sglang/srt/mem_cache/ple_state_pool.py +@@ -37,6 +37,10 @@ + def get_cpu_slots(self, indices: torch.Tensor) -> Any: ... + + def load_cpu_slots(self, data: Any, indices: torch.Tensor) -> None: ... ++ ++ def get_slot_tensors(self) -> Tuple[torch.Tensor, ...]: ++ """Contiguous [layer, slot, ...] views for bounded host-cache transfers.""" ++ ... + + + class ShortConvPool: +@@ -110,6 +114,9 @@ + + # SlotIndexedState: slot is dim 1, behind the layer dim. + ++ def get_slot_tensors(self) -> Tuple[torch.Tensor, ...]: ++ return () if self.conv_state is None else (self.conv_state,) ++ + def reset_slots(self, indices: torch.Tensor) -> None: + if self.conv_state is not None and indices.numel() > 0: + self.conv_state[:, indices] = 0 +@@ -201,6 +208,9 @@ + + # SlotIndexedState: slot is dim 0, no layer dim. + ++ def get_slot_tensors(self) -> Tuple[torch.Tensor, ...]: ++ return () if self.context is None else (self.context.unsqueeze(0),) ++ + def reset_slots(self, indices: torch.Tensor) -> None: + if self.context is not None and indices.numel() > 0: + self.context[indices.to(dtype=torch.long)] = self.eos_token_id +--- a/python/sglang/srt/mem_cache/memory_pool_host.py ++++ b/python/sglang/srt/mem_cache/memory_pool_host.py +@@ -58,6 +58,7 @@ + ) + from sglang.srt.mem_cache.pool_host.common import ( + ALLOC_MEMORY_FUNCS, ++ _cuda_host_unregister, + get_allocator_from_storage, + ) + from sglang.srt.mem_cache.pool_host.hisparse import HiSparseHostPoolMixin +@@ -99,6 +100,20 @@ + self.conv_dtype = device_pool.mamba_cache.conv[0].dtype + self.temporal_dtype = device_pool.mamba_cache.temporal.dtype + self.dtype = self.conv_dtype ++ self.sibling_device_tensors = tuple( ++ tensor ++ for sibling in getattr(device_pool, "_slot_siblings", ()) ++ for tensor in sibling.get_slot_tensors() ++ ) ++ for tensor in self.sibling_device_tensors: ++ if tensor.ndim < 3 or not tensor.is_contiguous(): ++ raise ValueError( ++ "HiCache slot state must be contiguous [layer, slot, ...]." ++ ) ++ self.sibling_bytes_per_slot = sum( ++ tensor.shape[0] * int(np.prod(tensor.shape[2:])) * tensor.element_size() ++ for tensor in self.sibling_device_tensors ++ ) + self.size_per_token = self.get_size_per_token() + + if host_size > 0: +@@ -152,8 +167,23 @@ + ) + for conv_state in device_pool.mamba_cache.conv + ] +- +- self.init_kv_buffer() ++ self.sibling_device_ptrs = [ ++ torch.tensor( ++ [layer.data_ptr() for layer in tensor], ++ dtype=torch.uint64, ++ device=self.device_pool.device, ++ ) ++ for tensor in self.sibling_device_tensors ++ ] ++ ++ self.temporal_buffer = None ++ self.conv_buffer = [] ++ self.sibling_buffers = [] ++ try: ++ self.init_kv_buffer() ++ except Exception: ++ self.destroy() ++ raise + self._init_write_back_staging_buffers() + self.lock = threading.RLock() + self.clear() +@@ -226,6 +256,39 @@ + ) + ) + ++ for tensor in self.sibling_device_tensors: ++ self.sibling_buffers.append( ++ alloc_func( ++ (self.size, tensor.shape[0], 1, *tensor.shape[2:]), ++ dtype=tensor.dtype, ++ device=self.device, ++ pin_memory=self.pin_memory, ++ allocator=self.allocator, ++ ) ++ ) ++ ++ def destroy(self): ++ if getattr(self, "_destroyed", False): ++ return ++ buffers = [ ++ getattr(self, "temporal_buffer", None), ++ *getattr(self, "conv_buffer", ()), ++ *getattr(self, "sibling_buffers", ()), ++ ] ++ for buffer in buffers: ++ if ( ++ buffer is not None ++ and buffer.numel() ++ and self.pin_memory ++ and (_is_cuda or _is_hip) ++ ): ++ _cuda_host_unregister(buffer) ++ self.temporal_buffer = None ++ self.conv_buffer = [] ++ self.sibling_buffers = [] ++ self.sibling_device_ptrs = [] ++ super().destroy() ++ + def _init_write_back_staging_buffers(self): + self.temporal_staging_buffer = None + self.conv_staging_buffers = [None] * len(self.conv_buffer) +@@ -239,7 +302,7 @@ + + def get_hybrid_pool_buffer(self): + # Expose all mamba host tensors that need Mooncake buffer registration. +- return [self.temporal_buffer, *self.conv_buffer] ++ return [self.temporal_buffer, *self.conv_buffer, *self.sibling_buffers] + + def _iter_page_tensors(self, index: int): + if self.layout in ["page_first", "page_first_direct"]: +@@ -250,6 +313,8 @@ + yield self.temporal_buffer[:, index : index + self.page_size] + for conv_buf in self.conv_buffer: + yield conv_buf[:, index : index + self.page_size] ++ for buffer in self.sibling_buffers: ++ yield buffer[index] + + @staticmethod + def _flatten_tensor_bytes(tensor: torch.Tensor) -> torch.Tensor: +@@ -298,7 +363,9 @@ + for conv_elem_size in self.conv_state_elem_sizes + ) + temporal_size = self.temporal_state_elem_size * self.temporal_dtype.itemsize +- return (conv_total_size + temporal_size) * self.num_mamba_layers ++ return ( ++ conv_total_size + temporal_size ++ ) * self.num_mamba_layers + self.sibling_bytes_per_slot + + def get_ksize_per_token(self): + return self.get_size_per_token() +@@ -434,6 +501,22 @@ + *, + is_draft: bool = False, + ): ++ # Qwen reads N-gram history before layer execution. Its getter waits on ++ # this first Mamba layer's completion event, including both companions. ++ if layer_id == 0: ++ for host_buffer, tensor in zip( ++ self.sibling_buffers, self.sibling_device_tensors ++ ): ++ for sibling_layer, target in enumerate(tensor): ++ self._copy_tensor_pf_lf( ++ src=host_buffer, ++ dst=target, ++ src_indices=host_indices, ++ dst_indices=device_indices, ++ layer_id=sibling_layer, ++ num_layers=tensor.shape[0], ++ io_backend=io_backend, ++ ) + if self.layout in ["page_first", "page_first_direct"]: + # no ssm state on conv-only models: nothing to transfer + if self.temporal_state_elem_size > 0: +@@ -476,6 +559,20 @@ + def backup_from_device_all_layer( + self, device_pool, host_indices, device_indices, io_backend="kernel" + ): ++ for tensor, host_buffer, device_ptrs in zip( ++ self.sibling_device_tensors, ++ self.sibling_buffers, ++ self.sibling_device_ptrs, ++ ): ++ self._copy_tensor_all_layers_lf_pf( ++ src_layers=tensor, ++ dst=host_buffer, ++ src_indices=device_indices, ++ dst_indices=host_indices, ++ num_layers=tensor.shape[0], ++ io_backend=io_backend, ++ src_ptrs=device_ptrs, ++ ) + if self.layout in ["page_first", "page_first_direct"]: + # no ssm state on conv-only models: a 0-size batched memcpy errors + if self.temporal_state_elem_size > 0: +@@ -585,6 +682,10 @@ + ) + for i in range(len(self.conv_state_shapes)) + ] ++ sibling_meta = [ ++ (buffer.data_ptr(), self._item_size_per_index(buffer)) ++ for buffer in self.sibling_buffers ++ ] + + for i in range(0, len(indices), self.page_size): + # Emit component pointers in stable order: temporal first (dropped +@@ -611,6 +712,9 @@ + ) + ptr_list.append(conv_ptr) + element_size_list.append(conv_element_sizes[j]) ++ for base_ptr, size_bytes in sibling_meta: ++ ptr_list.append(base_ptr + indices[i] * size_bytes) ++ element_size_list.append(size_bytes) + return ptr_list, element_size_list + + def is_stride_page_aligned(self, page_size_bytes: int = 4096) -> bool: +@@ -630,6 +734,12 @@ + if buf.data_ptr() % page_size_bytes != 0: + return False + if conv_stride % page_size_bytes != 0: ++ return False ++ for buffer in self.sibling_buffers: ++ if ( ++ buffer.data_ptr() % page_size_bytes != 0 ++ or self._item_size_per_index(buffer) % page_size_bytes != 0 ++ ): + return False + return True + +--- a/python/sglang/srt/mem_cache/memory_pool.py ++++ b/python/sglang/srt/mem_cache/memory_pool.py +@@ -1478,7 +1478,9 @@ + + def short_conv_layer_cache(self, layer_id: int) -> torch.Tensor: + if self.layer_transfer_counter is not None: +- self.layer_transfer_counter.wait_until(layer_id - self.start_layer) ++ # Companion state is restored with the first local Mamba layer. ++ ready_layer = max(layer_id, min(self.mamba_map)) ++ self.layer_transfer_counter.wait_until(ready_layer - self.start_layer) + return self.short_conv_pool.layer_cache(layer_id) + + def short_conv_layer_intermediate_cache( +@@ -1490,6 +1492,11 @@ + return self.get_mamba_indices(req_indices) + + def get_ngram_context(self, ngram_indices: torch.Tensor) -> torch.Tensor: ++ if self.layer_transfer_counter is not None: ++ # PLE prepares token history before the model's first layer runs. ++ self.layer_transfer_counter.wait_until( ++ min(self.mamba_map) - self.start_layer ++ ) + return self.ngram_pool.get_context(ngram_indices) + + def set_ngram_context( +--- a/python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py ++++ b/python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py +@@ -31,7 +31,11 @@ + PoolTransferResult, + ) + from sglang.srt.mem_cache.l2_transfer import L2Transfer +-from sglang.srt.mem_cache.memory_pool_host import HostPoolGroup, PoolEntry ++from sglang.srt.mem_cache.memory_pool_host import ( ++ HostPoolGroup, ++ MambaPoolHost, ++ PoolEntry, ++) + from sglang.srt.mem_cache.pool_host.mha import MHATokenToKVPoolHost + + if TYPE_CHECKING: +@@ -159,6 +163,8 @@ + storage_backend_extra_config: Optional[dict] = None, + host_pools: Optional[list[PoolEntry]] = None, + ): ++ for entry in [*getattr(self.mem_pool_host, "entries", ()), *(host_pools or ())]: ++ self._check_storage_pool(entry.host_pool) + super().attach_storage_backend( + storage_backend=storage_backend, + prefetch_threshold=prefetch_threshold, +@@ -169,9 +175,21 @@ + for entry in host_pools or []: + self.storage_backend.register_mem_host_pool_v2(entry.host_pool, entry.name) + ++ @staticmethod ++ def _check_storage_pool(host_pool): ++ if isinstance(host_pool, MambaPoolHost) and getattr( ++ host_pool, "sibling_buffers", () ++ ): ++ raise NotImplementedError( ++ "HiCache with PLE companion state supports RAM only; " ++ "storage backends do not preserve its component format." ++ ) ++ + def register_host_pool_entry(self, entry: PoolEntry) -> None: + if not isinstance(self.mem_pool_host, HostPoolGroup): + raise TypeError("Dynamic HiCache sidecars require HostPoolGroup.") ++ if self.enable_storage: ++ self._check_storage_pool(entry.host_pool) + self.mem_pool_host.add_entry(entry) + if not entry.is_primary_index_anchor: + self.extra_host_mem_release_queues.setdefault(entry.name, Queue()) diff --git a/patches/0021-hicache-file-integrity.patch b/patches/0021-hicache-file-integrity.patch new file mode 100644 index 0000000..14141bf --- /dev/null +++ b/patches/0021-hicache-file-integrity.patch @@ -0,0 +1,67 @@ +--- a/python/sglang/srt/mem_cache/hicache_storage.py ++++ b/python/sglang/srt/mem_cache/hicache_storage.py +@@ -478,10 +478,13 @@ + if self.metadata_cache is not None: + self.metadata_cache.add(suffixed) + return target_location +- except FileNotFoundError: ++ except OSError as error: + if self.metadata_cache is not None: + self.metadata_cache.remove(suffixed) +- logger.warning(f"Failed to fetch {key} from HiCacheFile storage.") ++ # A broken cache page must not terminate the prefetch worker. ++ logger.warning( ++ "Failed to fetch %s from HiCacheFile storage: %s", key, error ++ ) + return None + + def batch_get( +--- a/python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py ++++ b/python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py +@@ -24,6 +24,7 @@ + StorageOperation as BaseStorageOperation, + ) + from sglang.srt.mem_cache.hicache_storage import ( ++ HiCacheFile, + HiCacheStorageExtraInfo, + PoolHitPolicy, + PoolName, +@@ -164,7 +165,7 @@ + host_pools: Optional[list[PoolEntry]] = None, + ): + for entry in [*getattr(self.mem_pool_host, "entries", ()), *(host_pools or ())]: +- self._check_storage_pool(entry.host_pool) ++ self._check_storage_pool(entry.host_pool, storage_backend) + super().attach_storage_backend( + storage_backend=storage_backend, + prefetch_threshold=prefetch_threshold, +@@ -176,20 +177,23 @@ + self.storage_backend.register_mem_host_pool_v2(entry.host_pool, entry.name) + + @staticmethod +- def _check_storage_pool(host_pool): +- if isinstance(host_pool, MambaPoolHost) and getattr( +- host_pool, "sibling_buffers", () ++ def _check_storage_pool(host_pool, storage_backend=None): ++ if ( ++ isinstance(host_pool, MambaPoolHost) ++ and getattr(host_pool, "sibling_buffers", ()) ++ and storage_backend != "file" ++ and not isinstance(storage_backend, HiCacheFile) + ): + raise NotImplementedError( +- "HiCache with PLE companion state supports RAM only; " +- "storage backends do not preserve its component format." ++ "HiCache with PLE companion state supports RAM and file storage only; " ++ "other storage backends are not qualified for this checkpoint format." + ) + + def register_host_pool_entry(self, entry: PoolEntry) -> None: + if not isinstance(self.mem_pool_host, HostPoolGroup): + raise TypeError("Dynamic HiCache sidecars require HostPoolGroup.") + if self.enable_storage: +- self._check_storage_pool(entry.host_pool) ++ self._check_storage_pool(entry.host_pool, self.storage_backend) + self.mem_pool_host.add_entry(entry) + if not entry.is_primary_index_anchor: + self.extra_host_mem_release_queues.setdefault(entry.name, Queue()) diff --git a/patches/0022-hicache-qsa-sidecar.patch b/patches/0022-hicache-qsa-sidecar.patch new file mode 100644 index 0000000..cd387c3 --- /dev/null +++ b/patches/0022-hicache-qsa-sidecar.patch @@ -0,0 +1,228 @@ +--- a/python/sglang/srt/mem_cache/hicache_storage.py ++++ b/python/sglang/srt/mem_cache/hicache_storage.py +@@ -62,6 +62,7 @@ + MAMBA = "mamba" + SWA = "swa" + INDEXER = "indexer" ++ QSA_INDEXER = "qsa_indexer" + # TODO(hzh0425): Current DeepSeek V4 pool naming is verbose; will be normalized to + # 'COMPRESSED_KV / COMPRESSED_INDEXER / COMPRESSED_STATE' in the next PR. + DEEPSEEK_V4_C4 = "deepseek_v4_c4" +--- a/python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py ++++ b/python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py +@@ -687,6 +687,7 @@ + model_name: Optional[str] = None, + storage_backend_extra_config: Optional[dict] = None, + enable_storage_metrics: bool = False, ++ qsa_device_pools: tuple[Any, ...] = (), + ) -> tuple[HostPoolGroup, HybridCacheController]: + transfer_layer_num = len(full_layer_mapping | mamba_layer_mapping) + mamba_allocator = params.req_to_token_pool.mamba_allocator +@@ -698,6 +699,16 @@ + kv_host_size, mamba_host_size = _split_hicache_size( + server_args.hicache_size, (kv_pool, mamba_pool) + ) ++ if qsa_device_pools: ++ from sglang.srt.mem_cache.qsa_pool_host import qsa_index_bytes_per_token ++ ++ # The index shares KV slots and must fit inside the fixed KV budget. ++ kv_bytes = sum( ++ sum(pool.get_kv_size_bytes()) / (pool.size + pool.page_size) ++ for pool in (kv_pool, *mtp_draft_device_pools) ++ ) ++ index_bytes = qsa_index_bytes_per_token(qsa_device_pools, params.page_size) ++ kv_host_size *= kv_bytes / (kv_bytes + index_bytes) + kv_host_pool = build_kv_host_pool( + kv_pool=kv_pool, + page_size=params.page_size, +@@ -741,6 +752,25 @@ + device_free_fn=mamba_allocator.free, + ), + ] ++ if qsa_device_pools: ++ from sglang.srt.mem_cache.qsa_pool_host import QSAPagedHostPool ++ ++ index_host_pool = QSAPagedHostPool( ++ qsa_device_pools, ++ num_host_tokens=kv_host_pool.size, ++ page_size=params.page_size, ++ layout=server_args.hicache_mem_layout, ++ allocator_type=_get_allocator_type(server_args), ++ ) ++ entries.append( ++ build_pool_entry( ++ name=PoolName.QSA_INDEXER, ++ host_pool=index_host_pool, ++ device_pool=qsa_device_pools[0], ++ layer_mapping=full_layer_mapping, ++ transfer_layer_num=transfer_layer_num + len(mtp_draft_device_pools), ++ ) ++ ) + host_pool_group = HostPoolGroup(entries) + cache_controller = HybridCacheController( + params.token_to_kv_pool_allocator, +@@ -1279,9 +1309,22 @@ + enable_storage_metrics=False, + ): + from sglang.srt.mem_cache.base_prefix_cache import EvictParams ++ from sglang.srt.mem_cache.qsa_kv_pool import QSATokenToKVPool + + full_layer_mapping = dict(kvcache.full_attention_layer_id_mapping) + mamba_layer_mapping = dict(params.req_to_token_pool.mamba_map) ++ ++ qsa_pools = () ++ if isinstance(kvcache, QSATokenToKVPool): ++ qsa_pools = (kvcache, *params.mtp_draft_device_pools) ++ if any(not isinstance(pool, QSATokenToKVPool) for pool in qsa_pools): ++ raise ValueError("QSA HiCache requires compressed QSA draft pools") ++ if any( ++ len(pool.qsa_compressed_k_buffer_pool) != pool.full_kv_pool.layer_num ++ or pool.page_size != params.page_size ++ for pool in qsa_pools ++ ) or any(pool.full_kv_pool.layer_num != 1 for pool in qsa_pools[1:]): ++ raise ValueError("QSA HiCache target/draft index layers must match KV") + host_pool_group, cache_controller = build_hybrid_mamba_stack( + params=params, + server_args=server_args, +@@ -1298,6 +1341,7 @@ + model_name=model_name, + storage_backend_extra_config=storage_backend_extra_config, + enable_storage_metrics=enable_storage_metrics, ++ qsa_device_pools=qsa_pools, + ) + return StackBuildResult( + host_pool_group=host_pool_group, +@@ -1306,9 +1350,14 @@ + ComponentType.FULL: host_pool_group.get_pool(PoolName.KV), + ComponentType.MAMBA: host_pool_group.get_pool(PoolName.MAMBA), + }, ++ sidecars=( ++ [SidecarPoolSpec(PoolName.QSA_INDEXER, indices_from_pool=PoolName.KV)] ++ if qsa_pools ++ else [] ++ ), + register_req_to_token_counter=True, + transfer_layer_num=len(full_layer_mapping | mamba_layer_mapping), +- pools_desc="KV + MAMBA", ++ pools_desc="KV + MAMBA + QSA_INDEXER" if qsa_pools else "KV + MAMBA", + ) + + +--- a/python/sglang/srt/mem_cache/qsa_kv_pool.py ++++ b/python/sglang/srt/mem_cache/qsa_kv_pool.py +@@ -209,6 +209,7 @@ + return self.qsa_rope_position_buffer[loc.long()] + + def get_qsa_compressed_k_buffer(self, layer_id: int) -> torch.Tensor: ++ self._wait_for_layer(layer_id) + return self.qsa_compressed_k_buffer_pool[ + self._transfer_full_attention_id(layer_id) + ] +--- a/python/sglang/srt/mem_cache/qsa_pool_host.py ++++ b/python/sglang/srt/mem_cache/qsa_pool_host.py +@@ -0,0 +1,105 @@ ++"""Page-aligned HiCache storage for compressed QSA index keys.""" ++ ++from __future__ import annotations ++ ++import torch ++ ++from sglang.srt.mem_cache.memory_pool_host import DeepSeekV4PagedHostPool ++ ++ ++def qsa_index_bytes_per_token(device_pools, page_size: int) -> int: ++ total = 0 ++ for pool in device_pools: ++ ratio = pool.qsa_compress_ratio ++ if ratio <= 0 or page_size <= 1 or page_size % ratio: ++ raise ValueError( ++ "QSA HiCache requires complete compression groups per page" ++ ) ++ buffers = pool.qsa_compressed_k_buffer_pool ++ if not buffers: ++ raise ValueError("QSA HiCache requires compressed index buffers") ++ for buffer in buffers: ++ if buffer.dtype != torch.bfloat16 or buffer.ndim != 3: ++ raise ValueError("QSA HiCache requires BF16 [slot, head, dim] indices") ++ slot_bytes = buffer[0].numel() * buffer.element_size() ++ if slot_bytes % ratio: ++ raise ValueError("QSA compressed index byte size must divide the ratio") ++ total += slot_bytes // ratio ++ return total ++ ++ ++class QSAPagedHostPool(DeepSeekV4PagedHostPool): ++ """Mirror target and MTP indices using the full KV page address space.""" ++ ++ def __init__( ++ self, ++ device_pools, ++ num_host_tokens: int, ++ page_size: int, ++ layout: str, ++ *, ++ allocator_type: str = "default", ++ pin_memory: bool = True, ++ ): ++ device_pools = tuple(device_pools) ++ if ( ++ not device_pools ++ or page_size <= 1 ++ or num_host_tokens <= 0 ++ or num_host_tokens % page_size ++ ): ++ raise ValueError("QSA HiCache requires pools and a page-aligned host size") ++ if layout not in ("layer_first", "page_first", "page_first_direct"): ++ raise ValueError(f"Unsupported QSA HiCache layout: {layout}") ++ bytes_per_token = qsa_index_bytes_per_token(device_pools, page_size) ++ buffers = [] ++ item_bytes = None ++ index_shape = None ++ for pool in device_pools: ++ ratio = pool.qsa_compress_ratio ++ for buffer in pool.qsa_compressed_k_buffer_pool: ++ shape = (ratio, *buffer.shape[1:]) ++ if index_shape is not None and shape != index_shape: ++ raise ValueError("Target and draft QSA index shapes must match") ++ index_shape = shape ++ page_bytes = ( ++ page_size // ratio * buffer[0].numel() * buffer.element_size() ++ ) ++ if item_bytes is not None and page_bytes != item_bytes: ++ raise ValueError( ++ "Target and draft QSA index page shapes must match" ++ ) ++ if ( ++ not buffer.is_contiguous() ++ or buffer.numel() * buffer.element_size() % page_bytes ++ ): ++ raise ValueError( ++ "QSA index buffers must contain contiguous complete pages" ++ ) ++ item_bytes = page_bytes ++ # The reused transport copies byte rows, independent of index dtype. ++ buffers.append(buffer.view(torch.uint8).reshape(-1, page_bytes)) ++ super().__init__( ++ pool_name="qsa_indexer", ++ device_buffers=buffers, ++ item_bytes=item_bytes, ++ num_host_pages=num_host_tokens // page_size, ++ slot_page_size=page_size, ++ layout=layout, ++ allocator_type=allocator_type, ++ pin_memory=pin_memory, ++ ) ++ self.size_per_token = bytes_per_token ++ ++ def get_size_per_token(self): ++ return self.layer_num * self.item_bytes // self.slot_page_size ++ ++ def get_ksize_per_token(self): ++ return self.get_size_per_token() ++ ++ def _has_transfer_indices(self, host_indices, device_indices): ++ present = super()._has_transfer_indices(host_indices, device_indices) ++ if present and host_indices.numel() % self.slot_page_size: ++ # Partial groups would need ring state; restored prefixes end on pages. ++ raise ValueError("QSA HiCache transfers must contain complete KV pages") ++ return present diff --git a/patches/0023-qsa-sparse-gather-memory-safety.patch b/patches/0023-qsa-sparse-gather-memory-safety.patch new file mode 100644 index 0000000..8c4fa56 --- /dev/null +++ b/patches/0023-qsa-sparse-gather-memory-safety.patch @@ -0,0 +1,146 @@ +--- a/python/sglang/srt/layers/attention/qsa/sparse_attn.py ++++ b/python/sglang/srt/layers/attention/qsa/sparse_attn.py +@@ -382,8 +382,10 @@ + dim: tl.constexpr, + req_stride: tl.constexpr, + idx_stride: tl.constexpr, ++ pad_cols, + BLOCK_TOPK: tl.constexpr, + BLOCK_D: tl.constexpr, ++ ZERO_FILL: tl.constexpr, + ): + batch, head, block = tl.program_id(0), tl.program_id(1), tl.program_id(2) + cols = block * BLOCK_TOPK + tl.arange(0, BLOCK_TOPK) +@@ -399,11 +401,39 @@ + mask=valid, + other=0, + ) +- src = slots[:, None] * heads * dim + head * dim + dims[None, :] +- dst = (pack_start + cols)[:, None] * heads * dim + head * dim + dims[None, :] +- mask = valid[:, None] & (dims[None, :] < dim) +- tl.store(out_k + dst, tl.load(k + src, mask=mask, other=0.0), mask=mask) +- tl.store(out_v + dst, tl.load(v + src, mask=mask, other=0.0), mask=mask) ++ # 64-bit element offsets: slot * heads * dim exceeds int32 once the pool holds ++ # more than 2^31 / (heads * dim) tokens (~4.2M for 2 x 256), which an FP8 pool ++ # on one GPU does reach. ++ src = slots.to(tl.int64)[:, None] * heads * dim + head * dim + dims[None, :] ++ dst = ( ++ (pack_start + cols).to(tl.int64)[:, None] * heads * dim ++ + head * dim ++ + dims[None, :] ++ ) ++ load_mask = valid[:, None] & (dims[None, :] < dim) ++ if ZERO_FILL: ++ # Strided (page-aligned) packing: the paged decode kernel reads whole pages, ++ # so every slot in [valid_count, pad_cols) must hold zeros, never stale bytes. ++ # `valid_count` here is the row's page-aligned stride, not its valid count, so ++ # the store covers the full region while the load stays limited to valid rows. ++ store_mask = (cols < pad_cols)[:, None] & (dims[None, :] < dim) ++ else: ++ store_mask = load_mask ++ # Dequantize while gathering: the scratch is allocated in the query dtype, so an ++ # FP8 pool is read as fp8 and stored as bf16. The QSA backend writes the pool ++ # without per-tensor k/v scales (see set_kv_buffer calls in ++ # qwen_sparse_attn_backend.py), so no scale is applied here either. ++ out_dtype = out_k.dtype.element_ty ++ tl.store( ++ out_k + dst, ++ tl.load(k + src, mask=load_mask, other=0.0).to(out_dtype), ++ mask=store_mask, ++ ) ++ tl.store( ++ out_v + dst, ++ tl.load(v + src, mask=load_mask, other=0.0).to(out_dtype), ++ mask=store_mask, ++ ) + + + def qwen_sparse_valid_counts_triton(seq_lens, indices, counts, batch, topk): +@@ -422,11 +452,40 @@ + + + def qwen_sparse_kv_extraction_compact_triton( +- k, v, req_to_token, req_indices, indices, seq_lens, cu_k, out_k, out_v, batch, topk ++ k, ++ v, ++ req_to_token, ++ req_indices, ++ indices, ++ seq_lens, ++ cu_k, ++ out_k, ++ out_v, ++ batch, ++ topk, ++ zero_fill_cols: int = 0, + ): ++ """Gather the selected K/V rows into ``out_k``/``out_v``. ++ ++ ``zero_fill_cols`` > 0 selects the strided (page-aligned) layout used by the paged ++ decode kernel: row ``b`` owns ``[cu_k[b], cu_k[b] + zero_fill_cols)`` and every slot ++ past its valid rows is zero-filled. Paged kernels read whole pages and multiply the ++ masked probabilities into V, so stale or uninitialized bytes there (NaN/Inf bit ++ patterns) would otherwise leak into the output. ``0`` keeps the compact layout for ++ the varlen fallback, whose rows are packed back-to-back. ++ ++ ``out_k``/``out_v`` may use a wider dtype than the pool (bf16 scratch for an FP8 ++ pool); rows are converted while gathering. ++ ++ Both layouts assume the valid entries of each ``indices`` row are contiguous at ++ the front (``expand_qsa_block_indices`` sorts them that way): ``valid_count`` is a ++ count, not a mask, so a ``-1`` in the middle of a row would shift the packing. ++ """ + _, heads, dim = k.shape + block_topk = 16 +- _compact_kv[(batch, heads, triton.cdiv(topk, block_topk))]( ++ zero_fill = zero_fill_cols > 0 ++ num_cols = zero_fill_cols if zero_fill else topk ++ _compact_kv[(batch, heads, triton.cdiv(num_cols, block_topk))]( + k, + v, + req_to_token, +@@ -441,8 +500,10 @@ + dim, + req_to_token.stride(0), + indices.stride(0), ++ num_cols, + BLOCK_TOPK=block_topk, + BLOCK_D=triton.next_power_of_2(dim), ++ ZERO_FILL=zero_fill, + num_warps=8, + ) + +--- a/python/sglang/srt/layers/attention/qwen_sparse_attn_backend.py ++++ b/python/sglang/srt/layers/attention/qwen_sparse_attn_backend.py +@@ -1600,11 +1600,13 @@ + capacity_rows = ( + self._cuda_graph_max_tokens if metadata.is_cuda_graph else batch + ) ++ # Gather into the query dtype: an FP8 pool is dequantized on the way in, so the ++ # paged kernel always runs the bf16 q + bf16 KV path. + packed_k, packed_v = self._get_fa2_scratch( + max(capacity_rows, batch) * stride, + k_buffer.shape[1], + k_buffer.shape[2], +- k_buffer.dtype, ++ q.dtype, + k_buffer.device, + ) + qwen_sparse_kv_extraction_compact_triton( +@@ -1623,6 +1625,7 @@ + packed_v, + batch, + topk, ++ zero_fill_cols=stride, + ) + num_kv_heads = k_buffer.shape[1] + head_dim = k_buffer.shape[2] +@@ -1733,7 +1736,7 @@ + scratch_capacity, + k_buffer.shape[1], + k_buffer.shape[2], +- k_buffer.dtype, ++ q.dtype, + k_buffer.device, + ) + qwen_sparse_kv_extraction_compact_triton( diff --git a/patches/0024-router-pdl-bias-order.patch b/patches/0024-router-pdl-bias-order.patch new file mode 100644 index 0000000..732d552 --- /dev/null +++ b/patches/0024-router-pdl-bias-order.patch @@ -0,0 +1,34 @@ +--- a/python/sglang/kernels/ops/moe/moe_fused_gate.py ++++ b/python/sglang/kernels/ops/moe/moe_fused_gate.py +@@ -126,13 +126,13 @@ + mask_m = offs_m < M + mask_n = offs_n < N + +- # prefetch bias before PDL wait ++ # Bias can come from a preceding cast or fill; wait before either input load. ++ if USE_PDL: ++ tl.extra.cuda.gdc_wait() ++ + bias = tl.load(bias_ptr + offs_n, mask=mask_n, other=0.0).to( + tl.float32 + ) # [BLOCK_N] +- +- if USE_PDL: +- tl.extra.cuda.gdc_wait() + + row_ptr = scores_ptr + offs_m[:, None] * stride_sm + offs_n[None, :] * stride_sn + mask2d = mask_m[:, None] & mask_n[None, :] +--- a/python/sglang/kernels/jit/csrc/moe/route_radix.cuh ++++ b/python/sglang/kernels/jit/csrc/moe/route_radix.cuh +@@ -142,9 +142,9 @@ + // radix math below is fp32 either way — only the load width differs. + AlignedVector, kVecSize / 2> scores_vec; + +- // prefetch bias (frozen weight) before the PDL wait ++ // Bias may be produced by a preceding cast or fill kernel. ++ PDLWaitPrimary(); + bias_vec.load(params.bias, tx); +- PDLWaitPrimary(); + scores_vec.load(scores, tx); + + #pragma unroll diff --git a/patches/0025-hicache-load-order.patch b/patches/0025-hicache-load-order.patch new file mode 100644 index 0000000..d3e3c64 --- /dev/null +++ b/patches/0025-hicache-load-order.patch @@ -0,0 +1,65 @@ +--- a/python/sglang/srt/managers/cache_controller.py ++++ b/python/sglang/srt/managers/cache_controller.py +@@ -316,6 +316,8 @@ + self.load_queue: List[CacheOperation] = [] + self.write_queue: List[CacheOperation] = [] + self.ack_load_queue: List[HiCacheAck] = [] ++ # Load-back must follow in-flight forwards that may still write reclaimed pages. ++ self.load_fence_stream = None + self.ack_write_queue: List[HiCacheAck] = [] + + self.l2_transfer_engine = L2TransferEngine(io_backend) +@@ -845,6 +847,11 @@ + producer_event = self.layer_done_counter.events[producer_id] + producer_event.start_event.record() + ++ if self.load_fence_stream is not None: ++ self.l2_transfer_engine.host_to_device_stream.wait_stream( ++ self.load_fence_stream ++ ) ++ + completion = self.l2_transfer_engine.submit_host_to_device( + self._l2_load_transfers(host_indices, device_indices, pool_transfers), + start_event=producer_event.start_event, +--- a/python/sglang/srt/managers/scheduler.py ++++ b/python/sglang/srt/managers/scheduler.py +@@ -554,6 +554,12 @@ + self.token_to_kv_pool_allocator = result.token_to_kv_pool_allocator + self.disable_radix_cache = result.disable_radix_cache + self.tree_cache = result.tree_cache ++ if self.enable_hierarchical_cache: ++ cache_controller = self.tree_cache.cache_controller ++ if cache_controller is not None: ++ cache_controller.load_fence_stream = ( ++ self.tp_worker.model_runner.forward_stream ++ ) + self.emit_metrics_constants() + self.maybe_init_hccl_dp_prewarm() + +--- a/python/sglang/srt/mem_cache/memory_pool.py ++++ b/python/sglang/srt/mem_cache/memory_pool.py +@@ -1451,6 +1451,13 @@ + def get_mamba_indices(self, req_indices: torch.Tensor) -> torch.Tensor: + return self.req_index_to_mamba_index_mapping[req_indices] + ++ def wait_for_hicache_load_complete(self) -> None: ++ """Order whole-slot consumers after an active layerwise H->D load.""" ++ if self.layer_transfer_counter is not None: ++ self.layer_transfer_counter.wait_until( ++ self.layer_transfer_counter.num_layers - 1 ++ ) ++ + def translate_mamba_indices(self, mamba_indices: torch.Tensor) -> torch.Tensor: + """Virtual->physical mamba-slot translate. Identity for a static pool + (slots are physical); UnifiedHybridReqToTokenPool overrides it for the +--- a/python/sglang/srt/model_executor/model_runner.py ++++ b/python/sglang/srt/model_executor/model_runner.py +@@ -1651,6 +1651,8 @@ + forward_batch.mamba_cow_src_indices is not None + and len(forward_batch.mamba_cow_src_indices) > 0 + ): ++ # Whole-slot COW must wait for every restored layer. ++ pool.wait_for_hicache_load_complete() + if pool.mamba_ckpt_pool is not None: + # int8 checkpoints: dequantize src int8 ckpt slot into the active bf16 dst. + pool.mamba_ckpt_pool.load_to_active( diff --git a/patches/0026-qsa-short-extend-bounds.patch b/patches/0026-qsa-short-extend-bounds.patch new file mode 100644 index 0000000..257a012 --- /dev/null +++ b/patches/0026-qsa-short-extend-bounds.patch @@ -0,0 +1,10 @@ +--- a/python/sglang/srt/layers/attention/qsa/qsa_indexer.py ++++ b/python/sglang/srt/layers/attention/qsa/qsa_indexer.py +@@ -332,6 +332,7 @@ + self.compress_ratio, device=member_rows.device, dtype=torch.long + ) + source_keys = token_k ++ group_locs = group_locs.clamp_max(source_keys.shape[0] - 1) + source_rope = metadata.extend_rope_matrix + if source_rope is None: + source_rope = build_rope_position_matrix( diff --git a/patches/series.hicache-wip b/patches/series.hicache-wip new file mode 100644 index 0000000..a057a2d --- /dev/null +++ b/patches/series.hicache-wip @@ -0,0 +1,7 @@ +0020-hicache-ple-state.patch +0021-hicache-file-integrity.patch +0022-hicache-qsa-sidecar.patch +0023-qsa-sparse-gather-memory-safety.patch +0024-router-pdl-bias-order.patch +0025-hicache-load-order.patch +0026-qsa-short-extend-bounds.patch diff --git a/provenance/hicache-wip.json b/provenance/hicache-wip.json new file mode 100644 index 0000000..5ca6d3f --- /dev/null +++ b/provenance/hicache-wip.json @@ -0,0 +1,219 @@ +{ + "status": "DRAFT / WIP: opt-in profile; configuration-specific qualification is recorded in docs/hicache-wip.md", + "base_git_commit": "b52479451e88b0c54930f285c4406f789a11c1cd", + "base_image": "docker.io/kanadaj/sglang-qwen38fn-sm120-turbo@sha256:f2859d1ccf824a5295088cf578eba89b0f3eeefff6ae7679c3f5d64af0689458", + "base_inventory": "provenance/invalid-token-failure-runtime-files.json", + "base_inventory_sha256": "f7293cc004161bcad39bc3772939fd868f8fc9d6f09d2cdb7b7ffd5a23333e1d", + "source_files_before": 4392, + "source_files_after": 4393, + "patches": [ + { + "file": "0020-hicache-ple-state.patch", + "sha256": "4864c6bdec355a097e12764da72e5842369ef011af19948054b00e4e9e2c364c", + "files": { + "python/sglang/srt/mem_cache/ple_state_pool.py": { + "before": "a99b71c6e3941c060e4126c212fa9a941545d4d6614af7131681dc9b696515e2", + "after": "3364674a48d7db3a1f36690e420d42f888c50d12bb15d9b113d437b503513515" + }, + "python/sglang/srt/mem_cache/memory_pool_host.py": { + "before": "fd2b196b9bf39ae93f96afce6748ae2571c26308dbc150da452dd055f3b03125", + "after": "8a224a8434d7879c134100c1edb205a5dabb12d2d3310c68b3a720b3391e4634" + }, + "python/sglang/srt/mem_cache/memory_pool.py": { + "before": "ebcb705f37b6f78cfb730ea43c767538a4f63b719a14336f5bbac71d20ec3f7c", + "after": "b5cf490ef31e5ade34b24e6e5641b0db67f411324e065458a85c18f2f3feb46b" + }, + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py": { + "before": "bc06826aeae69fa9702469d6a8606fba6efafe66433e402f9a8fd488dfdb1096", + "after": "0c919d2416d86f30b60ff2bcc2621823c8d0021cbac6c5d3ab7dd13162a51003" + } + } + }, + { + "file": "0021-hicache-file-integrity.patch", + "sha256": "569a2cabf483ad6ecbc585ecd7791d3718b75fba80f64875e802b4b378ae5715", + "files": { + "python/sglang/srt/mem_cache/hicache_storage.py": { + "before": "de92d6c7228f3c93d889e1c054f867235055f74663b2808c5456e53ff040be86", + "after": "fd7b610e978fb84b3dc69ff47577be27796770b18c673bf0c60824521d43eea9" + }, + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py": { + "before": "0c919d2416d86f30b60ff2bcc2621823c8d0021cbac6c5d3ab7dd13162a51003", + "after": "c6ddda7a329f84b99e31629c415eaca82360c6c95b83469ac2f482cca17bd5cb" + } + } + }, + { + "file": "0022-hicache-qsa-sidecar.patch", + "sha256": "a0972e94c8b31cec72dd249947fd1e9dc77adc7dab655db062be373064912db2", + "files": { + "python/sglang/srt/mem_cache/hicache_storage.py": { + "before": "fd7b610e978fb84b3dc69ff47577be27796770b18c673bf0c60824521d43eea9", + "after": "09f53cb53e4359d369a072470c54bc2fcc1141ce649c05d98ffcef50f92be21d" + }, + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py": { + "before": "a348509b43c64ee979d838dfd7c6ee3350b6617edb608ccb0f593f7af86e7140", + "after": "c2fcd1f95bc5a7754ca22111748c76918729a593b784e04827520238174eb5d1" + }, + "python/sglang/srt/mem_cache/qsa_kv_pool.py": { + "before": "85e7687daee0af9506b4c0e8840ec5b4c870be6f6930a3c210cbd31bf1f84412", + "after": "9a07709e8c6b05858d13f9418984e27916cfcb2c21cd2619c25f0db361035e29" + }, + "python/sglang/srt/mem_cache/qsa_pool_host.py": { + "before": null, + "after": "b32eaab324d52ecef8e66e28dd2d270a8543b2a30cf7ab2145f0ac8d1fb38b07" + } + } + }, + { + "file": "0023-qsa-sparse-gather-memory-safety.patch", + "sha256": "ea71ab2106c534d4fbe954c59d956c31fe862d74490e745769d51410801c51f8", + "upstream_pr": "https://github.com/sgl-project/sglang/pull/38851", + "files": { + "python/sglang/srt/layers/attention/qsa/sparse_attn.py": { + "before": "c7052125569f3c0fa9a0a4d62d2f57433faec636ad82a1d99c3b39e267b7904c", + "after": "6773d7fe83d42878efa9d65a49260b84fd13336f6192828cb093cba44ad5c930" + }, + "python/sglang/srt/layers/attention/qwen_sparse_attn_backend.py": { + "before": "12c4d4d34774e5592c3a3ba3956d19a280606007e0161598e4e108bb6caa479b", + "after": "99e719d0c90be7cd43738cf06fc1a610b0d6cdd6bc42c4b235091962366885f5" + } + } + }, + { + "file": "0024-router-pdl-bias-order.patch", + "sha256": "148026a93c1eb17629f17fe82ff854b3e0d7da156b7664672f68813c55a0aedf", + "upstream_pr": "https://github.com/sgl-project/sglang/pull/38290", + "adaptation": "Keep existing bias API; move PDL waits before dependent bias loads in both kernels.", + "files": { + "python/sglang/kernels/ops/moe/moe_fused_gate.py": { + "before": "945eae03580d034420a20f2c38adf8d9ae8fed4a13de364d8c235466ffc513b0", + "after": "366c124db146378a68468deafb18a24d9f02ef64effaf59425915964c45ff71c" + }, + "python/sglang/kernels/jit/csrc/moe/route_radix.cuh": { + "before": "f93a2c03c15bf98203b0412b96aee97422020e4c3d22b55416afb99dd42e0c29", + "after": "82191277f1f8104eedbf6c187c62c1d460d700fed6981109332e4dbd07c5a047" + } + } + }, + { + "file": "0025-hicache-load-order.patch", + "sha256": "cf73bbf2332f9c691a1a71d44134ad5eab2d50804ed91dc2e15cecb7d83bd385", + "upstream_prs": [ + "https://github.com/sgl-project/sglang/pull/36738", + "https://github.com/sgl-project/sglang/pull/36743" + ], + "files": { + "python/sglang/srt/managers/cache_controller.py": { + "before": "3f323c0b08acb8b1de6f3ff8c08f1ed34d508afd186ae61d370f4e1087d89974", + "after": "005ee937a4d75bb379adb3b78c874b37ccc00fe0e201f34dba74b6249301434a" + }, + "python/sglang/srt/managers/scheduler.py": { + "before": "8bc11f8bd2ddef96bf32adc1fe5b52c3929e23538cde1047914eb336f3994595", + "after": "1f7d64f0268595d8d6e03dd3233f98c523899f4e63876bef8f4683b21ddb4a19" + }, + "python/sglang/srt/mem_cache/memory_pool.py": { + "before": "b5cf490ef31e5ade34b24e6e5641b0db67f411324e065458a85c18f2f3feb46b", + "after": "ca6dfe21d59623c5be325462cf877f340268c66dbd7ab63a4bfc451d9b1da795" + }, + "python/sglang/srt/model_executor/model_runner.py": { + "before": "d93a427b8ba77128ba0752adb990a1d69a489e3249c189ee9bca67583ace2069", + "after": "b5d03401cad03f84bc30ca21d67c9ff1b471f251e9e745220b9348a53414adaf" + } + } + }, + { + "file": "0026-qsa-short-extend-bounds.patch", + "sha256": "aa965304ad4b18ad46fa0eccf9b32675ce77917500cdc296dfec1f5a3ea9a050", + "upstream_pr": "https://github.com/sgl-project/sglang/pull/39446", + "files": { + "python/sglang/srt/layers/attention/qsa/qsa_indexer.py": { + "before": "bb57ce1e9abc4fbfcba2c9aaaf125b9e625983966497df57165b6d4c6461afe2", + "after": "72c5d471a67729446ec9b1c0d810bc87bc85149c381c213adfb4119eddde9a7c" + } + } + } + ], + "files": { + "python/sglang/srt/mem_cache/hicache_storage.py": { + "before": "de92d6c7228f3c93d889e1c054f867235055f74663b2808c5456e53ff040be86", + "after": "09f53cb53e4359d369a072470c54bc2fcc1141ce649c05d98ffcef50f92be21d" + }, + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_cache_controller.py": { + "before": "bc06826aeae69fa9702469d6a8606fba6efafe66433e402f9a8fd488dfdb1096", + "after": "c6ddda7a329f84b99e31629c415eaca82360c6c95b83469ac2f482cca17bd5cb" + }, + "python/sglang/srt/mem_cache/hybrid_cache/hybrid_pool_assembler.py": { + "before": "a348509b43c64ee979d838dfd7c6ee3350b6617edb608ccb0f593f7af86e7140", + "after": "c2fcd1f95bc5a7754ca22111748c76918729a593b784e04827520238174eb5d1" + }, + "python/sglang/srt/mem_cache/memory_pool.py": { + "before": "ebcb705f37b6f78cfb730ea43c767538a4f63b719a14336f5bbac71d20ec3f7c", + "after": "ca6dfe21d59623c5be325462cf877f340268c66dbd7ab63a4bfc451d9b1da795" + }, + "python/sglang/srt/mem_cache/memory_pool_host.py": { + "before": "fd2b196b9bf39ae93f96afce6748ae2571c26308dbc150da452dd055f3b03125", + "after": "8a224a8434d7879c134100c1edb205a5dabb12d2d3310c68b3a720b3391e4634" + }, + "python/sglang/srt/mem_cache/ple_state_pool.py": { + "before": "a99b71c6e3941c060e4126c212fa9a941545d4d6614af7131681dc9b696515e2", + "after": "3364674a48d7db3a1f36690e420d42f888c50d12bb15d9b113d437b503513515" + }, + "python/sglang/srt/mem_cache/qsa_kv_pool.py": { + "before": "85e7687daee0af9506b4c0e8840ec5b4c870be6f6930a3c210cbd31bf1f84412", + "after": "9a07709e8c6b05858d13f9418984e27916cfcb2c21cd2619c25f0db361035e29" + }, + "python/sglang/srt/mem_cache/qsa_pool_host.py": { + "before": null, + "after": "b32eaab324d52ecef8e66e28dd2d270a8543b2a30cf7ab2145f0ac8d1fb38b07" + }, + "python/sglang/srt/layers/attention/qsa/sparse_attn.py": { + "before": "c7052125569f3c0fa9a0a4d62d2f57433faec636ad82a1d99c3b39e267b7904c", + "after": "6773d7fe83d42878efa9d65a49260b84fd13336f6192828cb093cba44ad5c930" + }, + "python/sglang/srt/layers/attention/qwen_sparse_attn_backend.py": { + "before": "12c4d4d34774e5592c3a3ba3956d19a280606007e0161598e4e108bb6caa479b", + "after": "99e719d0c90be7cd43738cf06fc1a610b0d6cdd6bc42c4b235091962366885f5" + }, + "python/sglang/kernels/ops/moe/moe_fused_gate.py": { + "before": "945eae03580d034420a20f2c38adf8d9ae8fed4a13de364d8c235466ffc513b0", + "after": "366c124db146378a68468deafb18a24d9f02ef64effaf59425915964c45ff71c" + }, + "python/sglang/kernels/jit/csrc/moe/route_radix.cuh": { + "before": "f93a2c03c15bf98203b0412b96aee97422020e4c3d22b55416afb99dd42e0c29", + "after": "82191277f1f8104eedbf6c187c62c1d460d700fed6981109332e4dbd07c5a047" + }, + "python/sglang/srt/managers/cache_controller.py": { + "before": "3f323c0b08acb8b1de6f3ff8c08f1ed34d508afd186ae61d370f4e1087d89974", + "after": "005ee937a4d75bb379adb3b78c874b37ccc00fe0e201f34dba74b6249301434a" + }, + "python/sglang/srt/managers/scheduler.py": { + "before": "8bc11f8bd2ddef96bf32adc1fe5b52c3929e23538cde1047914eb336f3994595", + "after": "1f7d64f0268595d8d6e03dd3233f98c523899f4e63876bef8f4683b21ddb4a19" + }, + "python/sglang/srt/model_executor/model_runner.py": { + "before": "d93a427b8ba77128ba0752adb990a1d69a489e3249c189ee9bca67583ace2069", + "after": "b5d03401cad03f84bc30ca21d67c9ff1b471f251e9e745220b9348a53414adaf" + }, + "python/sglang/srt/layers/attention/qsa/qsa_indexer.py": { + "before": "bb57ce1e9abc4fbfcba2c9aaaf125b9e625983966497df57165b6d4c6461afe2", + "after": "72c5d471a67729446ec9b1c0d810bc87bc85149c381c213adfb4119eddde9a7c" + } + }, + "result_inventory_sha256": "f0f4eb40679807cb03a7c92c010df00bdeecc1262fb9a83c505b96ed9379a542", + "retained_validation": { + "cpu_unique_tests": "55 passed in the packaged PLE, file, and QSA fixture suite", + "gpu_ple": "24 per-card kernel-transfer cases plus one combined asynchronous target/draft/recurrent checkpoint case passed; 6 direct-copy cases were excluded after matching parent failures", + "gpu_file": "one real GPU to RAM to reconstructed-file checkpoint case passed", + "gpu_qsa": "4 per card: target/draft relocation, two layouts, RAM and reconstructed file storage", + "live_restore": "cold 4/4, storage 4/4, GPU replay 4/4; QSA added 81,788,928 restored bytes (832 bytes/token)" + }, + "known_blockers": [ + "A later ordinary 200-tool catalogue/replay run passed only 32/48 with repeated punctuation.", + "That failing run recorded no new host or storage reads, so the corruption is not attributed solely to restored cache data.", + "Instrumented diagnostics observed NaNs in CUDA-graph draft extension; causation and a safe fix remain unresolved.", + "No production deployment or merge qualification is claimed; HiCache must remain disabled." + ], + "base_profile": "production-cumulative-compat-20260914-v3", + "retained_validation_scope": "Historical pre-rebase evidence; fresh cumulative candidate qualification is required." +} diff --git a/scripts/test_hicache_wip.sh b/scripts/test_hicache_wip.sh new file mode 100755 index 0000000..f29275e --- /dev/null +++ b/scripts/test_hicache_wip.sh @@ -0,0 +1,48 @@ +#!/usr/bin/env bash +set -euo pipefail + +RED='\033[0;31m' +YELLOW='\033[1;33m' +GRAY='\033[0;90m' +NC='\033[0m' + +run() { + printf >&2 "${GRAY}$(pwd) >${NC} " + printf >&2 "${YELLOW}" + printf >&2 "%q " "$@" + printf >&2 "${NC}\n" + + "$@" || { + local exit_code=$? + printf >&2 "${RED}Command failed with exit code %s: %s${NC}\n" "$exit_code" "$1" + return "$exit_code" + } +} + +cd "$(dirname "$0")/.." +PYTHON="${PYTHON:-python3}" + +run "$PYTHON" scripts/verify_hicache_wip.py +run "$PYTHON" -m unittest tests/test_hicache_wip_packaging.py -v + +if [[ -n "${HICACHE_WIP_IMAGE:-}" ]]; then + run docker run --rm --pull never --network none --read-only \ + --user "$(id -u):$(id -g)" \ + --memory 4g --cpus 4 --pids-limit 512 --cap-drop ALL \ + --tmpfs /tmp:rw,noexec,nosuid,size=1g,mode=1777 \ + -e HOME=/tmp/hicache-home \ + -e SGLANG_CACHE_DIR=/tmp/hicache-cache \ + -e PYTHONDONTWRITEBYTECODE=1 \ + -e SGLANG_DEVICE=cpu \ + -e QWEN_HICACHE_TEST_DEVICE=cpu \ + -e PYTHONPATH=/hicache-tests:/sgl-workspace/sglang/python \ + -v "$(pwd)/validation/hicache:/hicache-tests:ro" \ + --entrypoint python3 "$HICACHE_WIP_IMAGE" -c \ + 'from sglang.test.test_utils import maybe_stub_sgl_kernel; maybe_stub_sgl_kernel(); import pytest,sys; sys.exit(pytest.main(sys.argv[1:]))' \ + /hicache-tests/test_hicache_ple_local.py \ + /hicache-tests/test_hicache_file_local.py \ + /hicache-tests/test_hicache_qsa_local.py \ + /hicache-tests/test_hicache_load_order.py \ + /hicache-tests/test_qsa_short_extend.py \ + -q -p no:cacheprovider +fi diff --git a/scripts/verify_hicache_wip.py b/scripts/verify_hicache_wip.py new file mode 100755 index 0000000..ae9f025 --- /dev/null +++ b/scripts/verify_hicache_wip.py @@ -0,0 +1,126 @@ +#!/usr/bin/env python3 +"""Verify the isolated, opt-in HiCache patch profile.""" + +import argparse +import hashlib +import json +from pathlib import Path +import subprocess + + +ROOT = Path(__file__).resolve().parents[1] + + +def digest(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def inventory_hash(inventory: dict[str, str]) -> str: + payload = (json.dumps(dict(sorted(inventory.items())), indent=2) + "\n").encode() + return hashlib.sha256(payload).hexdigest() + + +def base_inventory() -> dict[str, str]: + manifest = json.loads((ROOT / "provenance/hicache-wip.json").read_text()) + inventory_path = ROOT / manifest["base_inventory"] + if digest(inventory_path) != manifest["base_inventory_sha256"]: + raise ValueError("Cumulative parent inventory digest mismatch") + return json.loads(inventory_path.read_text()) + + +def apply_patch(tree: Path, patch: Path) -> None: + subprocess.run(["git", "apply", "--check", str(patch)], cwd=tree, check=True) + subprocess.run(["git", "apply", str(patch)], cwd=tree, check=True) + + +def package_records() -> tuple[dict, dict[str, str]]: + manifest_path = ROOT / "provenance/hicache-wip.json" + manifest = json.loads(manifest_path.read_text()) + base_path = ROOT / manifest["base_inventory"] + if digest(base_path) != manifest["base_inventory_sha256"]: + raise ValueError("Base inventory digest mismatch") + + inventory = base_inventory() + if len(inventory) != manifest["source_files_before"]: + raise ValueError("Base source count mismatch") + + series = (ROOT / "patches/series.hicache-wip").read_text().splitlines() + if series != [row["file"] for row in manifest["patches"]]: + raise ValueError("HiCache patch order differs") + + initial = dict(inventory) + changed_paths: set[str] = set() + for patch_record in manifest["patches"]: + patch = ROOT / "patches" / patch_record["file"] + if digest(patch) != patch_record["sha256"]: + raise ValueError("HiCache patch hash mismatch: " + patch.name) + for name, hashes in patch_record["files"].items(): + if inventory.get(name) != hashes["before"]: + raise ValueError("HiCache patch transition mismatch: " + name) + inventory[name] = hashes["after"] + changed_paths.add(name) + + if changed_paths != set(manifest["files"]): + raise ValueError("HiCache changed-path manifest differs") + for name, hashes in manifest["files"].items(): + if initial.get(name) != hashes["before"] or inventory[name] != hashes["after"]: + raise ValueError("HiCache cumulative file transition mismatch: " + name) + if len(inventory) != manifest["source_files_after"]: + raise ValueError("Result source count mismatch") + if inventory_hash(inventory) != manifest["result_inventory_sha256"]: + raise ValueError("Result inventory digest mismatch") + return manifest, inventory + + +def verify_tree(tree: Path, inventory: dict[str, str]) -> None: + actual = { + str(path.relative_to(tree)) + for path in (tree / "python/sglang").rglob("*") + if path.is_file() and "__pycache__" not in path.parts and path.suffix != ".pyc" + } + if actual != set(inventory): + raise ValueError("Full source inventory differs") + for name, expected in inventory.items(): + if digest(tree / name) != expected: + raise ValueError("Source hash mismatch: " + name) + + +def verify(tree: Path, should_apply: bool) -> int: + manifest, result = package_records() + if should_apply: + verify_tree(tree, base_inventory()) + for patch_record in manifest["patches"]: + apply_patch(tree, ROOT / "patches" / patch_record["file"]) + verify_tree(tree, result) + return len(result) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--tree", type=Path) + parser.add_argument("--apply", action="store_true") + args = parser.parse_args() + if args.apply and args.tree is None: + parser.error("--apply requires --tree") + if args.tree is None: + manifest, _ = package_records() + changed = len(manifest["files"]) + source_files = manifest["source_files_after"] + full_tree = False + else: + source_files = verify(args.tree.resolve(), args.apply) + changed = len(package_records()[0]["files"]) + full_tree = True + print( + json.dumps( + { + "profile": "hicache-wip", + "status": manifest["status"], + "clean_patch_apply": bool(args.tree is not None and args.apply), + "patch_chain_verified": True, + "changed_source_files": changed, + "source_files": source_files, + "full_tree_verified": full_tree, + } + ) + ) diff --git a/tests/test_hicache_wip_packaging.py b/tests/test_hicache_wip_packaging.py new file mode 100644 index 0000000..b1c02b6 --- /dev/null +++ b/tests/test_hicache_wip_packaging.py @@ -0,0 +1,82 @@ +"""Fail-closed checks for the isolated, opt-in HiCache profile.""" + +import importlib.util +from pathlib import Path +import unittest +from unittest.mock import patch + + +ROOT = Path(__file__).resolve().parents[1] +SPEC = importlib.util.spec_from_file_location( + "hicache_wip_verifier", ROOT / "scripts/verify_hicache_wip.py" +) +assert SPEC is not None and SPEC.loader is not None +VERIFIER = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(VERIFIER) + + +class HiCacheWipPackagingTest(unittest.TestCase): + def test_patch_chain_and_result_inventory(self): + manifest, inventory = VERIFIER.package_records() + self.assertEqual(manifest["status"].split(":", 1)[0], "DRAFT / WIP") + self.assertEqual(len(inventory), 4393) + self.assertEqual( + [row["file"] for row in manifest["patches"]], + [ + "0020-hicache-ple-state.patch", + "0021-hicache-file-integrity.patch", + "0022-hicache-qsa-sidecar.patch", + "0023-qsa-sparse-gather-memory-safety.patch", + "0024-router-pdl-bias-order.patch", + "0025-hicache-load-order.patch", + "0026-qsa-short-extend-bounds.patch", + ], + ) + + def test_new_qsa_sidecar_is_the_only_new_source(self): + manifest, _ = VERIFIER.package_records() + added = [name for name, row in manifest["files"].items() if row["before"] is None] + self.assertEqual( + added, ["python/sglang/srt/mem_cache/qsa_pool_host.py"] + ) + + def test_patch_paths_match_the_manifest(self): + manifest, _ = VERIFIER.package_records() + for row in manifest["patches"]: + with self.subTest(patch=row["file"]): + lines = (ROOT / "patches" / row["file"]).read_text().splitlines() + paths = { + line.removeprefix("+++ b/") + for line in lines + if line.startswith("+++ b/") + } + self.assertEqual(paths, set(row["files"])) + + def test_every_patch_fails_closed_on_drift(self): + manifest, _ = VERIFIER.package_records() + original = VERIFIER.digest + for row in manifest["patches"]: + with self.subTest(patch=row["file"]): + target = ROOT / "patches" / row["file"] + + def changed(path, *, target=target): + return "0" * 64 if path == target else original(path) + + with patch.object(VERIFIER, "digest", side_effect=changed): + with self.assertRaisesRegex(ValueError, "patch hash mismatch"): + VERIFIER.package_records() + + def test_default_profiles_do_not_include_hicache_wip(self): + for name in ("series", "series.production", "series.responses-compat"): + series = (ROOT / "patches" / name).read_text() + self.assertNotIn("hicache", series.lower()) + dockerfile = (ROOT / "Dockerfile.hicache-wip").read_text() + self.assertIn("EXPERIMENTAL", dockerfile) + self.assertIn( + "sha256:f2859d1ccf824a5295088cf578eba89b0f3eeefff6ae7679c3f5d64af0689458", + dockerfile, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/validation/hicache/test_hicache_file_gpu_local.py b/validation/hicache/test_hicache_file_gpu_local.py new file mode 100644 index 0000000..c25e3a4 --- /dev/null +++ b/validation/hicache/test_hicache_file_gpu_local.py @@ -0,0 +1,42 @@ +"""Real Qwen-shaped GPU↔RAM↔file checkpoints, including packed MTP and PLE.""" + +import os + +from sglang.srt.mem_cache.hicache_storage import PoolName, PoolTransfer +from test_hicache_file_local import storage +from test_hicache_ple_gpu_local import exercise_async_checkpoint + + +def test_gpu_disk_checkpoint_survives_backend_reconstruction(tmp_path): + rank = int(os.environ.get("QWEN_HICACHE_TP_RANK", "0")) + + def roundtrip(kv_host, state_host, kv_rows, state_rows, epoch): + def reopen(): + backend = storage(tmp_path, rank) + backend.register_mem_host_pool_v2(kv_host, PoolName.KV) + backend.register_mem_host_pool_v2(state_host, PoolName.MAMBA) + return backend + + transfers = [ + PoolTransfer(PoolName.KV, host_indices=kv_rows, keys=[str(epoch)]), + PoolTransfer(PoolName.MAMBA, host_indices=state_rows, keys=[str(epoch)]), + ] + assert reopen().batch_set_v2(transfers) == { + PoolName.KV: [True], + PoolName.MAMBA: [True], + } + kv_host.kv_buffer.zero_() + for tensor in state_host.get_hybrid_pool_buffer(): + tensor.zero_() + backend = reopen() + expected_bytes = (epoch + 1) * ( + 64 * kv_host.size_per_token + state_host.size_per_token + ) + assert backend._evictor._total_bytes == expected_bytes + assert backend._evictor._total_bytes <= backend._evictor.max_size_bytes + assert backend.batch_get_v2(transfers) == { + PoolName.KV: [True], + PoolName.MAMBA: [True], + } + + exercise_async_checkpoint(disk_roundtrip=roundtrip) diff --git a/validation/hicache/test_hicache_file_local.py b/validation/hicache/test_hicache_file_local.py new file mode 100644 index 0000000..b4c0e93 --- /dev/null +++ b/validation/hicache/test_hicache_file_local.py @@ -0,0 +1,237 @@ +"""Disk feasibility probes against the bundled file backend; no serving changes.""" + +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +from queue import Queue +import threading +from unittest.mock import Mock + +import pytest +import torch + +from sglang.srt.managers.cache_controller import HiCacheController, PrefetchOperation +from sglang.srt.mem_cache.hybrid_cache.hybrid_cache_controller import ( + HybridCacheController, +) +from sglang.srt.mem_cache.hicache_storage import ( + HiCacheFile, + HiCacheStorageConfig, + PoolName, + PoolTransfer, +) +from sglang.srt.mem_cache.memory_pool_host import HostPoolGroup, PoolEntry +from test_hicache_ple_local import assert_state, make_pool, poison, snapshot + +pytest_plugins = ["test_hicache_ple_local"] + + +def storage(path, rank=0, cap=256_000_000, metadata=True): + return HiCacheFile( + HiCacheStorageConfig( + tp_rank=rank, + tp_size=2, + pp_rank=0, + pp_size=1, + attn_cp_rank=0, + attn_cp_size=1, + is_mla_model=False, + enable_storage_metrics=False, + is_page_first_layout=True, + model_name="qwen-ple-file-probe", + extra_config={ + "max_size": cap, + "min_free_space": 0, + "eviction_ratio": 0.9, + "enable_metadata_cache": metadata, + }, + ), + file_path=str(path), + ) + + +@pytest.mark.parametrize("rank", [0, 1]) +@pytest.mark.parametrize("metadata", [False, True]) +def test_file_restart_restores_ple_and_recurrent_state( + tmp_path, device, host_factory, rank, metadata +): + tmp_path.mkdir(exist_ok=True) + pool = make_pool(device) + host = host_factory(pool) + src, dst = torch.tensor([1], device=device), torch.tensor([5], device=device) + rows = host.alloc(1) + expected = snapshot(pool, src) + host.backup_from_device_all_layer(pool, rows, src) + backend = storage(tmp_path, rank, metadata=metadata) + assert backend._evictor.max_size_bytes == 256_000_000 + backend.register_mem_host_pool_v2(host, PoolName.MAMBA) + transfer = PoolTransfer(PoolName.MAMBA, host_indices=rows, keys=["checkpoint"]) + assert backend.batch_set_v2([transfer]) == {PoolName.MAMBA: [True]} + for tensor in host.get_hybrid_pool_buffer(): + tensor.fill_(0) + poison(pool, dst) + + # Reconstruct storage metadata from disk; no in-memory backend state survives. + backend = storage(tmp_path, rank, metadata=metadata) + assert backend._evictor._total_bytes == host.size_per_token + backend.register_mem_host_pool_v2(host, PoolName.MAMBA) + assert backend.batch_get_v2([transfer]) == {PoolName.MAMBA: [True]} + for layer in range(pool.num_mamba_layers): + host.load_to_device_per_layer(pool, rows, dst, layer) + assert_state(pool, dst, expected) + + +def test_two_rank_limits_bound_aggregate_and_survive_restart(tmp_path): + per_rank = 1024 + ranks = [storage(tmp_path, rank, per_rank) for rank in (0, 1)] + + def fill(rank): + for i in range(20): + assert ranks[rank].set( + str(i), torch.full((128,), rank + 1, dtype=torch.uint8) + ) + assert ranks[rank]._evictor._total_bytes <= per_rank + + with ThreadPoolExecutor(max_workers=2) as executor: + list(executor.map(fill, (0, 1))) + assert sum(p.stat().st_size for p in tmp_path.glob("*.bin")) <= 2 * per_rank + assert not list(tmp_path.glob("*.tmp.*")) + for rank in (0, 1): + reopened = storage(tmp_path, rank, per_rank) + assert reopened._evictor._total_bytes <= per_rank + page = reopened.get("19", torch.zeros(128, dtype=torch.uint8)) + assert torch.all(page == rank + 1) + + +def test_rejects_value_larger_than_rank_cap(tmp_path): + backend = storage(tmp_path, cap=64) + assert not backend.set("oversized", torch.ones(65, dtype=torch.uint8)) + assert not list(tmp_path.glob("*.bin")) + assert backend._evictor._total_bytes == 0 + + +def test_missing_file_is_cache_miss(tmp_path): + assert storage(tmp_path).get("missing", torch.zeros(32, dtype=torch.uint8)) is None + + +def test_short_file_is_cache_miss(tmp_path): + backend = storage(tmp_path) + assert backend.set("short", torch.ones(16, dtype=torch.uint8)) + assert backend.get("short", torch.zeros(32, dtype=torch.uint8)) is None + + +def test_disk_read_error_is_cache_miss(tmp_path, monkeypatch): + backend = storage(tmp_path) + assert backend.set("io-error", torch.ones(16, dtype=torch.uint8)) + target = Path(backend._get_component_path("io-error")) + original = open + + def read_error(path, mode="r", *args, **kwargs): + if Path(path) == target and mode == "rb": + raise OSError(5, "injected disk read error") + return original(path, mode, *args, **kwargs) + + monkeypatch.setattr("builtins.open", read_error) + assert backend.get("io-error", torch.zeros(16, dtype=torch.uint8)) is None + + +def test_failed_write_rolls_back_reservation(tmp_path, monkeypatch): + backend = storage(tmp_path, cap=1024) + + def rename_error(*args): + raise OSError(28, "injected filesystem full") + + monkeypatch.setattr("os.replace", rename_error) + assert not backend.set("failed", torch.ones(128, dtype=torch.uint8)) + assert backend._evictor._total_bytes == 0 + assert not backend._evictor._pending_writes + assert not list(tmp_path.iterdir()) + + +def test_prefetch_worker_continues_after_short_read(tmp_path, device, host_factory): + host = host_factory(make_pool(device)) + rows = host.alloc(2) + backend = storage(tmp_path) + assert backend.set("broken", torch.zeros(1, dtype=torch.uint8)) + expected = torch.full_like(host.get_dummy_flat_data_page(), 17) + assert backend.set("valid", expected) + controller = HiCacheController.__new__(HiCacheController) + controller.storage_backend, controller.mem_pool_host = backend, host + controller.page_size, controller.has_draft = 1, False + controller.page_get_func = controller._generic_page_get + controller.storage_stop_event = threading.Event() + controller.prefetch_buffer, controller.host_mem_release_queue = Queue(), Queue() + operations = [] + for i, key in enumerate(["broken", "valid"]): + op = PrefetchOperation(key, [i]) + op.hash_value, op.host_indices = [key], rows[i : i + 1] + operations.append(op) + controller.prefetch_buffer.put(op) + finished = threading.Event() + increment = operations[1].increment + + def completed(n): + result = increment(n) + finished.set() + return result + + operations[1].increment = completed + errors = [] + + def work(): + try: + controller.prefetch_io_aux_func() + except Exception as error: + errors.append(error) + + worker = threading.Thread(target=work) + worker.start() + try: + assert finished.wait(3), ( + "Prefetch worker did not reach the next valid page", + errors, + ) + finally: + controller.storage_stop_event.set() + controller.prefetch_buffer.put(None) + worker.join(3) + assert not worker.is_alive() and not errors + assert operations[0].is_terminated() and operations[0].completed_tokens == 0 + assert operations[1].completed_tokens == 1 + assert controller.host_mem_release_queue.qsize() == 1 + assert torch.equal(host.get_data_page(rows[1].item()), expected) + + +@pytest.mark.parametrize("late", [False, True]) +def test_file_attachment_allows_complete_checkpoint( + tmp_path, device, host_factory, monkeypatch, late +): + host = host_factory(make_pool(device)) + backend = storage(tmp_path) + controller = HybridCacheController.__new__(HybridCacheController) + anchor = PoolEntry(PoolName.KV, host, host.device_pool, lambda n: n, True) + controller.mem_pool_host = HostPoolGroup([anchor]) + controller.storage_backend, controller.enable_storage = backend, True + controller.extra_host_mem_release_queues = {} + entry = PoolEntry(PoolName.MAMBA, host, host.device_pool, lambda n: n) + if late: + controller.register_host_pool_entry(entry) + assert controller.mem_pool_host.entry_map[PoolName.MAMBA] is entry + else: + base_attach = Mock() + monkeypatch.setattr( + HybridCacheController.__mro__[1], "attach_storage_backend", base_attach + ) + controller.attach_storage_backend("file", host_pools=[entry]) + base_attach.assert_called_once() + assert backend.registered_pools[PoolName.MAMBA] is host + + +def test_metadata_queries_do_not_scan_the_entire_cache(tmp_path, monkeypatch): + backend = storage(tmp_path) + assert backend.set("prefix", torch.ones(32, dtype=torch.uint8)) + scan = Mock( + side_effect=AssertionError("A prefix lookup must not scan a 512GB directory") + ) + monkeypatch.setattr("os.scandir", scan) + assert backend.batch_exists_v2(["prefix"]).kv_hit_pages == 1 + scan.assert_not_called() diff --git a/validation/hicache/test_hicache_load_order.py b/validation/hicache/test_hicache_load_order.py new file mode 100644 index 0000000..141f0ac --- /dev/null +++ b/validation/hicache/test_hicache_load_order.py @@ -0,0 +1,79 @@ +"""Restore ordering for reclaimed pages and whole-slot recurrent-state copies.""" + +from types import SimpleNamespace +from unittest.mock import Mock + +import pytest +import torch + +from sglang.srt.managers.cache_controller import CacheOperation, HiCacheController +from sglang.srt.mem_cache.memory_pool import HybridReqToTokenPool +from sglang.srt.model_executor.forward_batch_info import ForwardMode +from sglang.srt.model_executor.model_runner import ModelRunner + + +@pytest.mark.parametrize("fenced", [False, True]) +def test_restore_fences_before_transfer_submission(fenced): + calls = [] + controller = object.__new__(HiCacheController) + op = CacheOperation(torch.tensor([0]), torch.tensor([1]), 42) + controller.load_queue = [op] + controller.ack_load_queue = [] + controller.layer_num = 3 + event = SimpleNamespace(start_event=Mock(), complete=Mock()) + controller.layer_done_counter = SimpleNamespace( + update_producer=lambda: 0, events=[event] + ) + controller.load_fence_stream = object() if fenced else None + controller._move_op_indices = lambda op: (op.host_indices, op.device_indices, []) + controller._l2_load_transfers = lambda *args: [] + controller._num_tokens_by_pool = lambda op: {} + controller._transfer_num_bytes = lambda op: 0 + + def wait(stream): + assert stream is controller.load_fence_stream + calls.append("wait") + + def submit(*args, **kwargs): + calls.append("submit") + return SimpleNamespace(start_event=object(), finish_event=object(), timing_enabled=False) + + controller.l2_transfer_engine = SimpleNamespace( + host_to_device_stream=SimpleNamespace(wait_stream=wait), + submit_host_to_device=submit, + ) + assert controller.start_loading() == 0 + assert calls == (["wait", "submit"] if fenced else ["submit"]) + assert controller.start_loading() == -1 + assert len(controller.ack_load_queue) == 1 + + +@pytest.mark.parametrize("checkpoint", [False, True]) +@pytest.mark.parametrize("has_cache", [False, True]) +def test_whole_slot_copy_waits_for_final_layer(checkpoint, has_cache): + calls = [] + pool = object.__new__(HybridReqToTokenPool) + pool.layer_transfer_counter = ( + SimpleNamespace(num_layers=48, wait_until=lambda i: calls.append(("wait", i))) + if has_cache else None + ) + pool.translate_mamba_indices = lambda indices: indices + pool.mamba_pool = SimpleNamespace(copy_from=lambda *args: calls.append(("copy",))) + pool.mamba_ckpt_pool = ( + SimpleNamespace(load_to_active=lambda *args: calls.append(("copy",))) + if checkpoint else None + ) + runner = object.__new__(ModelRunner) + runner.req_to_token_pool = pool + runner.is_draft_worker = False + batch = SimpleNamespace( + forward_mode=ForwardMode.EXTEND, + mamba_clear_indices=None, + mamba_cow_src_indices=torch.tensor([2]), + mamba_cow_dst_indices=torch.tensor([5]), + ) + runner._maybe_execute_deferred_mamba_cow_and_clear(batch) + assert calls == ([("wait", 47), ("copy",)] if has_cache else [("copy",)]) + assert batch.mamba_cow_src_indices is None + runner._maybe_execute_deferred_mamba_cow_and_clear(batch) + assert calls.count(("copy",)) == 1 diff --git a/validation/hicache/test_hicache_load_order_gpu.py b/validation/hicache/test_hicache_load_order_gpu.py new file mode 100644 index 0000000..b4b9884 --- /dev/null +++ b/validation/hicache/test_hicache_load_order_gpu.py @@ -0,0 +1,84 @@ +"""Exercise delayed GPU producers through the restored-state consumer wait.""" + +from types import SimpleNamespace + +import torch + +from sglang.srt.managers.cache_controller import CacheOperation, HiCacheController, LayerDoneCounter +from sglang.srt.mem_cache.l2_transfer import L2Transfer, L2TransferEngine +from sglang.srt.mem_cache.memory_pool import HybridReqToTokenPool +from sglang.srt.model_executor.forward_batch_info import ForwardMode +from sglang.srt.model_executor.model_runner import ModelRunner + + +def test_deferred_copy_sees_all_restored_layers(): + assert torch.cuda.is_available() + source = torch.zeros((3, 1024), device="cuda") + destination = torch.zeros_like(source) + src_index = torch.tensor([0], device="cuda") + dst_index = torch.tensor([1], device="cuda") + restore_stream = torch.cuda.Stream() + restore_stream.wait_stream(torch.cuda.current_stream()) + counter = LayerDoneCounter(3) + index = counter.update_producer() + counter.set_consumer(index) + with torch.cuda.stream(restore_stream): + for layer in range(3): + torch.cuda._sleep(20_000_000) + source[layer].fill_(layer + 17) + counter.events[index].complete(layer) + + pool = object.__new__(HybridReqToTokenPool) + pool.layer_transfer_counter = counter + pool.mamba_ckpt_pool = None + pool.translate_mamba_indices = lambda indices: indices + pool.mamba_pool = SimpleNamespace(copy_from=lambda *args: destination.copy_(source)) + runner = object.__new__(ModelRunner) + runner.req_to_token_pool = pool + runner.is_draft_worker = False + batch = SimpleNamespace( + forward_mode=ForwardMode.EXTEND, + mamba_clear_indices=None, + mamba_cow_src_indices=src_index, + mamba_cow_dst_indices=dst_index, + ) + runner._maybe_execute_deferred_mamba_cow_and_clear(batch) + actual = destination.cpu() + restore_stream.synchronize() + expected = torch.arange(17, 20, dtype=actual.dtype)[:, None].expand_as(actual) + torch.testing.assert_close(actual, expected, rtol=0, atol=0) + + +def test_restore_follows_inflight_write_to_reclaimed_page(): + assert torch.cuda.is_available() + destination = torch.zeros((1, 1024), device="cuda") + host = torch.full((1, 1024), 17.0, pin_memory=True) + indices = torch.tensor([0]) + forward_stream = torch.cuda.Stream() + forward_stream.wait_stream(torch.cuda.current_stream()) + engine = L2TransferEngine("direct") + counter = LayerDoneCounter(1) + host_pool = SimpleNamespace( + layer_num=1, + load_to_device_per_layer=lambda *args, **kwargs: destination.copy_(host, non_blocking=True), + ) + transfer = L2Transfer(host_pool, None, indices, indices) + controller = object.__new__(HiCacheController) + op = CacheOperation(indices, indices, 42) + controller.load_queue = [op] + controller.ack_load_queue = [] + controller.layer_num = 1 + controller.layer_done_counter = counter + controller.load_fence_stream = forward_stream + controller.l2_transfer_engine = engine + controller._move_op_indices = lambda op: (indices, indices, []) + controller._l2_load_transfers = lambda *args: [transfer] + controller._num_tokens_by_pool = lambda op: {} + controller._transfer_num_bytes = lambda op: host.numel() * host.element_size() + with torch.cuda.stream(forward_stream): + torch.cuda._sleep(200_000_000) + destination.fill_(99) + controller.start_loading() + controller.ack_load_queue[0].finish_event.synchronize() + forward_stream.synchronize() + torch.testing.assert_close(destination.cpu(), host, rtol=0, atol=0) diff --git a/validation/hicache/test_hicache_ple_gpu_local.py b/validation/hicache/test_hicache_ple_gpu_local.py new file mode 100644 index 0000000..cc33c39 --- /dev/null +++ b/validation/hicache/test_hicache_ple_gpu_local.py @@ -0,0 +1,192 @@ +"""CUDA-only integration checks with Qwen TP2 state shapes and real transfers.""" + +import torch + +from sglang.srt.managers.cache_controller import CacheOperation, LayerDoneCounter +from sglang.srt.mem_cache.hicache_storage import PoolName, PoolTransfer +from sglang.srt.mem_cache.hybrid_cache.hybrid_cache_controller import ( + HybridCacheController, +) +from sglang.srt.mem_cache.l2_transfer import L2TransferEngine +from sglang.srt.mem_cache.memory_pool import ( + HybridReqToTokenPool, + MHATokenToKVPool, + MambaPool, +) +from sglang.srt.mem_cache.memory_pool_host import ( + HostPoolGroup, + MambaPoolHost, + PoolEntry, +) +from sglang.srt.mem_cache.ple_state_pool import NGramPool, ShortConvPool +from sglang.srt.mem_cache.pool_host.mha import MHATokenToKVPoolHost + +from test_hicache_ple_local import assert_state, poison, snapshot, tensors + + +def make_kv(layer_num): + # Synthetic values, but the serving pool's exact FP8 byte layout and geometry. + pool = MHATokenToKVPool.__new__(MHATokenToKVPool) + pool.size, pool.page_size = 256, 64 + pool.dtype, pool.store_dtype = torch.float8_e4m3fn, torch.uint8 + pool.layer_num, pool.start_layer, pool.end_layer = layer_num, 0, layer_num + pool.head_num, pool.head_dim, pool.device = 1, 256, "cuda" + pool.k_buffer = [ + torch.zeros((320, 1, 256), dtype=torch.uint8, device="cuda") + for _ in range(layer_num) + ] + pool.v_buffer = [torch.zeros_like(x) for x in pool.k_buffer] + pool.k_data_ptrs = torch.tensor( + [x.data_ptr() for x in pool.k_buffer], dtype=torch.uint64, device="cuda" + ) + pool.v_data_ptrs = torch.tensor( + [x.data_ptr() for x in pool.v_buffer], dtype=torch.uint64, device="cuda" + ) + return pool + + +def make_qwen_state(): + pool = MambaPool.__new__(MambaPool) + pool.size, pool.num_mamba_layers, pool.device = 7, 36, "cuda" + pool.mamba_layer_ids = [layer for layer in range(48) if layer % 4 != 3] + pool.mamba_cache = MambaPool.State( + conv=[torch.zeros((36, 8, 5120, 3), dtype=torch.bfloat16, device="cuda")], + temporal=torch.zeros( + (36, 8, 24, 128, 128), dtype=torch.bfloat16, device="cuda" + ), + ) + conv = ShortConvPool.__new__(ShortConvPool) + conv.conv_state = torch.zeros((1, 8, 10240, 9), dtype=torch.bfloat16, device="cuda") + conv.layer_map = {2: 0} + ngram = NGramPool.__new__(NGramPool) + ngram.context = torch.zeros((8, 2), dtype=torch.int64, device="cuda") + pool._slot_siblings, pool.replayssm_cache_base = [conv, ngram], None + return pool + + +def exercise_async_checkpoint(disk_roundtrip=None): + assert torch.cuda.is_available(), "This integration check requires real CUDA" + main, draft, recurrent = make_kv(12), make_kv(1), make_qwen_state() + made = [] + try: + kv_host = MHATokenToKVPoolHost( + main, 2, 0, 64, "page_first", mtp_draft_device_pools=(draft,) + ) + made.append(kv_host) + state_host = MambaPoolHost(recurrent, 2, 0, layout="page_first") + made.append(state_host) + kv_map = {layer: i for i, layer in enumerate(range(3, 48, 4))} + kv_map[48] = 12 + state_map = {layer: i for i, layer in enumerate(recurrent.mamba_layer_ids)} + controller = HybridCacheController.__new__(HybridCacheController) + controller.mem_pool_host = HostPoolGroup( + [ + PoolEntry(PoolName.KV, kv_host, main, kv_map.get, True), + PoolEntry(PoolName.MAMBA, state_host, recurrent, state_map.get), + ] + ) + controller.has_draft, controller.has_mtp_draft = False, True + controller.mtp_draft_device_pools = (draft,) + controller.layer_num, controller.io_backend, controller.device = ( + 48, + "kernel", + "cuda", + ) + counter, engine = LayerDoneCounter(48), L2TransferEngine("kernel") + request_pool = HybridReqToTokenPool.__new__(HybridReqToTokenPool) + request_pool.start_layer, request_pool.mamba_map = 0, state_map + request_pool.layer_transfer_counter = counter + request_pool.short_conv_pool, request_pool.ngram_pool = recurrent._slot_siblings + kv_rows, state_rows = kv_host.alloc(64), state_host.alloc(1) + kv_src, kv_dst = torch.arange(64, device="cuda"), torch.arange( + 128, 192, device="cuda" + ) + state_src, state_dst = torch.tensor([1], device="cuda"), torch.tensor( + [4, 5], device="cuda" + ) + all_kv = main.k_buffer + main.v_buffer + draft.k_buffer + draft.v_buffer + assert kv_host.layer_num == 13 + assert kv_host.size_per_token == 13 * 2 * 256 + assert ( + state_host.size_per_token + == 36 * (5120 * 3 + 24 * 128 * 128) * 2 + 10240 * 9 * 2 + 2 * 8 + ) + assert ( + sum( + t.numel() * t.element_size() + for t in state_host.get_hybrid_pool_buffer() + ) + == state_host.size * state_host.size_per_token + ) + + # Reuse slots and wrap the actual three-event producer/consumer ring. + for epoch in range(4): + for i, tensor in enumerate(all_kv): + tensor[kv_src] = ( + torch.arange(64, device="cuda")[:, None, None] + 7 * i + epoch + ).to(torch.uint8) + for i, tensor in enumerate(tensors(recurrent).values()): + tensor[:, state_src] = epoch + i + 21 + expected_kv = [t[kv_src].clone() for t in all_kv] + expected_state = { + k: v.repeat(1, 2, *([1] * (v.ndim - 2))) + for k, v in snapshot(recurrent, state_src).items() + } + write_op = CacheOperation( + kv_rows, + kv_src, + epoch, + pool_transfers=[PoolTransfer(PoolName.MAMBA, state_rows, state_src)], + ) + write_args = controller._move_write_operation(write_op) + written = engine.submit_device_to_host( + controller._l2_transfers(*write_args) + ) + written.finish_event.synchronize() + if disk_roundtrip is not None: + disk_roundtrip(kv_host, state_host, kv_rows, state_rows, epoch) + for tensor in all_kv: + tensor[kv_dst] = 255 + poison(recurrent, state_dst) + + load_op = CacheOperation( + kv_rows, + kv_dst, + epoch, + pool_transfers=[ + PoolTransfer(PoolName.MAMBA, state_rows.repeat(2), state_dst) + ], + ) + load_args = controller.move_hybrid_indices(load_op) + transfers = controller._l2_load_transfers(*load_args) + assert len(transfers) == 3 and transfers[-1].is_draft + event_index = counter.update_producer() + counter.set_consumer(event_index) + with torch.cuda.stream(engine.host_to_device_stream): + torch.cuda._sleep(20_000_000) + restored = engine.submit_host_to_device( + transfers, + layer_num=48, + on_layer_done=counter.events[event_index].complete, + ) + + # Capture PLE reads before any host-side synchronization of the restore. + early_ngram = request_pool.get_ngram_context(state_dst).clone() + early_conv = request_pool.short_conv_layer_cache(2)[state_dst].clone() + torch.cuda.current_stream().synchronize() + assert torch.equal(early_ngram, expected_state["ple_ngram"][0]) + assert torch.equal(early_conv, expected_state["ple_conv"][0]) + restored.finish_event.synchronize() + assert_state(recurrent, state_dst, expected_state) + for actual, expected in zip(all_kv, expected_kv): + assert torch.equal(actual[kv_dst], expected) + assert kv_host.available_size() == kv_host.size - 64 + assert state_host.available_size() == state_host.size - 1 + finally: + torch.cuda.synchronize() + for host in made: + host.destroy() + + +def test_async_qwen_main_draft_mamba_and_ple_checkpoint(): + exercise_async_checkpoint() diff --git a/validation/hicache/test_hicache_ple_local.py b/validation/hicache/test_hicache_ple_local.py new file mode 100644 index 0000000..b302938 --- /dev/null +++ b/validation/hicache/test_hicache_ple_local.py @@ -0,0 +1,420 @@ +"""PLE checkpoint correctness on CPU fixtures and real CUDA transfers.""" + +import os +from types import SimpleNamespace +from unittest.mock import Mock + +import pytest +import torch + +if os.environ.get("QWEN_HICACHE_TEST_DEVICE", "cpu") == "cpu": + from sglang.test.test_utils import maybe_stub_sgl_kernel + + maybe_stub_sgl_kernel() + +from sglang.srt.mem_cache import memory_pool_host as host_module +from sglang.srt.mem_cache.hybrid_cache.hybrid_cache_controller import ( + HybridCacheController, +) +from sglang.srt.mem_cache.memory_pool import HybridReqToTokenPool, MambaPool +from sglang.srt.mem_cache.memory_pool_host import HostPoolGroup, MambaPoolHost +from sglang.srt.mem_cache.ple_state_pool import NGramPool, ShortConvPool + + +@pytest.fixture +def device(): + d = torch.device(os.environ.get("QWEN_HICACHE_TEST_DEVICE", "cpu")) + if d.type == "cuda": + assert torch.cuda.is_available(), "Requested CUDA tests must run, not skip" + return d + + +def sync(device): + if device.type == "cuda": + torch.cuda.synchronize(device) + + +def io_indices(indices, backend): + # HiCacheController.move_indices keeps direct-copy indices on the CPU. + return indices.cpu() if backend == "direct" else indices + + +def pattern(shape, dtype, device, offset=0): + count = 1 + for n in shape: + count *= n + return ((torch.arange(count, device=device) % 97) + offset).to(dtype).reshape(shape) + + +def make_pool(device, companions=True): + pool = MambaPool.__new__(MambaPool) + pool.size = 7 + pool.num_mamba_layers = 3 + pool.mamba_layer_ids = [0, 2, 3] + pool.device = device.type + pool.mamba_cache = MambaPool.State( + conv=[pattern((3, 8, 12, 4), torch.bfloat16, device, 2)], + temporal=pattern((3, 8, 2, 8, 8), torch.bfloat16, device, 4), + ) + conv = ShortConvPool.__new__(ShortConvPool) + conv.conv_state = pattern((2, 8, 8, 4), torch.bfloat16, device, 6) + conv.layer_map = {1: 0, 3: 1} + ngram = NGramPool.__new__(NGramPool) + ngram.context = pattern((8, 2), torch.int64, device, 1000) + pool._slot_siblings = [conv, ngram] if companions else [] + pool.replayssm_cache_base = None + return pool + + +def tensors(pool): + result = {"conv": pool.mamba_cache.conv[0], "temporal": pool.mamba_cache.temporal} + if pool._slot_siblings: + result["ple_conv"] = pool._slot_siblings[0].conv_state + result["ple_ngram"] = pool._slot_siblings[1].context.unsqueeze(0) + return result + + +def snapshot(pool, indices): + return {name: tensor[:, indices].clone() for name, tensor in tensors(pool).items()} + + +def poison(pool, indices): + for i, tensor in enumerate(tensors(pool).values(), 1): + tensor[:, indices] = -100 * i + + +def assert_state(pool, indices, expected): + for name, tensor in tensors(pool).items(): + assert torch.equal(tensor[:, indices], expected[name]), name + + +@pytest.fixture(autouse=True) +def cpu_transport(monkeypatch, device): + if device.type != "cpu": + return + + def backup(*, src_layers, dst, src_indices, dst_indices, **kwargs): + dst[dst_indices, :, 0] = src_layers[:, src_indices].transpose(0, 1) + + def restore(*, src, dst, src_indices, dst_indices, layer_id, **kwargs): + dst[dst_indices] = src[src_indices, layer_id, 0] + + # Retain real construction, state selection, allocation and lifecycle. + # CUDA runs do not replace either transport function. + monkeypatch.setattr( + MambaPoolHost, "_copy_tensor_all_layers_lf_pf", staticmethod(backup) + ) + monkeypatch.setattr(MambaPoolHost, "_copy_tensor_pf_lf", staticmethod(restore)) + + +@pytest.fixture +def host_factory(device): + made = [] + + def create(pool, layout="page_first", **kwargs): + host = MambaPoolHost( + pool, + host_to_device_ratio=2, + host_size=kwargs.pop("host_size", 0), + layout=layout, + pin_memory=device.type == "cuda", + **kwargs, + ) + made.append(host) + return host + + yield create + sync(device) + for host in made: + host.destroy() + + +@pytest.mark.parametrize( + "layout,backend", [("page_first", "kernel"), ("page_first_direct", "direct")] +) +@pytest.mark.parametrize("companions", [True, False]) +@pytest.mark.parametrize("destination", [[1, 2], [4, 5]]) +def test_complete_state_roundtrip( + device, host_factory, layout, backend, companions, destination +): + pool = make_pool(device, companions) + host = host_factory(pool, layout) + src = torch.tensor([1, 2], device=device) + dst = torch.tensor(destination, device=device) + rows = host.alloc(2) + expected = snapshot(pool, src) + host.backup_from_device_all_layer(pool, rows, io_indices(src, backend), backend) + sync(device) + poison(pool, dst) + for layer in range(pool.num_mamba_layers): + host.load_to_device_per_layer( + pool, rows, io_indices(dst, backend), layer, backend + ) + sync(device) + assert_state(pool, dst, expected) + + +@pytest.mark.parametrize( + "layout,backend", [("page_first", "kernel"), ("page_first_direct", "direct")] +) +def test_one_host_checkpoint_restores_tree_and_request_slots( + device, host_factory, layout, backend +): + pool = make_pool(device) + host = host_factory(pool, layout) + src = torch.tensor([1], device=device) + dst = torch.tensor([4, 5], device=device) + rows = host.alloc(1) + expected = { + k: v.repeat(1, 2, *([1] * (v.ndim - 2))) for k, v in snapshot(pool, src).items() + } + host.backup_from_device_all_layer(pool, rows, io_indices(src, backend), backend) + sync(device) + poison(pool, dst) + for layer in range(pool.num_mamba_layers): + host.load_to_device_per_layer( + pool, rows.repeat(2), io_indices(dst, backend), layer, backend + ) + sync(device) + assert_state(pool, dst, expected) + + +@pytest.mark.parametrize("backend", ["kernel", "direct"]) +def test_companions_ready_at_first_layer_event(device, host_factory, backend): + pool = make_pool(device) + host = host_factory( + pool, "page_first" if backend == "kernel" else "page_first_direct" + ) + src, dst = torch.tensor([1], device=device), torch.tensor([4], device=device) + rows = host.alloc(1) + expected = snapshot(pool, src) + host.backup_from_device_all_layer(pool, rows, io_indices(src, backend), backend) + sync(device) + poison(pool, dst) + host.load_to_device_per_layer(pool, rows, io_indices(dst, backend), 0, backend) + sync(device) + actual = snapshot(pool, dst) + assert torch.equal(actual["ple_conv"], expected["ple_conv"]) + assert torch.equal(actual["ple_ngram"], expected["ple_ngram"]) + assert torch.equal(actual["temporal"][0], expected["temporal"][0]) + assert torch.all(actual["temporal"][1:] == -200) + + +@pytest.mark.parametrize("companions", [True, False]) +def test_fixed_budget_counts_every_buffer(device, host_factory, companions): + pool = make_pool(device, companions) + budget = 30000 + host = host_factory(pool, host_size=budget / 1e9) + allocated = sum(t.numel() * t.element_size() for t in host.get_hybrid_pool_buffer()) + bytes_per_slot = sum( + t[:, 0].numel() * t.element_size() for t in tensors(pool).values() + ) + assert allocated == host.size * bytes_per_slot + assert budget < allocated <= budget + bytes_per_slot + assert allocated == host.size * host.size_per_token + + +def test_capacity_is_bounded_across_reuse_and_reset(device, host_factory): + pool = make_pool(device) + host = host_factory(pool) + buffer_ids = [x.data_ptr() for x in host.get_hybrid_pool_buffer()] + all_rows = host.alloc(host.size) + assert host.alloc(1) is None + src, dst = torch.tensor([1, 2], device=device), torch.tensor([4, 5], device=device) + for epoch in range(3): + rows = all_rows[:2] + for tensor in tensors(pool).values(): + tensor[:, src] = epoch + 17 + host.backup_from_device_all_layer(pool, rows, src) + sync(device) + host.free(rows) + reused = host.alloc(2) + assert torch.equal(reused, rows) + for tensor in tensors(pool).values(): + tensor[:, src] = epoch + 77 + expected = snapshot(pool, src) + host.backup_from_device_all_layer(pool, reused, src) + sync(device) + poison(pool, dst) + for layer in range(pool.num_mamba_layers): + host.load_to_device_per_layer(pool, reused, dst, layer) + sync(device) + assert_state(pool, dst, expected) + assert [x.data_ptr() for x in host.get_hybrid_pool_buffer()] == buffer_ids + host.clear() + assert host.available_size() == host.size + assert len(torch.unique(host.alloc(host.size))) == host.size + + +def test_empty_transfers_do_not_change_state(device, host_factory): + pool = make_pool(device) + host = host_factory(pool) + all_rows = torch.arange(8, device=device) + before = snapshot(pool, all_rows) + empty_device = torch.empty(0, dtype=torch.int64, device=device) + empty_host = torch.empty(0, dtype=torch.int64) + host.backup_from_device_all_layer(pool, empty_host, empty_device) + for layer in range(pool.num_mamba_layers): + host.load_to_device_per_layer(pool, empty_host, empty_device, layer) + sync(device) + assert_state(pool, all_rows, before) + + +@pytest.mark.parametrize("kind", ["short_conv", "ngram"]) +def test_disabled_companions_have_no_transfer_tensors(kind): + pool = ( + ShortConvPool.__new__(ShortConvPool) + if kind == "short_conv" + else NGramPool.__new__(NGramPool) + ) + if kind == "short_conv": + pool.conv_state = None + else: + pool.context = None + assert pool.get_slot_tensors() == () + + +@pytest.mark.parametrize( + "start,layers,ple_layer", [(0, [0, 2, 3], 1), (16, [16, 18], 17), (0, [2, 3], 0)] +) +def test_readers_wait_before_reading_restored_state(start, layers, ple_layer): + calls = [] + pool = HybridReqToTokenPool.__new__(HybridReqToTokenPool) + pool.start_layer = start + pool.mamba_map = {layer: i for i, layer in enumerate(layers)} + pool.layer_transfer_counter = SimpleNamespace( + wait_until=lambda n: calls.append(("wait", n)) + ) + pool.ngram_pool = SimpleNamespace(get_context=lambda _: calls.append(("ngram",))) + pool.short_conv_pool = SimpleNamespace( + layer_cache=lambda _: calls.append(("conv",)) + ) + pool.get_ngram_context(torch.tensor([1])) + pool.short_conv_layer_cache(ple_layer) + assert calls == [ + ("wait", min(layers) - start), + ("ngram",), + ("wait", max(ple_layer, min(layers)) - start), + ("conv",), + ] + + +def test_no_hicache_has_no_read_barrier(): + pool = HybridReqToTokenPool.__new__(HybridReqToTokenPool) + pool.layer_transfer_counter = None + pool.ngram_pool = SimpleNamespace(get_context=lambda _: "history") + pool.short_conv_pool = SimpleNamespace(layer_cache=lambda _: "conv") + assert pool.get_ngram_context(torch.tensor([1])) == "history" + assert pool.short_conv_layer_cache(1) == "conv" + + +def test_host_memory_check_includes_companions(monkeypatch, device): + pool = make_pool(device) + main_bytes = sum( + t[:, 0].numel() * t.element_size() + for t in tensors(make_pool(device, False)).values() + ) + available = host_module.HICACHE_HOST_MEMORY_RESERVE_BYTES + 15 * main_bytes + 1 + monkeypatch.setattr( + host_module.psutil, + "virtual_memory", + lambda: SimpleNamespace(available=available), + ) + allocator = Mock(side_effect=AssertionError("Must reject before host allocation")) + monkeypatch.setitem(host_module.ALLOC_MEMORY_FUNCS, device.type, allocator) + with pytest.raises(ValueError, match="Not enough host memory"): + MambaPoolHost(pool, 2, 0, layout="page_first", pin_memory=False) + allocator.assert_not_called() + + +def test_partial_allocation_releases_all_pinned_buffers(monkeypatch): + pool = make_pool(torch.device("cpu")) + made, released = [], [] + + def allocate(dims, *, dtype, **kwargs): + if len(made) == 3: + raise MemoryError("companion allocation failure") + tensor = torch.empty(dims, dtype=dtype) + made.append(tensor) + return tensor + + monkeypatch.setattr(host_module, "_is_cuda", True) + monkeypatch.setattr( + host_module, "_cuda_host_unregister", lambda t: released.append(t.data_ptr()) + ) + monkeypatch.setitem(host_module.ALLOC_MEMORY_FUNCS, "cpu", allocate) + with pytest.raises(MemoryError, match="companion allocation"): + MambaPoolHost(pool, 2, 0, layout="page_first", pin_memory=True) + assert released == [t.data_ptr() for t in made] + + +def test_destroy_is_idempotent(monkeypatch, device, host_factory): + host = host_factory(make_pool(device)) + expected = [t.data_ptr() for t in host.get_hybrid_pool_buffer()] + original = host_module._cuda_host_unregister + released = [] + + def unregister(tensor): + released.append(tensor.data_ptr()) + if device.type == "cuda": + original(tensor) + + monkeypatch.setattr(host_module, "_is_cuda", True) + monkeypatch.setattr(host_module, "_cuda_host_unregister", unregister) + host.pin_memory = True + sync(device) + host.destroy() + host.destroy() + assert released == expected + assert host.sibling_buffers == [] + + +def test_flat_state_and_pointer_metadata_cover_companions(device, host_factory): + pool = make_pool(device) + host = host_factory(pool) + rows = host.alloc(2) + host.backup_from_device_all_layer(pool, rows, torch.tensor([1, 2], device=device)) + sync(device) + for row in rows.tolist(): + page = host.get_data_page(row) + assert page.numel() == host.size_per_token + saved = page.clone() + host.set_from_flat_data_page(row, torch.zeros_like(page)) + host.set_from_flat_data_page(row, saved) + assert torch.equal(saved, host.get_data_page(row)) + pointers, lengths = host.get_page_buffer_meta(rows) + assert sum(lengths) == len(rows) * host.size_per_token + expected = [t for row in rows.tolist() for t in host._iter_page_tensors(row)] + assert pointers == [t.data_ptr() for t in expected] + assert lengths == [t.numel() * t.element_size() for t in expected] + assert not host.is_stride_page_aligned() + + +@pytest.mark.parametrize("late", [False, True]) +def test_storage_attachment_rejected_before_side_effects( + device, host_factory, monkeypatch, late +): + host = host_factory(make_pool(device)) + controller = HybridCacheController.__new__(HybridCacheController) + entry = SimpleNamespace(host_pool=host) + controller.mem_pool_host = HostPoolGroup.__new__(HostPoolGroup) + controller.mem_pool_host.entries = [] if late else [entry] + controller.mem_pool_host.add_entry = Mock() + controller.enable_storage = True + controller.storage_backend = Mock() + base_attach = Mock(side_effect=AssertionError("Storage attachment must not start")) + monkeypatch.setattr( + HybridCacheController.__mro__[1], "attach_storage_backend", base_attach + ) + with pytest.raises(NotImplementedError, match="RAM and file storage only"): + if late: + controller.register_host_pool_entry(entry) + else: + controller.attach_storage_backend("mooncake") + base_attach.assert_not_called() + controller.mem_pool_host.add_entry.assert_not_called() + + +def test_non_ple_storage_guard_is_unchanged(device, host_factory): + HybridCacheController._check_storage_pool(host_factory(make_pool(device, False))) + HybridCacheController._check_storage_pool(SimpleNamespace()) diff --git a/validation/hicache/test_hicache_qsa_gpu_local.py b/validation/hicache/test_hicache_qsa_gpu_local.py new file mode 100644 index 0000000..3e54414 --- /dev/null +++ b/validation/hicache/test_hicache_qsa_gpu_local.py @@ -0,0 +1,163 @@ +"""Real target/draft index copies with relocation, file restart and layer waits.""" + +import os + +import pytest +import torch + +from sglang.srt.managers.cache_controller import CacheOperation, LayerDoneCounter +from sglang.srt.mem_cache.hicache_storage import PoolName, PoolTransfer +from sglang.srt.mem_cache.hybrid_cache.hybrid_cache_controller import ( + HybridCacheController, +) +from sglang.srt.mem_cache.l2_transfer import L2TransferEngine +from sglang.srt.mem_cache.memory_pool_host import HostPoolGroup, PoolEntry +from sglang.srt.mem_cache.pool_host.mha import MHATokenToKVPoolHost +from sglang.srt.mem_cache.qsa_pool_host import QSAPagedHostPool + +from test_hicache_file_local import storage +from test_hicache_ple_gpu_local import make_kv +from test_hicache_qsa_local import make_index_pool + + +@pytest.mark.parametrize("layout", ["layer_first", "page_first"]) +@pytest.mark.parametrize("on_disk", [False, True]) +def test_async_qsa_target_and_draft_relocation(tmp_path, layout, on_disk): + assert torch.cuda.is_available(), "Real CUDA is required for this gate" + main, draft = make_kv(12), make_kv(1) + qsa, draft_qsa = make_index_pool(12, "cuda"), make_index_pool(1, "cuda") + made = [] + try: + kv_host = MHATokenToKVPoolHost( + main, 2, 0, 64, layout, mtp_draft_device_pools=(draft,) + ) + made.append(kv_host) + index_host = QSAPagedHostPool((qsa, draft_qsa), kv_host.size, 64, layout) + made.append(index_host) + kv_map = {layer: i for i, layer in enumerate(range(3, 48, 4))} + kv_map[48] = 12 + controller = HybridCacheController.__new__(HybridCacheController) + controller.mem_pool_host = HostPoolGroup( + [ + PoolEntry(PoolName.KV, kv_host, main, kv_map.get, True), + PoolEntry(PoolName.QSA_INDEXER, index_host, qsa, kv_map.get), + ] + ) + controller.has_draft, controller.has_mtp_draft = False, True + controller.mtp_draft_device_pools = (draft,) + controller.layer_num, controller.io_backend, controller.device = ( + 48, + "kernel", + "cuda", + ) + counter, engine = LayerDoneCounter(48), L2TransferEngine("kernel") + qsa.layer_transfer_counter = counter + rows = kv_host.alloc(128) + source, destination = torch.arange(64, 192, device="cuda"), torch.arange( + 128, 256, device="cuda" + ) + source_index, dest_index = torch.arange(16, 48, device="cuda"), torch.arange( + 32, 64, device="cuda" + ) + all_kv = main.k_buffer + main.v_buffer + draft.k_buffer + draft.v_buffer + all_index = ( + qsa.qsa_compressed_k_buffer_pool + draft_qsa.qsa_compressed_k_buffer_pool + ) + assert index_host.layer_num == 13 and index_host.size_per_token == 13 * 64 + for epoch in range(4): + for i, buffer in enumerate(all_kv): + buffer[source] = ( + torch.arange(128, device="cuda")[:, None, None] + i * 7 + epoch + ).to(torch.uint8) + for i, buffer in enumerate(all_index): + buffer[source_index] = ( + torch.arange(32 * 128, device="cuda").reshape(32, 1, 128) % 191 + + i + + epoch + ).to(torch.bfloat16) + expected_kv = [x[source].clone() for x in all_kv] + expected_index = [x[source_index].clone() for x in all_index] + write = CacheOperation( + rows, + source, + epoch, + pool_transfers=[ + PoolTransfer( + PoolName.QSA_INDEXER, + rows, + source, + indices_from_pool=PoolName.KV, + ) + ], + ) + assert controller._transfer_num_bytes(write) == 128 * ( + kv_host.size_per_token + index_host.size_per_token + ) + copied = engine.submit_device_to_host( + controller._l2_transfers(*controller._move_write_operation(write)) + ) + copied.finish_event.synchronize() + if on_disk: + + def reopen(): + backend = storage( + tmp_path, int(os.environ.get("QWEN_HICACHE_TP_RANK", "0")) + ) + backend.register_mem_host_pool_v2(kv_host, PoolName.KV) + backend.register_mem_host_pool_v2(index_host, PoolName.QSA_INDEXER) + return backend + + keys = [f"{epoch}-{i}" for i in range(2)] + transfers = [ + PoolTransfer(name, rows, keys=keys) + for name in (PoolName.KV, PoolName.QSA_INDEXER) + ] + expected_hits = { + name: [True, True] for name in (PoolName.KV, PoolName.QSA_INDEXER) + } + assert reopen().batch_set_v2(transfers) == expected_hits + kv_host.kv_buffer.zero_() + for buffer in index_host.get_hybrid_pool_buffer(): + buffer.zero_() + assert reopen().batch_get_v2(transfers) == expected_hits + for buffer in all_kv: + buffer[destination] = 255 + for buffer in all_index: + buffer[dest_index] = -200 + load = CacheOperation( + rows, + destination, + epoch, + pool_transfers=[ + PoolTransfer( + PoolName.QSA_INDEXER, + rows, + destination, + indices_from_pool=PoolName.KV, + ) + ], + ) + transfers = controller._l2_load_transfers( + *controller.move_hybrid_indices(load) + ) + assert len(transfers) == 4 and sum(x.is_draft for x in transfers) == 2 + event_id = counter.update_producer() + counter.set_consumer(event_id) + with torch.cuda.stream(engine.host_to_device_stream): + torch.cuda._sleep(20_000_000) + restored = engine.submit_host_to_device( + transfers, layer_num=48, on_layer_done=counter.events[event_id].complete + ) + # This read must wait for the index copy, before a full-transfer sync. + early = qsa.get_qsa_compressed_k_buffer(3)[dest_index].clone() + torch.cuda.current_stream().synchronize() + assert torch.equal(early, expected_index[0]) + restored.finish_event.synchronize() + for actual, expected in zip(all_kv, expected_kv): + assert torch.equal(actual[destination], expected) + for actual, expected in zip(all_index, expected_index): + assert torch.equal(actual[dest_index], expected) + finally: + torch.cuda.synchronize() + for host in made: + host.destroy() diff --git a/validation/hicache/test_hicache_qsa_local.py b/validation/hicache/test_hicache_qsa_local.py new file mode 100644 index 0000000..61b80fe --- /dev/null +++ b/validation/hicache/test_hicache_qsa_local.py @@ -0,0 +1,254 @@ +"""Compressed QSA cache layout, budgeting and required disk-page coverage.""" + +from types import SimpleNamespace +from unittest.mock import Mock + +import pytest +import torch + +from sglang.srt.mem_cache.hicache_storage import PoolHitPolicy, PoolName, PoolTransfer +from sglang.srt.mem_cache.hybrid_cache import hybrid_pool_assembler as assembler +from sglang.srt.mem_cache.qsa_kv_pool import QSATokenToKVPool +from sglang.srt.mem_cache.qsa_pool_host import ( + QSAPagedHostPool, + qsa_index_bytes_per_token, +) + +from test_hicache_file_local import storage + + +def make_index_pool(layers=2, device="cpu", ratio=4, page_size=64): + pool = QSATokenToKVPool.__new__(QSATokenToKVPool) + pool.page_size, pool.qsa_compress_ratio = page_size, ratio + pool.qsa_compressed_k_buffer_pool = [ + ((torch.arange(80 * 128, device=device) % 173) + layer) + .to(torch.bfloat16) + .reshape(80, 1, 128) + for layer in range(layers) + ] + pool.full_attention_layer_id_mapping = {4 * i + 3: i for i in range(layers)} + pool.start_layer, pool.layer_transfer_counter = 0, None + return pool + + +@pytest.mark.parametrize("layout", ["layer_first", "page_first", "page_first_direct"]) +def test_flat_page_carries_every_target_and_draft_layer(layout): + pools = (make_index_pool(), make_index_pool(1)) + host = QSAPagedHostPool(pools, 192, 64, layout, pin_memory=False) + try: + assert host.size_per_token == 3 * 128 * 2 // 4 + assert host.get_size_per_token() == host.size_per_token + assert ( + sum(x.numel() * x.element_size() for x in host.get_hybrid_pool_buffer()) + == 192 * host.size_per_token + ) + expected = torch.arange(64 * host.size_per_token).to(torch.uint8) + host.set_from_flat_data_page(64, expected) + assert torch.equal(host.get_data_page(64), expected) + assert host.get_dummy_flat_data_page().shape == expected.shape + assert host._to_page_indices(torch.arange(64, 192)).tolist() == [1, 2] + finally: + host.destroy() + + +@pytest.mark.parametrize("ratio,page_size", [(0, 64), (3, 64), (4, 1)]) +def test_rejects_incomplete_compression_groups(ratio, page_size): + with pytest.raises(ValueError): + qsa_index_bytes_per_token((make_index_pool(ratio=ratio),), page_size) + + +def test_rejects_partial_copy_and_mismatched_draft(): + host = QSAPagedHostPool( + (make_index_pool(),), 192, 64, "page_first", pin_memory=False + ) + try: + with pytest.raises(ValueError, match="complete KV pages"): + host._has_transfer_indices(torch.arange(63), torch.arange(63)) + finally: + host.destroy() + with pytest.raises(ValueError, match="shapes must match"): + QSAPagedHostPool( + (make_index_pool(), make_index_pool(1, ratio=8)), + 192, + 64, + "page_first", + pin_memory=False, + ) + + +def test_index_read_waits_on_global_attention_layer(): + pool = make_index_pool() + pool.layer_transfer_counter = Mock() + result = pool.get_qsa_compressed_k_buffer(7) + pool.layer_transfer_counter.wait_until.assert_called_once_with(7) + assert result is pool.qsa_compressed_k_buffer_pool[1] + + +def test_file_requires_all_sparse_index_pages(tmp_path): + host = QSAPagedHostPool( + (make_index_pool(), make_index_pool(1)), 192, 64, "page_first", pin_memory=False + ) + try: + backend = storage(tmp_path) + backend.register_mem_host_pool_v2(host, PoolName.QSA_INDEXER) + keys = ["first", "second"] + for key in keys: + assert backend.set(key, torch.zeros(32, dtype=torch.uint8)) + transfer = PoolTransfer( + PoolName.QSA_INDEXER, + host_indices=torch.arange(128), + keys=keys, + hit_policy=PoolHitPolicy.ALL_PAGES, + indices_from_pool=PoolName.KV, + ) + assert backend.batch_exists_v2(keys, [transfer]).kv_hit_pages == 0 + expected = torch.arange(64 * host.size_per_token).to(torch.uint8) + host.set_from_flat_data_page(0, expected) + first = PoolTransfer( + PoolName.QSA_INDEXER, host_indices=torch.arange(64), keys=keys[:1] + ) + assert backend.batch_set_v2([first]) == {PoolName.QSA_INDEXER: [True]} + assert backend.batch_exists_v2(keys, [transfer]).kv_hit_pages == 1 + host.set_from_flat_data_page(64, expected.flip(0)) + assert backend.batch_set_v2([transfer]) == {PoolName.QSA_INDEXER: [True, True]} + host.kv_buffer.zero_() + reopened = storage(tmp_path) + reopened.register_mem_host_pool_v2(host, PoolName.QSA_INDEXER) + assert reopened.batch_get_v2([transfer]) == {PoolName.QSA_INDEXER: [True, True]} + assert torch.equal(host.get_data_page(0), expected) + assert torch.equal(host.get_data_page(64), expected.flip(0)) + finally: + host.destroy() + + +def test_mamba_strategy_registers_required_index_and_rejects_missing_draft(monkeypatch): + target, draft = make_index_pool(), make_index_pool(1) + for pool, count in ((target, 2), (draft, 1)): + pool.full_kv_pool = SimpleNamespace(layer_num=count) + target.use_mla = False + params = SimpleNamespace( + page_size=64, + mtp_draft_device_pools=(draft,), + req_to_token_pool=SimpleNamespace( + mamba_map={0: 0, 1: 1, 2: 2, 4: 3, 5: 4, 6: 5}, mamba_pool=object() + ), + ) + group, controller = Mock(), Mock() + build = Mock(return_value=(group, controller)) + monkeypatch.setattr(assembler, "build_hybrid_mamba_stack", build) + result = assembler._MambaStrategy().build( + cache=Mock(), + kvcache=target, + params=params, + server_args=Mock(), + load_cache_event=Mock(), + ) + assert build.call_args.kwargs["qsa_device_pools"] == (target, draft) + assert len(result.sidecars) == 1 + assert result.sidecars[0].pool_name == PoolName.QSA_INDEXER + assert result.sidecars[0].hit_policy == PoolHitPolicy.ALL_PAGES + assert result.sidecars[0].indices_from_pool == PoolName.KV + params.mtp_draft_device_pools = (SimpleNamespace(),) + with pytest.raises(ValueError, match="compressed QSA draft"): + assembler._MambaStrategy().build( + cache=Mock(), + kvcache=target, + params=params, + server_args=Mock(), + load_cache_event=Mock(), + ) + + +@pytest.mark.parametrize("with_draft", [False, True]) +def test_fixed_host_budget_includes_index_and_draft(monkeypatch, with_draft): + target, draft = make_index_pool(), make_index_pool(1) + kv = SimpleNamespace( + size=256, + page_size=64, + layer_num=2, + get_kv_size_bytes=lambda: (320 * 2 * 256, 320 * 2 * 256), + ) + draft.full_kv_pool = SimpleNamespace( + size=256, + page_size=64, + layer_num=1, + get_kv_size_bytes=lambda: (320 * 256, 320 * 256), + ) + state = SimpleNamespace(get_kv_size_bytes=lambda: 320 * 1024) + args = SimpleNamespace( + hicache_size=0.01, + hicache_ratio=2, + hicache_mem_layout="page_first", + hicache_write_policy="write_through", + hicache_io_backend="kernel", + ) + params = SimpleNamespace( + mtp_draft_device_pools=(draft,) if with_draft else (), + req_to_token_pool=SimpleNamespace(mamba_allocator=Mock()), + page_size=64, + token_to_kv_pool_allocator=Mock(), + tp_cache_group=None, + attn_cp_cache_group=None, + attn_tp_cache_group=None, + pp_cache_group=None, + ) + built = {} + + def kv_host(**kwargs): + built["kv_budget"] = kwargs["host_size"] * 1e9 + per_token = 1024 + (512 if with_draft else 0) + size = (int(built["kv_budget"] // per_token) // 64 + 1) * 64 + return SimpleNamespace( + size=size, + logical_size=size, + page_size=64, + layout="page_first", + device="cpu", + size_per_token=per_token, + can_use_write_back_jit=False, + ) + + def state_host(*args, **kwargs): + built["state_budget"] = args[2] * 1e9 + return SimpleNamespace(can_use_write_back_jit=False) + + monkeypatch.setattr(assembler, "build_kv_host_pool", kv_host) + monkeypatch.setattr(assembler, "MambaPoolHost", state_host) + monkeypatch.setattr(assembler, "HybridCacheController", Mock()) + monkeypatch.setattr(assembler, "_get_allocator_type", lambda args: "default") + from sglang.srt.mem_cache import qsa_pool_host as host_module + + monkeypatch.setattr( + host_module, + "QSAPagedHostPool", + lambda *args, **kwargs: QSAPagedHostPool(*args, pin_memory=False, **kwargs), + ) + group, _ = assembler.build_hybrid_mamba_stack( + params=params, + server_args=args, + kv_pool=kv, + mamba_pool=state, + full_layer_mapping={3: 0, 7: 1}, + mamba_layer_mapping={i: i for i in (0, 1, 2, 4, 5, 6)}, + load_cache_event=Mock(), + storage_backend=None, + use_mla=False, + qsa_device_pools=(target, draft) if with_draft else (target,), + ) + index = group.get_pool(PoolName.QSA_INDEXER) + try: + anchor = group.get_pool(PoolName.KV) + actual = ( + anchor.size * (anchor.size_per_token + index.size_per_token) + + built["state_budget"] + ) + assert ( + 10_000_000 + <= actual + <= 10_000_000 + 64 * (anchor.size_per_token + index.size_per_token) + ) + entry = group.entry_map[PoolName.QSA_INDEXER] + assert entry.layer_mapper(3) == 0 and entry.layer_mapper(7) == 1 + assert entry.layer_mapper(8) == (2 if with_draft else None) + finally: + index.destroy() diff --git a/validation/hicache/test_qsa_short_extend.py b/validation/hicache/test_qsa_short_extend.py new file mode 100644 index 0000000..18d61e8 --- /dev/null +++ b/validation/hicache/test_qsa_short_extend.py @@ -0,0 +1,50 @@ +"""Partial compression groups must not gather beyond a short cached extension.""" + +from types import SimpleNamespace + +import pytest +import torch + +from sglang.srt.layers.attention.qsa.qsa_indexer import QSAIndexer +from sglang.srt.layers.attention.qwen_sparse_attn_backend import QwenSparseAttnBackend + + +@pytest.mark.parametrize("rows", [1, 2, 3, 4, 5, 8]) +def test_short_extend_gather_bounds(rows): + ratio = 4 + prefix = 64 + writes, ends, _, members = QwenSparseAttnBackend._qsa_write_plan( + token_slot_table=torch.arange(128).reshape(1, -1), + start_blocks=torch.tensor([prefix // ratio]), + end_blocks=torch.tensor([(prefix + rows) // ratio]), + capacity=rows // ratio + 1, + compress_ratio=ratio, + row_token_starts=torch.tensor([0]), + prefix_lens=torch.tensor([prefix]), + ) + stored = [] + pool = SimpleNamespace(set_qsa_compressed_k_buffer=lambda layer, slots, keys: stored.append(keys)) + metadata = SimpleNamespace( + token_to_kv_pool=pool, + compress_member_rows=members, + is_cuda_graph=False, + write_locs=writes, + compress_group_positions=ends, + extend_rope_matrix=torch.zeros((rows, 3), dtype=torch.int64), + ) + indexer = SimpleNamespace( + compress_ratio=ratio, + layer_id=0, + _use_fused_compress=lambda pool: False, + _rope_from_matrix=lambda values: values, + normalize_compressed_keys=lambda keys, positions: keys, + ) + keys = torch.arange(rows * 8, dtype=torch.float32).reshape(rows, 1, 8) + QSAIndexer.update_key_state_and_compress( + indexer, keys, torch.arange(prefix, prefix + rows), + torch.zeros((3, rows), dtype=torch.int64), metadata, state_stored=True, + ) + assert len(stored) == 1 + valid = writes != 0 + expected = keys[: rows // ratio * ratio].reshape(-1, ratio, 1, 8).mean(1) + torch.testing.assert_close(stored[0][valid], expected) diff --git a/validation/hicache/test_qsa_strided_zero_fill.py b/validation/hicache/test_qsa_strided_zero_fill.py new file mode 100644 index 0000000..9e84228 --- /dev/null +++ b/validation/hicache/test_qsa_strided_zero_fill.py @@ -0,0 +1,192 @@ +"""Regression test for the QSA strided sparse-decode scratch zero-fill. + +Poison the packed scratch with NaN, gather with the strided layout used by +`_forward_trtllm_sparse`, and require that (a) valid rows are copied exactly and +(b) every slot in [valid_count, stride) is zero, so the paged decode kernel can never +multiply masked probabilities into stale NaN/Inf bytes. Also checks the compact +(FA2 fallback) layout is unchanged. Intended for test/registered/kernel/qsa/. +""" + +import sys + +import pytest +import torch + +from sglang.test.ci.ci_register import register_cuda_ci + +register_cuda_ci(est_time=120, stage="base-b-kernel-unit", runner_config="1-gpu-large") + +from sglang.srt.layers.attention.qsa.sparse_attn import ( + qwen_sparse_fa2_cu_seqlens_triton, + qwen_sparse_kv_extraction_compact_triton, +) + + +@pytest.mark.parametrize("dtype", [torch.bfloat16, torch.float8_e4m3fn]) +def test_strided_gather_zero_fills_tail(dtype): + if not torch.cuda.is_available(): + pytest.skip("CUDA required") + torch.manual_seed(0) + device = torch.device("cuda") + batch, topk, page, heads, dim = 3, 2051, 64, 2, 256 + pages_per_row = (topk + page - 1) // page + stride = pages_per_row * page + pool_rows = 8192 + k_pool = torch.randn(pool_rows, heads, dim, device=device, dtype=torch.bfloat16).to( + dtype + ) + v_pool = torch.randn(pool_rows, heads, dim, device=device, dtype=torch.bfloat16).to( + dtype + ) + seq_lens = torch.tensor([733, 109, 2500], device=device, dtype=torch.int32) + req_to_token = ( + torch.randperm(pool_rows, device=device)[: batch * 2600] + .reshape(batch, 2600) + .to(torch.int32) + ) + req_indices = torch.arange(batch, device=device, dtype=torch.int32) + # top-k rows: the first min(seq_len, topk) logical positions, then -1 padding + indices = torch.full((batch, topk), -1, device=device, dtype=torch.int32) + for b in range(batch): + n = min(int(seq_lens[b]), topk) + indices[b, :n] = torch.arange(n, device=device, dtype=torch.int32) + cu_strided = torch.arange(batch + 1, device=device, dtype=torch.int32) * stride + # the scratch is always in the compute dtype (bf16); an FP8 pool is dequantized on the way in + packed_k = torch.full( + (batch * stride, heads, dim), float("nan"), device=device, dtype=torch.bfloat16 + ) + packed_v = packed_k.clone() + + qwen_sparse_kv_extraction_compact_triton( + k_pool, + v_pool, + req_to_token, + req_indices, + indices, + seq_lens, + cu_strided, + packed_k, + packed_v, + batch, + topk, + zero_fill_cols=stride, + ) + pk, pv = ( + packed_k.float().view(batch, stride, heads, dim), + packed_v.float().view(batch, stride, heads, dim), + ) + assert torch.isfinite(pk).all() and torch.isfinite(pv).all() + for b in range(batch): + n = min(int(seq_lens[b]), topk) + slots = req_to_token[b, :n].long() + torch.testing.assert_close(pk[b, :n], k_pool[slots].to(torch.bfloat16).float()) + torch.testing.assert_close(pv[b, :n], v_pool[slots].to(torch.bfloat16).float()) + assert (pk[b, n:] == 0).all() and (pv[b, n:] == 0).all() + + +def test_compact_gather_unchanged(): + if not torch.cuda.is_available(): + pytest.skip("CUDA required") + torch.manual_seed(0) + device = torch.device("cuda") + batch, topk, heads, dim = 2, 2051, 2, 256 + k_pool = torch.randn(4096, heads, dim, device=device, dtype=torch.bfloat16) + v_pool = torch.randn(4096, heads, dim, device=device, dtype=torch.bfloat16) + seq_lens = torch.tensor([300, 50], device=device, dtype=torch.int32) + req_to_token = torch.arange(batch * 512, device=device, dtype=torch.int32).reshape( + batch, 512 + ) + req_indices = torch.arange(batch, device=device, dtype=torch.int32) + indices = torch.full((batch, topk), -1, device=device, dtype=torch.int32) + for b in range(batch): + indices[b, : int(seq_lens[b])] = torch.arange( + int(seq_lens[b]), device=device, dtype=torch.int32 + ) + counts = torch.empty(batch, device=device, dtype=torch.int32) + cu_k = torch.empty(batch + 1, device=device, dtype=torch.int32) + qwen_sparse_fa2_cu_seqlens_triton(seq_lens, indices, counts, cu_k, batch, topk) + assert cu_k.tolist() == [0, 300, 350] + packed_k = torch.full( + (batch * topk, heads, dim), float("nan"), device=device, dtype=torch.bfloat16 + ) + packed_v = packed_k.clone() + qwen_sparse_kv_extraction_compact_triton( + k_pool, + v_pool, + req_to_token, + req_indices, + indices, + seq_lens, + cu_k, + packed_k, + packed_v, + batch, + topk, + ) + torch.testing.assert_close(packed_k[:300], k_pool[req_to_token[0, :300].long()]) + torch.testing.assert_close(packed_k[300:350], k_pool[req_to_token[1, :50].long()]) + # compact layout leaves the region past the packed rows untouched (still NaN) + assert torch.isnan(packed_k[350:]).all() + + +def test_strided_gather_addresses_pool_beyond_int32_elements(): + """Slots past 2^31 / (heads * dim) must be addressed with 64-bit offsets. + + An FP8 KV pool on one GB300 holds ~7.6M tokens for Qwen3.8-Flash-Next (2 kv heads x 256), + so slot indices above 4,194,304 occur in production; int32 element offsets wrap there. + """ + if not torch.cuda.is_available(): + pytest.skip("CUDA required") + if torch.cuda.get_device_properties(0).total_memory < 6 * 1024**3: + pytest.skip("needs ~2.5 GB of device memory") + torch.manual_seed(0) + device = torch.device("cuda") + heads, dim = 2, 256 + threshold = (1 << 31) // (heads * dim) # 4,194,304 + pool_rows = threshold + 4096 + k_pool = torch.zeros( + pool_rows, heads, dim, device=device, dtype=torch.float8_e4m3fn + ) + v_pool = torch.zeros( + pool_rows, heads, dim, device=device, dtype=torch.float8_e4m3fn + ) + hi = torch.arange(threshold + 64, threshold + 64 + 300, device=device) + k_pool[hi] = torch.randn(300, heads, dim, device=device, dtype=torch.bfloat16).to( + torch.float8_e4m3fn + ) + v_pool[hi] = torch.randn(300, heads, dim, device=device, dtype=torch.bfloat16).to( + torch.float8_e4m3fn + ) + batch, topk, page = 1, 2051, 64 + stride = ((topk + page - 1) // page) * page + seq_lens = torch.tensor([300], device=device, dtype=torch.int32) + req_to_token = torch.zeros(batch, 512, device=device, dtype=torch.int32) + req_to_token[0, :300] = hi.to(torch.int32) + indices = torch.full((batch, topk), -1, device=device, dtype=torch.int32) + indices[0, :300] = torch.arange(300, device=device, dtype=torch.int32) + cu_strided = torch.arange(batch + 1, device=device, dtype=torch.int32) * stride + packed_k = torch.full( + (batch * stride, heads, dim), float("nan"), device=device, dtype=torch.bfloat16 + ) + packed_v = packed_k.clone() + qwen_sparse_kv_extraction_compact_triton( + k_pool, + v_pool, + req_to_token, + torch.zeros(1, device=device, dtype=torch.int32), + indices, + seq_lens, + cu_strided, + packed_k, + packed_v, + batch, + topk, + zero_fill_cols=stride, + ) + torch.testing.assert_close(packed_k[:300], k_pool[hi].to(torch.bfloat16)) + torch.testing.assert_close(packed_v[:300], v_pool[hi].to(torch.bfloat16)) + assert (packed_k[300:] == 0).all() and (packed_v[300:] == 0).all() + + +if __name__ == "__main__": + sys.exit(pytest.main([__file__, "-v"])) diff --git a/validation/hicache/validate_router_pdl_gpu.py b/validation/hicache/validate_router_pdl_gpu.py new file mode 100644 index 0000000..a2bb415 --- /dev/null +++ b/validation/hicache/validate_router_pdl_gpu.py @@ -0,0 +1,47 @@ +"""Check compiled dependency ordering and routing against a settled reference.""" +import importlib,json,os,re +from pathlib import Path +import torch +m=importlib.import_module("sglang.kernels.ops.moe.moe_fused_gate") +compiled=[] +original=m._router_triton_kernel.run +def capture(*args,**kwargs): + result=original(*args,**kwargs) + if result is not None:compiled.append(result) + return result +m._router_triton_kernel.run=capture +for scoring in ("softmax","sigmoid"): + torch.manual_seed(321) + scores=torch.randn((32,512),device="cuda",dtype=torch.float32) + bias=torch.randn(512,device="cuda",dtype=torch.float32)*0.01 + weights,ids=m.moe_fused_gate(scores,bias,10,scoring_func=scoring,num_expert_group=2,topk_group=2) + activated=torch.softmax(scores+bias,dim=-1) if scoring=="softmax" else torch.sigmoid(scores) + ranked=activated if scoring=="softmax" else activated+bias + expected_ids=torch.topk(ranked,10,dim=-1).indices + expected_weights=activated.gather(1,expected_ids) + expected_weights=expected_weights/expected_weights.sum(dim=-1,keepdim=True) + torch.testing.assert_close(ids.long(),expected_ids) + torch.testing.assert_close(weights,expected_weights,atol=2e-6,rtol=2e-5) + ptx=compiled[-1].asm["ptx"] + lines=ptx.splitlines() + waits=[i for i,line in enumerate(lines) if "griddepcontrol.wait" in line] + loads=[i for i,line in enumerate(lines) if re.search(r"\bld\.global",line)] + report={"scoring":scoring,"numerics_pass":True,"first_wait":waits[0] if waits else None,"first_global_load":loads[0] if loads else None,"ordering_pass":bool(waits and loads and min(loads)>min(waits))} + print(json.dumps(report),flush=True) + assert report["ordering_pass"], report + output=Path("/out") + if output.exists():(output/(scoring+".ptx")).write_text(ptx) + +# The radix path returns winners in expert-id order. +torch.manual_seed(322) +scores = torch.randn((32, 896), device="cuda", dtype=torch.float32) +bias = torch.randn(896, device="cuda", dtype=torch.float32) * 0.01 +assert m.moe_route_radix.covered(scores, bias, 16) +weights, ids = m.moe_fused_gate(scores, bias, 16, scoring_func="sigmoid") +activated = torch.sigmoid(scores) +expected_ids = torch.topk(activated + bias, 16, dim=-1).indices +torch.testing.assert_close(ids.long().sort(dim=-1).values, expected_ids.sort(dim=-1).values) +expected_weights = activated.gather(1, ids.long()) +expected_weights /= expected_weights.sum(dim=-1, keepdim=True) +torch.testing.assert_close(weights, expected_weights, atol=2e-6, rtol=2e-5) +print(json.dumps({"path": "radix", "numerics_pass": True}), flush=True)