Add files using upload-large-folder tool

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

chat_template.jinja

@@ -0,0 +1,86 @@
+[gMASK]<sop>
+{%- if tools -%}
+<|system|>
+# Tools
+
+You may call one or more functions to assist with the user query.
+
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>
+{% for tool in tools %}
+{{ tool | tojson(ensure_ascii=False) }}
+{% endfor %}
+</tools>
+
+For each function call, output the function name and arguments within the following XML format:
+<tool_call>{function-name}<arg_key>{arg-key-1}</arg_key><arg_value>{arg-value-1}</arg_value><arg_key>{arg-key-2}</arg_key><arg_value>{arg-value-2}</arg_value>...</tool_call>{%- endif -%}
+{%- macro visible_text(content) -%}
+    {%- if content is string -%}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping -%}
+        {%- for item in content -%}
+            {%- if item is mapping and item.type == 'text' -%}
+                {{- item.text }}
+            {%- elif item is string -%}
+                {{- item }}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- else -%}
+        {{- content }}
+    {%- endif -%}
+{%- endmacro -%}
+{%- set ns = namespace(last_user_index=-1) %}
+{%- for m in messages %}
+    {%- if m.role == 'user' %}
+        {%- set ns.last_user_index = loop.index0 -%}
+    {%- endif %}
+{%- endfor %}
+{%- for m in messages -%}
+{%- if m.role == 'user' -%}<|user|>{{ visible_text(m.content) }}
+{%- elif m.role == 'assistant' -%}
+<|assistant|>
+{%- set reasoning_content = '' %}
+{%- set content = visible_text(m.content) %}
+{%- if m.reasoning_content is string %}
+    {%- set reasoning_content = m.reasoning_content %}
+{%- else %}
+    {%- if '</think>' in content %}
+        {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+        {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+    {%- endif %}
+{%- endif %}
+{%- if ((clear_thinking is defined and not clear_thinking) or loop.index0 > ns.last_user_index) and reasoning_content -%}
+{{ '<think>' + reasoning_content.strip() +  '</think>'}}
+{%- else -%}
+{{ '</think>' }}
+{%- endif -%}
+{%- if content.strip() -%}
+{{ content.strip() }}
+{%- endif -%}
+{% if m.tool_calls %}
+{% for tc in m.tool_calls %}
+{%- if tc.function %}
+    {%- set tc = tc.function %}
+{%- endif %}
+{{- '<tool_call>' + tc.name -}}
+{% set _args = tc.arguments %}{% for k, v in _args.items() %}<arg_key>{{ k }}</arg_key><arg_value>{{ v | tojson(ensure_ascii=False) if v is not string else v }}</arg_value>{% endfor %}</tool_call>{% endfor %}
+{% endif %}
+{%- elif m.role == 'tool' -%}
+{%- if m.content is string -%}
+{%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+    {{- '<|observation|>' }}
+{%- endif %}
+{{- '<tool_response>' }}
+{{- m.content }}
+{{- '</tool_response>' }}
+{%- else -%}
+<|observation|>{% for tr in m.content %}
+<tool_response>{{ tr.output if tr.output is defined else tr }}</tool_response>{% endfor -%}
+{% endif -%}
+{%- elif m.role == 'system' -%}
+<|system|>{{ visible_text(m.content) }}
+{%- endif -%}
+{%- endfor -%}
+{%- if add_generation_prompt -%}
+    <|assistant|>{{- '</think>' if (enable_thinking is defined and not enable_thinking) else '<think>' -}}
+{%- endif -%}

config.json

@@ -0,0 +1,863 @@
+{
+  "architectures": [
+    "GlmMoeDsaForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 0,
+  "dtype": "bfloat16",
+  "eos_token_id": [
+    154820,
+    154827,
+    154829
+  ],
+  "ep_size": 1,
+  "first_k_dense_replace": 3,
+  "head_dim": 64,
+  "hidden_act": "silu",
+  "hidden_size": 6144,
+  "index_head_dim": 128,
+  "index_n_heads": 32,
+  "index_topk": 2048,
+  "indexer_rope_interleave": true,
+  "initializer_range": 0.02,
+  "intermediate_size": 12288,
+  "kv_lora_rank": 512,
+  "max_position_embeddings": 202752,
+  "mlp_layer_types": [
+    "dense",
+    "dense",
+    "dense",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse",
+    "sparse"
+  ],
+  "model_type": "glm_moe_dsa",
+  "moe_intermediate_size": 2048,
+  "moe_layer_freq": 1,
+  "n_group": 1,
+  "n_routed_experts": 205,
+  "n_shared_experts": 1,
+  "norm_topk_prob": true,
+  "num_attention_heads": 64,
+  "num_experts_per_tok": 8,
+  "num_hidden_layers": 78,
+  "num_key_value_heads": 64,
+  "num_nextn_predict_layers": 1,
+  "pad_token_id": 154820,
+  "pretraining_tp": 1,
+  "q_lora_rank": 2048,
+  "qk_head_dim": 256,
+  "qk_nope_head_dim": 192,
+  "qk_rope_head_dim": 64,
+  "quantization_config": {
+    "activation_scheme": "dynamic",
+    "dequantize": false,
+    "modules_to_not_convert": [
+      "lm_head",
+      "model.embed_tokens",
+      "model.layers.0.input_layernorm",
+      "model.layers.0.post_attention_layernorm",
+      "model.layers.0.self_attn.indexer.k_norm",
+      "model.layers.0.self_attn.indexer.k_norm.bias",
+      "model.layers.0.self_attn.indexers_proj",
+      "model.layers.0.self_attn.kv_a_layernorm",
+      "model.layers.0.self_attn.q_a_layernorm",
+      "model.layers.1.input_layernorm",
+      "model.layers.1.post_attention_layernorm",
+      "model.layers.1.self_attn.indexer.k_norm",
+      "model.layers.1.self_attn.indexer.k_norm.bias",
+      "model.layers.1.self_attn.indexers_proj",
+      "model.layers.1.self_attn.kv_a_layernorm",
+      "model.layers.1.self_attn.q_a_layernorm",
+      "model.layers.2.input_layernorm",
+      "model.layers.2.post_attention_layernorm",
+      "model.layers.2.self_attn.indexer.k_norm",
+      "model.layers.2.self_attn.indexer.k_norm.bias",
+      "model.layers.2.self_attn.indexers_proj",
+      "model.layers.2.self_attn.kv_a_layernorm",
+      "model.layers.2.self_attn.q_a_layernorm",
+      "model.layers.3.input_layernorm",
+      "model.layers.3.mlp.gate",
+      "model.layers.3.mlp.gate.e_score_correction_bias",
+      "model.layers.3.post_attention_layernorm",
+      "model.layers.3.self_attn.indexer.k_norm",
+      "model.layers.3.self_attn.indexer.k_norm.bias",
+      "model.layers.3.self_attn.indexers_proj",
+      "model.layers.3.self_attn.kv_a_layernorm",
+      "model.layers.3.self_attn.q_a_layernorm",
+      "model.layers.4.input_layernorm",
+      "model.layers.4.mlp.gate",
+      "model.layers.4.mlp.gate.e_score_correction_bias",
+      "model.layers.4.post_attention_layernorm",
+      "model.layers.4.self_attn.indexer.k_norm",
+      "model.layers.4.self_attn.indexer.k_norm.bias",
+      "model.layers.4.self_attn.indexers_proj",
+      "model.layers.4.self_attn.kv_a_layernorm",
+      "model.layers.4.self_attn.q_a_layernorm",
+      "model.layers.5.input_layernorm",
+      "model.layers.5.mlp.gate",
+      "model.layers.5.mlp.gate.e_score_correction_bias",
+      "model.layers.5.post_attention_layernorm",
+      "model.layers.5.self_attn.indexer.k_norm",
+      "model.layers.5.self_attn.indexer.k_norm.bias",
+      "model.layers.5.self_attn.indexers_proj",
+      "model.layers.5.self_attn.kv_a_layernorm",
+      "model.layers.5.self_attn.q_a_layernorm",
+      "model.layers.6.input_layernorm",
+      "model.layers.6.mlp.gate",
+      "model.layers.6.mlp.gate.e_score_correction_bias",
+      "model.layers.6.post_attention_layernorm",
+      "model.layers.6.self_attn.indexer.k_norm",
+      "model.layers.6.self_attn.indexer.k_norm.bias",
+      "model.layers.6.self_attn.indexers_proj",
+      "model.layers.6.self_attn.kv_a_layernorm",
+      "model.layers.6.self_attn.q_a_layernorm",
+      "model.layers.7.input_layernorm",
+      "model.layers.7.mlp.gate",
+      "model.layers.7.mlp.gate.e_score_correction_bias",
+      "model.layers.7.post_attention_layernorm",
+      "model.layers.7.self_attn.indexer.k_norm",
+      "model.layers.7.self_attn.indexer.k_norm.bias",
+      "model.layers.7.self_attn.indexers_proj",
+      "model.layers.7.self_attn.kv_a_layernorm",
+      "model.layers.7.self_attn.q_a_layernorm",
+      "model.layers.8.input_layernorm",
+      "model.layers.8.mlp.gate",
+      "model.layers.8.mlp.gate.e_score_correction_bias",
+      "model.layers.8.post_attention_layernorm",
+      "model.layers.8.self_attn.indexer.k_norm",
+      "model.layers.8.self_attn.indexer.k_norm.bias",
+      "model.layers.8.self_attn.indexers_proj",
+      "model.layers.8.self_attn.kv_a_layernorm",
+      "model.layers.8.self_attn.q_a_layernorm",
+      "model.layers.9.input_layernorm",
+      "model.layers.9.mlp.gate",
+      "model.layers.9.mlp.gate.e_score_correction_bias",
+      "model.layers.9.post_attention_layernorm",
+      "model.layers.9.self_attn.indexer.k_norm",
+      "model.layers.9.self_attn.indexer.k_norm.bias",
+      "model.layers.9.self_attn.indexers_proj",
+      "model.layers.9.self_attn.kv_a_layernorm",
+      "model.layers.9.self_attn.q_a_layernorm",
+      "model.layers.10.input_layernorm",
+      "model.layers.10.mlp.gate",
+      "model.layers.10.mlp.gate.e_score_correction_bias",
+      "model.layers.10.post_attention_layernorm",
+      "model.layers.10.self_attn.indexer.k_norm",
+      "model.layers.10.self_attn.indexer.k_norm.bias",
+      "model.layers.10.self_attn.indexers_proj",
+      "model.layers.10.self_attn.kv_a_layernorm",
+      "model.layers.10.self_attn.q_a_layernorm",
+      "model.layers.11.input_layernorm",
+      "model.layers.11.mlp.gate",
+      "model.layers.11.mlp.gate.e_score_correction_bias",
+      "model.layers.11.post_attention_layernorm",
+      "model.layers.11.self_attn.indexer.k_norm",
+      "model.layers.11.self_attn.indexer.k_norm.bias",
+      "model.layers.11.self_attn.indexers_proj",
+      "model.layers.11.self_attn.kv_a_layernorm",
+      "model.layers.11.self_attn.q_a_layernorm",
+      "model.layers.12.input_layernorm",
+      "model.layers.12.mlp.gate",
+      "model.layers.12.mlp.gate.e_score_correction_bias",
+      "model.layers.12.post_attention_layernorm",
+      "model.layers.12.self_attn.indexer.k_norm",
+      "model.layers.12.self_attn.indexer.k_norm.bias",
+      "model.layers.12.self_attn.indexers_proj",
+      "model.layers.12.self_attn.kv_a_layernorm",
+      "model.layers.12.self_attn.q_a_layernorm",
+      "model.layers.13.input_layernorm",
+      "model.layers.13.mlp.gate",
+      "model.layers.13.mlp.gate.e_score_correction_bias",
+      "model.layers.13.post_attention_layernorm",
+      "model.layers.13.self_attn.indexer.k_norm",
+      "model.layers.13.self_attn.indexer.k_norm.bias",
+      "model.layers.13.self_attn.indexers_proj",
+      "model.layers.13.self_attn.kv_a_layernorm",
+      "model.layers.13.self_attn.q_a_layernorm",
+      "model.layers.14.input_layernorm",
+      "model.layers.14.mlp.gate",
+      "model.layers.14.mlp.gate.e_score_correction_bias",
+      "model.layers.14.post_attention_layernorm",
+      "model.layers.14.self_attn.indexer.k_norm",
+      "model.layers.14.self_attn.indexer.k_norm.bias",
+      "model.layers.14.self_attn.indexers_proj",
+      "model.layers.14.self_attn.kv_a_layernorm",
+      "model.layers.14.self_attn.q_a_layernorm",
+      "model.layers.15.input_layernorm",
+      "model.layers.15.mlp.gate",
+      "model.layers.15.mlp.gate.e_score_correction_bias",
+      "model.layers.15.post_attention_layernorm",
+      "model.layers.15.self_attn.indexer.k_norm",
+      "model.layers.15.self_attn.indexer.k_norm.bias",
+      "model.layers.15.self_attn.indexers_proj",
+      "model.layers.15.self_attn.kv_a_layernorm",
+      "model.layers.15.self_attn.q_a_layernorm",
+      "model.layers.16.input_layernorm",
+      "model.layers.16.mlp.gate",
+      "model.layers.16.mlp.gate.e_score_correction_bias",
+      "model.layers.16.post_attention_layernorm",
+      "model.layers.16.self_attn.indexer.k_norm",
+      "model.layers.16.self_attn.indexer.k_norm.bias",
+      "model.layers.16.self_attn.indexers_proj",
+      "model.layers.16.self_attn.kv_a_layernorm",
+      "model.layers.16.self_attn.q_a_layernorm",
+      "model.layers.17.input_layernorm",
+      "model.layers.17.mlp.gate",
+      "model.layers.17.mlp.gate.e_score_correction_bias",
+      "model.layers.17.post_attention_layernorm",
+      "model.layers.17.self_attn.indexer.k_norm",
+      "model.layers.17.self_attn.indexer.k_norm.bias",
+      "model.layers.17.self_attn.indexers_proj",
+      "model.layers.17.self_attn.kv_a_layernorm",
+      "model.layers.17.self_attn.q_a_layernorm",
+      "model.layers.18.input_layernorm",
+      "model.layers.18.mlp.gate",
+      "model.layers.18.mlp.gate.e_score_correction_bias",
+      "model.layers.18.post_attention_layernorm",
+      "model.layers.18.self_attn.indexer.k_norm",
+      "model.layers.18.self_attn.indexer.k_norm.bias",
+      "model.layers.18.self_attn.indexers_proj",
+      "model.layers.18.self_attn.kv_a_layernorm",
+      "model.layers.18.self_attn.q_a_layernorm",
+      "model.layers.19.input_layernorm",
+      "model.layers.19.mlp.gate",
+      "model.layers.19.mlp.gate.e_score_correction_bias",
+      "model.layers.19.post_attention_layernorm",
+      "model.layers.19.self_attn.indexer.k_norm",
+      "model.layers.19.self_attn.indexer.k_norm.bias",
+      "model.layers.19.self_attn.indexers_proj",
+      "model.layers.19.self_attn.kv_a_layernorm",
+      "model.layers.19.self_attn.q_a_layernorm",
+      "model.layers.20.input_layernorm",
+      "model.layers.20.mlp.gate",
+      "model.layers.20.mlp.gate.e_score_correction_bias",
+      "model.layers.20.post_attention_layernorm",
+      "model.layers.20.self_attn.indexer.k_norm",
+      "model.layers.20.self_attn.indexer.k_norm.bias",
+      "model.layers.20.self_attn.indexers_proj",
+      "model.layers.20.self_attn.kv_a_layernorm",
+      "model.layers.20.self_attn.q_a_layernorm",
+      "model.layers.21.input_layernorm",
+      "model.layers.21.mlp.gate",
+      "model.layers.21.mlp.gate.e_score_correction_bias",
+      "model.layers.21.post_attention_layernorm",
+      "model.layers.21.self_attn.indexer.k_norm",
+      "model.layers.21.self_attn.indexer.k_norm.bias",
+      "model.layers.21.self_attn.indexers_proj",
+      "model.layers.21.self_attn.kv_a_layernorm",
+      "model.layers.21.self_attn.q_a_layernorm",
+      "model.layers.22.input_layernorm",
+      "model.layers.22.mlp.gate",
+      "model.layers.22.mlp.gate.e_score_correction_bias",
+      "model.layers.22.post_attention_layernorm",
+      "model.layers.22.self_attn.indexer.k_norm",
+      "model.layers.22.self_attn.indexer.k_norm.bias",
+      "model.layers.22.self_attn.indexers_proj",
+      "model.layers.22.self_attn.kv_a_layernorm",
+      "model.layers.22.self_attn.q_a_layernorm",
+      "model.layers.23.input_layernorm",
+      "model.layers.23.mlp.gate",
+      "model.layers.23.mlp.gate.e_score_correction_bias",
+      "model.layers.23.post_attention_layernorm",
+      "model.layers.23.self_attn.indexer.k_norm",
+      "model.layers.23.self_attn.indexer.k_norm.bias",
+      "model.layers.23.self_attn.indexers_proj",
+      "model.layers.23.self_attn.kv_a_layernorm",
+      "model.layers.23.self_attn.q_a_layernorm",
+      "model.layers.24.input_layernorm",
+      "model.layers.24.mlp.gate",
+      "model.layers.24.mlp.gate.e_score_correction_bias",
+      "model.layers.24.post_attention_layernorm",
+      "model.layers.24.self_attn.indexer.k_norm",
+      "model.layers.24.self_attn.indexer.k_norm.bias",
+      "model.layers.24.self_attn.indexers_proj",
+      "model.layers.24.self_attn.kv_a_layernorm",
+      "model.layers.24.self_attn.q_a_layernorm",
+      "model.layers.25.input_layernorm",
+      "model.layers.25.mlp.gate",
+      "model.layers.25.mlp.gate.e_score_correction_bias",
+      "model.layers.25.post_attention_layernorm",
+      "model.layers.25.self_attn.indexer.k_norm",
+      "model.layers.25.self_attn.indexer.k_norm.bias",
+      "model.layers.25.self_attn.indexers_proj",
+      "model.layers.25.self_attn.kv_a_layernorm",
+      "model.layers.25.self_attn.q_a_layernorm",
+      "model.layers.26.input_layernorm",
+      "model.layers.26.mlp.gate",
+      "model.layers.26.mlp.gate.e_score_correction_bias",
+      "model.layers.26.post_attention_layernorm",
+      "model.layers.26.self_attn.indexer.k_norm",
+      "model.layers.26.self_attn.indexer.k_norm.bias",
+      "model.layers.26.self_attn.indexers_proj",
+      "model.layers.26.self_attn.kv_a_layernorm",
+      "model.layers.26.self_attn.q_a_layernorm",
+      "model.layers.27.input_layernorm",
+      "model.layers.27.mlp.gate",
+      "model.layers.27.mlp.gate.e_score_correction_bias",
+      "model.layers.27.post_attention_layernorm",
+      "model.layers.27.self_attn.indexer.k_norm",
+      "model.layers.27.self_attn.indexer.k_norm.bias",
+      "model.layers.27.self_attn.indexers_proj",
+      "model.layers.27.self_attn.kv_a_layernorm",
+      "model.layers.27.self_attn.q_a_layernorm",
+      "model.layers.28.input_layernorm",
+      "model.layers.28.mlp.gate",
+      "model.layers.28.mlp.gate.e_score_correction_bias",
+      "model.layers.28.post_attention_layernorm",
+      "model.layers.28.self_attn.indexer.k_norm",
+      "model.layers.28.self_attn.indexer.k_norm.bias",
+      "model.layers.28.self_attn.indexers_proj",
+      "model.layers.28.self_attn.kv_a_layernorm",
+      "model.layers.28.self_attn.q_a_layernorm",
+      "model.layers.29.input_layernorm",
+      "model.layers.29.mlp.gate",
+      "model.layers.29.mlp.gate.e_score_correction_bias",
+      "model.layers.29.post_attention_layernorm",
+      "model.layers.29.self_attn.indexer.k_norm",
+      "model.layers.29.self_attn.indexer.k_norm.bias",
+      "model.layers.29.self_attn.indexers_proj",
+      "model.layers.29.self_attn.kv_a_layernorm",
+      "model.layers.29.self_attn.q_a_layernorm",
+      "model.layers.30.input_layernorm",
+      "model.layers.30.mlp.gate",
+      "model.layers.30.mlp.gate.e_score_correction_bias",
+      "model.layers.30.post_attention_layernorm",
+      "model.layers.30.self_attn.indexer.k_norm",
+      "model.layers.30.self_attn.indexer.k_norm.bias",
+      "model.layers.30.self_attn.indexers_proj",
+      "model.layers.30.self_attn.kv_a_layernorm",
+      "model.layers.30.self_attn.q_a_layernorm",
+      "model.layers.31.input_layernorm",
+      "model.layers.31.mlp.gate",
+      "model.layers.31.mlp.gate.e_score_correction_bias",
+      "model.layers.31.post_attention_layernorm",
+      "model.layers.31.self_attn.indexer.k_norm",
+      "model.layers.31.self_attn.indexer.k_norm.bias",
+      "model.layers.31.self_attn.indexers_proj",
+      "model.layers.31.self_attn.kv_a_layernorm",
+      "model.layers.31.self_attn.q_a_layernorm",
+      "model.layers.32.input_layernorm",
+      "model.layers.32.mlp.gate",
+      "model.layers.32.mlp.gate.e_score_correction_bias",
+      "model.layers.32.post_attention_layernorm",
+      "model.layers.32.self_attn.indexer.k_norm",
+      "model.layers.32.self_attn.indexer.k_norm.bias",
+      "model.layers.32.self_attn.indexers_proj",
+      "model.layers.32.self_attn.kv_a_layernorm",
+      "model.layers.32.self_attn.q_a_layernorm",
+      "model.layers.33.input_layernorm",
+      "model.layers.33.mlp.gate",
+      "model.layers.33.mlp.gate.e_score_correction_bias",
+      "model.layers.33.post_attention_layernorm",
+      "model.layers.33.self_attn.indexer.k_norm",
+      "model.layers.33.self_attn.indexer.k_norm.bias",
+      "model.layers.33.self_attn.indexers_proj",
+      "model.layers.33.self_attn.kv_a_layernorm",
+      "model.layers.33.self_attn.q_a_layernorm",
+      "model.layers.34.input_layernorm",
+      "model.layers.34.mlp.gate",
+      "model.layers.34.mlp.gate.e_score_correction_bias",
+      "model.layers.34.post_attention_layernorm",
+      "model.layers.34.self_attn.indexer.k_norm",
+      "model.layers.34.self_attn.indexer.k_norm.bias",
+      "model.layers.34.self_attn.indexers_proj",
+      "model.layers.34.self_attn.kv_a_layernorm",
+      "model.layers.34.self_attn.q_a_layernorm",
+      "model.layers.35.input_layernorm",
+      "model.layers.35.mlp.gate",
+      "model.layers.35.mlp.gate.e_score_correction_bias",
+      "model.layers.35.post_attention_layernorm",
+      "model.layers.35.self_attn.indexer.k_norm",
+      "model.layers.35.self_attn.indexer.k_norm.bias",
+      "model.layers.35.self_attn.indexers_proj",
+      "model.layers.35.self_attn.kv_a_layernorm",
+      "model.layers.35.self_attn.q_a_layernorm",
+      "model.layers.36.input_layernorm",
+      "model.layers.36.mlp.gate",
+      "model.layers.36.mlp.gate.e_score_correction_bias",
+      "model.layers.36.post_attention_layernorm",
+      "model.layers.36.self_attn.indexer.k_norm",
+      "model.layers.36.self_attn.indexer.k_norm.bias",
+      "model.layers.36.self_attn.indexers_proj",
+      "model.layers.36.self_attn.kv_a_layernorm",
+      "model.layers.36.self_attn.q_a_layernorm",
+      "model.layers.37.input_layernorm",
+      "model.layers.37.mlp.gate",
+      "model.layers.37.mlp.gate.e_score_correction_bias",
+      "model.layers.37.post_attention_layernorm",
+      "model.layers.37.self_attn.indexer.k_norm",
+      "model.layers.37.self_attn.indexer.k_norm.bias",
+      "model.layers.37.self_attn.indexers_proj",
+      "model.layers.37.self_attn.kv_a_layernorm",
+      "model.layers.37.self_attn.q_a_layernorm",
+      "model.layers.38.input_layernorm",
+      "model.layers.38.mlp.gate",
+      "model.layers.38.mlp.gate.e_score_correction_bias",
+      "model.layers.38.post_attention_layernorm",
+      "model.layers.38.self_attn.indexer.k_norm",
+      "model.layers.38.self_attn.indexer.k_norm.bias",
+      "model.layers.38.self_attn.indexers_proj",
+      "model.layers.38.self_attn.kv_a_layernorm",
+      "model.layers.38.self_attn.q_a_layernorm",
+      "model.layers.39.input_layernorm",
+      "model.layers.39.mlp.gate",
+      "model.layers.39.mlp.gate.e_score_correction_bias",
+      "model.layers.39.post_attention_layernorm",
+      "model.layers.39.self_attn.indexer.k_norm",
+      "model.layers.39.self_attn.indexer.k_norm.bias",
+      "model.layers.39.self_attn.indexers_proj",
+      "model.layers.39.self_attn.kv_a_layernorm",
+      "model.layers.39.self_attn.q_a_layernorm",
+      "model.layers.40.input_layernorm",
+      "model.layers.40.mlp.gate",
+      "model.layers.40.mlp.gate.e_score_correction_bias",
+      "model.layers.40.post_attention_layernorm",
+      "model.layers.40.self_attn.indexer.k_norm",
+      "model.layers.40.self_attn.indexer.k_norm.bias",
+      "model.layers.40.self_attn.indexers_proj",
+      "model.layers.40.self_attn.kv_a_layernorm",
+      "model.layers.40.self_attn.q_a_layernorm",
+      "model.layers.41.input_layernorm",
+      "model.layers.41.mlp.gate",
+      "model.layers.41.mlp.gate.e_score_correction_bias",
+      "model.layers.41.post_attention_layernorm",
+      "model.layers.41.self_attn.indexer.k_norm",
+      "model.layers.41.self_attn.indexer.k_norm.bias",
+      "model.layers.41.self_attn.indexers_proj",
+      "model.layers.41.self_attn.kv_a_layernorm",
+      "model.layers.41.self_attn.q_a_layernorm",
+      "model.layers.42.input_layernorm",
+      "model.layers.42.mlp.gate",
+      "model.layers.42.mlp.gate.e_score_correction_bias",
+      "model.layers.42.post_attention_layernorm",
+      "model.layers.42.self_attn.indexer.k_norm",
+      "model.layers.42.self_attn.indexer.k_norm.bias",
+      "model.layers.42.self_attn.indexers_proj",
+      "model.layers.42.self_attn.kv_a_layernorm",
+      "model.layers.42.self_attn.q_a_layernorm",
+      "model.layers.43.input_layernorm",
+      "model.layers.43.mlp.gate",
+      "model.layers.43.mlp.gate.e_score_correction_bias",
+      "model.layers.43.post_attention_layernorm",
+      "model.layers.43.self_attn.indexer.k_norm",
+      "model.layers.43.self_attn.indexer.k_norm.bias",
+      "model.layers.43.self_attn.indexers_proj",
+      "model.layers.43.self_attn.kv_a_layernorm",
+      "model.layers.43.self_attn.q_a_layernorm",
+      "model.layers.44.input_layernorm",
+      "model.layers.44.mlp.gate",
+      "model.layers.44.mlp.gate.e_score_correction_bias",
+      "model.layers.44.post_attention_layernorm",
+      "model.layers.44.self_attn.indexer.k_norm",
+      "model.layers.44.self_attn.indexer.k_norm.bias",
+      "model.layers.44.self_attn.indexers_proj",
+      "model.layers.44.self_attn.kv_a_layernorm",
+      "model.layers.44.self_attn.q_a_layernorm",
+      "model.layers.45.input_layernorm",
+      "model.layers.45.mlp.gate",
+      "model.layers.45.mlp.gate.e_score_correction_bias",
+      "model.layers.45.post_attention_layernorm",
+      "model.layers.45.self_attn.indexer.k_norm",
+      "model.layers.45.self_attn.indexer.k_norm.bias",
+      "model.layers.45.self_attn.indexers_proj",
+      "model.layers.45.self_attn.kv_a_layernorm",
+      "model.layers.45.self_attn.q_a_layernorm",
+      "model.layers.46.input_layernorm",
+      "model.layers.46.mlp.gate",
+      "model.layers.46.mlp.gate.e_score_correction_bias",
+      "model.layers.46.post_attention_layernorm",
+      "model.layers.46.self_attn.indexer.k_norm",
+      "model.layers.46.self_attn.indexer.k_norm.bias",
+      "model.layers.46.self_attn.indexers_proj",
+      "model.layers.46.self_attn.kv_a_layernorm",
+      "model.layers.46.self_attn.q_a_layernorm",
+      "model.layers.47.input_layernorm",
+      "model.layers.47.mlp.gate",
+      "model.layers.47.mlp.gate.e_score_correction_bias",
+      "model.layers.47.post_attention_layernorm",
+      "model.layers.47.self_attn.indexer.k_norm",
+      "model.layers.47.self_attn.indexer.k_norm.bias",
+      "model.layers.47.self_attn.indexers_proj",
+      "model.layers.47.self_attn.kv_a_layernorm",
+      "model.layers.47.self_attn.q_a_layernorm",
+      "model.layers.48.input_layernorm",
+      "model.layers.48.mlp.gate",
+      "model.layers.48.mlp.gate.e_score_correction_bias",
+      "model.layers.48.post_attention_layernorm",
+      "model.layers.48.self_attn.indexer.k_norm",
+      "model.layers.48.self_attn.indexer.k_norm.bias",
+      "model.layers.48.self_attn.indexers_proj",
+      "model.layers.48.self_attn.kv_a_layernorm",
+      "model.layers.48.self_attn.q_a_layernorm",
+      "model.layers.49.input_layernorm",
+      "model.layers.49.mlp.gate",
+      "model.layers.49.mlp.gate.e_score_correction_bias",
+      "model.layers.49.post_attention_layernorm",
+      "model.layers.49.self_attn.indexer.k_norm",
+      "model.layers.49.self_attn.indexer.k_norm.bias",
+      "model.layers.49.self_attn.indexers_proj",
+      "model.layers.49.self_attn.kv_a_layernorm",
+      "model.layers.49.self_attn.q_a_layernorm",
+      "model.layers.50.input_layernorm",
+      "model.layers.50.mlp.gate",
+      "model.layers.50.mlp.gate.e_score_correction_bias",
+      "model.layers.50.post_attention_layernorm",
+      "model.layers.50.self_attn.indexer.k_norm",
+      "model.layers.50.self_attn.indexer.k_norm.bias",
+      "model.layers.50.self_attn.indexers_proj",
+      "model.layers.50.self_attn.kv_a_layernorm",
+      "model.layers.50.self_attn.q_a_layernorm",
+      "model.layers.51.input_layernorm",
+      "model.layers.51.mlp.gate",
+      "model.layers.51.mlp.gate.e_score_correction_bias",
+      "model.layers.51.post_attention_layernorm",
+      "model.layers.51.self_attn.indexer.k_norm",
+      "model.layers.51.self_attn.indexer.k_norm.bias",
+      "model.layers.51.self_attn.indexers_proj",
+      "model.layers.51.self_attn.kv_a_layernorm",
+      "model.layers.51.self_attn.q_a_layernorm",
+      "model.layers.52.input_layernorm",
+      "model.layers.52.mlp.gate",
+      "model.layers.52.mlp.gate.e_score_correction_bias",
+      "model.layers.52.post_attention_layernorm",
+      "model.layers.52.self_attn.indexer.k_norm",
+      "model.layers.52.self_attn.indexer.k_norm.bias",
+      "model.layers.52.self_attn.indexers_proj",
+      "model.layers.52.self_attn.kv_a_layernorm",
+      "model.layers.52.self_attn.q_a_layernorm",
+      "model.layers.53.input_layernorm",
+      "model.layers.53.mlp.gate",
+      "model.layers.53.mlp.gate.e_score_correction_bias",
+      "model.layers.53.post_attention_layernorm",
+      "model.layers.53.self_attn.indexer.k_norm",
+      "model.layers.53.self_attn.indexer.k_norm.bias",
+      "model.layers.53.self_attn.indexers_proj",
+      "model.layers.53.self_attn.kv_a_layernorm",
+      "model.layers.53.self_attn.q_a_layernorm",
+      "model.layers.54.input_layernorm",
+      "model.layers.54.mlp.gate",
+      "model.layers.54.mlp.gate.e_score_correction_bias",
+      "model.layers.54.post_attention_layernorm",
+      "model.layers.54.self_attn.indexer.k_norm",
+      "model.layers.54.self_attn.indexer.k_norm.bias",
+      "model.layers.54.self_attn.indexers_proj",
+      "model.layers.54.self_attn.kv_a_layernorm",
+      "model.layers.54.self_attn.q_a_layernorm",
+      "model.layers.55.input_layernorm",
+      "model.layers.55.mlp.gate",
+      "model.layers.55.mlp.gate.e_score_correction_bias",
+      "model.layers.55.post_attention_layernorm",
+      "model.layers.55.self_attn.indexer.k_norm",
+      "model.layers.55.self_attn.indexer.k_norm.bias",
+      "model.layers.55.self_attn.indexers_proj",
+      "model.layers.55.self_attn.kv_a_layernorm",
+      "model.layers.55.self_attn.q_a_layernorm",
+      "model.layers.56.input_layernorm",
+      "model.layers.56.mlp.gate",
+      "model.layers.56.mlp.gate.e_score_correction_bias",
+      "model.layers.56.post_attention_layernorm",
+      "model.layers.56.self_attn.indexer.k_norm",
+      "model.layers.56.self_attn.indexer.k_norm.bias",
+      "model.layers.56.self_attn.indexers_proj",
+      "model.layers.56.self_attn.kv_a_layernorm",
+      "model.layers.56.self_attn.q_a_layernorm",
+      "model.layers.57.input_layernorm",
+      "model.layers.57.mlp.gate",
+      "model.layers.57.mlp.gate.e_score_correction_bias",
+      "model.layers.57.post_attention_layernorm",
+      "model.layers.57.self_attn.indexer.k_norm",
+      "model.layers.57.self_attn.indexer.k_norm.bias",
+      "model.layers.57.self_attn.indexers_proj",
+      "model.layers.57.self_attn.kv_a_layernorm",
+      "model.layers.57.self_attn.q_a_layernorm",
+      "model.layers.58.input_layernorm",
+      "model.layers.58.mlp.gate",
+      "model.layers.58.mlp.gate.e_score_correction_bias",
+      "model.layers.58.post_attention_layernorm",
+      "model.layers.58.self_attn.indexer.k_norm",
+      "model.layers.58.self_attn.indexer.k_norm.bias",
+      "model.layers.58.self_attn.indexers_proj",
+      "model.layers.58.self_attn.kv_a_layernorm",
+      "model.layers.58.self_attn.q_a_layernorm",
+      "model.layers.59.input_layernorm",
+      "model.layers.59.mlp.gate",
+      "model.layers.59.mlp.gate.e_score_correction_bias",
+      "model.layers.59.post_attention_layernorm",
+      "model.layers.59.self_attn.indexer.k_norm",
+      "model.layers.59.self_attn.indexer.k_norm.bias",
+      "model.layers.59.self_attn.indexers_proj",
+      "model.layers.59.self_attn.kv_a_layernorm",
+      "model.layers.59.self_attn.q_a_layernorm",
+      "model.layers.60.input_layernorm",
+      "model.layers.60.mlp.gate",
+      "model.layers.60.mlp.gate.e_score_correction_bias",
+      "model.layers.60.post_attention_layernorm",
+      "model.layers.60.self_attn.indexer.k_norm",
+      "model.layers.60.self_attn.indexer.k_norm.bias",
+      "model.layers.60.self_attn.indexers_proj",
+      "model.layers.60.self_attn.kv_a_layernorm",
+      "model.layers.60.self_attn.q_a_layernorm",
+      "model.layers.61.input_layernorm",
+      "model.layers.61.mlp.gate",
+      "model.layers.61.mlp.gate.e_score_correction_bias",
+      "model.layers.61.post_attention_layernorm",
+      "model.layers.61.self_attn.indexer.k_norm",
+      "model.layers.61.self_attn.indexer.k_norm.bias",
+      "model.layers.61.self_attn.indexers_proj",
+      "model.layers.61.self_attn.kv_a_layernorm",
+      "model.layers.61.self_attn.q_a_layernorm",
+      "model.layers.62.input_layernorm",
+      "model.layers.62.mlp.gate",
+      "model.layers.62.mlp.gate.e_score_correction_bias",
+      "model.layers.62.post_attention_layernorm",
+      "model.layers.62.self_attn.indexer.k_norm",
+      "model.layers.62.self_attn.indexer.k_norm.bias",
+      "model.layers.62.self_attn.indexers_proj",
+      "model.layers.62.self_attn.kv_a_layernorm",
+      "model.layers.62.self_attn.q_a_layernorm",
+      "model.layers.63.input_layernorm",
+      "model.layers.63.mlp.gate",
+      "model.layers.63.mlp.gate.e_score_correction_bias",
+      "model.layers.63.post_attention_layernorm",
+      "model.layers.63.self_attn.indexer.k_norm",
+      "model.layers.63.self_attn.indexer.k_norm.bias",
+      "model.layers.63.self_attn.indexers_proj",
+      "model.layers.63.self_attn.kv_a_layernorm",
+      "model.layers.63.self_attn.q_a_layernorm",
+      "model.layers.64.input_layernorm",
+      "model.layers.64.mlp.gate",
+      "model.layers.64.mlp.gate.e_score_correction_bias",
+      "model.layers.64.post_attention_layernorm",
+      "model.layers.64.self_attn.indexer.k_norm",
+      "model.layers.64.self_attn.indexer.k_norm.bias",
+      "model.layers.64.self_attn.indexers_proj",
+      "model.layers.64.self_attn.kv_a_layernorm",
+      "model.layers.64.self_attn.q_a_layernorm",
+      "model.layers.65.input_layernorm",
+      "model.layers.65.mlp.gate",
+      "model.layers.65.mlp.gate.e_score_correction_bias",
+      "model.layers.65.post_attention_layernorm",
+      "model.layers.65.self_attn.indexer.k_norm",
+      "model.layers.65.self_attn.indexer.k_norm.bias",
+      "model.layers.65.self_attn.indexers_proj",
+      "model.layers.65.self_attn.kv_a_layernorm",
+      "model.layers.65.self_attn.q_a_layernorm",
+      "model.layers.66.input_layernorm",
+      "model.layers.66.mlp.gate",
+      "model.layers.66.mlp.gate.e_score_correction_bias",
+      "model.layers.66.post_attention_layernorm",
+      "model.layers.66.self_attn.indexer.k_norm",
+      "model.layers.66.self_attn.indexer.k_norm.bias",
+      "model.layers.66.self_attn.indexers_proj",
+      "model.layers.66.self_attn.kv_a_layernorm",
+      "model.layers.66.self_attn.q_a_layernorm",
+      "model.layers.67.input_layernorm",
+      "model.layers.67.mlp.gate",
+      "model.layers.67.mlp.gate.e_score_correction_bias",
+      "model.layers.67.post_attention_layernorm",
+      "model.layers.67.self_attn.indexer.k_norm",
+      "model.layers.67.self_attn.indexer.k_norm.bias",
+      "model.layers.67.self_attn.indexers_proj",
+      "model.layers.67.self_attn.kv_a_layernorm",
+      "model.layers.67.self_attn.q_a_layernorm",
+      "model.layers.68.input_layernorm",
+      "model.layers.68.mlp.gate",
+      "model.layers.68.mlp.gate.e_score_correction_bias",
+      "model.layers.68.post_attention_layernorm",
+      "model.layers.68.self_attn.indexer.k_norm",
+      "model.layers.68.self_attn.indexer.k_norm.bias",
+      "model.layers.68.self_attn.indexers_proj",
+      "model.layers.68.self_attn.kv_a_layernorm",
+      "model.layers.68.self_attn.q_a_layernorm",
+      "model.layers.69.input_layernorm",
+      "model.layers.69.mlp.gate",
+      "model.layers.69.mlp.gate.e_score_correction_bias",
+      "model.layers.69.post_attention_layernorm",
+      "model.layers.69.self_attn.indexer.k_norm",
+      "model.layers.69.self_attn.indexer.k_norm.bias",
+      "model.layers.69.self_attn.indexers_proj",
+      "model.layers.69.self_attn.kv_a_layernorm",
+      "model.layers.69.self_attn.q_a_layernorm",
+      "model.layers.70.input_layernorm",
+      "model.layers.70.mlp.gate",
+      "model.layers.70.mlp.gate.e_score_correction_bias",
+      "model.layers.70.post_attention_layernorm",
+      "model.layers.70.self_attn.indexer.k_norm",
+      "model.layers.70.self_attn.indexer.k_norm.bias",
+      "model.layers.70.self_attn.indexers_proj",
+      "model.layers.70.self_attn.kv_a_layernorm",
+      "model.layers.70.self_attn.q_a_layernorm",
+      "model.layers.71.input_layernorm",
+      "model.layers.71.mlp.gate",
+      "model.layers.71.mlp.gate.e_score_correction_bias",
+      "model.layers.71.post_attention_layernorm",
+      "model.layers.71.self_attn.indexer.k_norm",
+      "model.layers.71.self_attn.indexer.k_norm.bias",
+      "model.layers.71.self_attn.indexers_proj",
+      "model.layers.71.self_attn.kv_a_layernorm",
+      "model.layers.71.self_attn.q_a_layernorm",
+      "model.layers.72.input_layernorm",
+      "model.layers.72.mlp.gate",
+      "model.layers.72.mlp.gate.e_score_correction_bias",
+      "model.layers.72.post_attention_layernorm",
+      "model.layers.72.self_attn.indexer.k_norm",
+      "model.layers.72.self_attn.indexer.k_norm.bias",
+      "model.layers.72.self_attn.indexers_proj",
+      "model.layers.72.self_attn.kv_a_layernorm",
+      "model.layers.72.self_attn.q_a_layernorm",
+      "model.layers.73.input_layernorm",
+      "model.layers.73.mlp.gate",
+      "model.layers.73.mlp.gate.e_score_correction_bias",
+      "model.layers.73.post_attention_layernorm",
+      "model.layers.73.self_attn.indexer.k_norm",
+      "model.layers.73.self_attn.indexer.k_norm.bias",
+      "model.layers.73.self_attn.indexers_proj",
+      "model.layers.73.self_attn.kv_a_layernorm",
+      "model.layers.73.self_attn.q_a_layernorm",
+      "model.layers.74.input_layernorm",
+      "model.layers.74.mlp.gate",
+      "model.layers.74.mlp.gate.e_score_correction_bias",
+      "model.layers.74.post_attention_layernorm",
+      "model.layers.74.self_attn.indexer.k_norm",
+      "model.layers.74.self_attn.indexer.k_norm.bias",
+      "model.layers.74.self_attn.indexers_proj",
+      "model.layers.74.self_attn.kv_a_layernorm",
+      "model.layers.74.self_attn.q_a_layernorm",
+      "model.layers.75.input_layernorm",
+      "model.layers.75.mlp.gate",
+      "model.layers.75.mlp.gate.e_score_correction_bias",
+      "model.layers.75.post_attention_layernorm",
+      "model.layers.75.self_attn.indexer.k_norm",
+      "model.layers.75.self_attn.indexer.k_norm.bias",
+      "model.layers.75.self_attn.indexers_proj",
+      "model.layers.75.self_attn.kv_a_layernorm",
+      "model.layers.75.self_attn.q_a_layernorm",
+      "model.layers.76.input_layernorm",
+      "model.layers.76.mlp.gate",
+      "model.layers.76.mlp.gate.e_score_correction_bias",
+      "model.layers.76.post_attention_layernorm",
+      "model.layers.76.self_attn.indexer.k_norm",
+      "model.layers.76.self_attn.indexer.k_norm.bias",
+      "model.layers.76.self_attn.indexers_proj",
+      "model.layers.76.self_attn.kv_a_layernorm",
+      "model.layers.76.self_attn.q_a_layernorm",
+      "model.layers.77.input_layernorm",
+      "model.layers.77.mlp.gate",
+      "model.layers.77.mlp.gate.e_score_correction_bias",
+      "model.layers.77.post_attention_layernorm",
+      "model.layers.77.self_attn.indexer.k_norm",
+      "model.layers.77.self_attn.indexer.k_norm.bias",
+      "model.layers.77.self_attn.indexers_proj",
+      "model.layers.77.self_attn.kv_a_layernorm",
+      "model.layers.77.self_attn.q_a_layernorm",
+      "model.layers.78.eh_proj",
+      "model.layers.78.enorm",
+      "model.layers.78.hnorm",
+      "model.layers.78.input_layernorm",
+      "model.layers.78.mlp.gate",
+      "model.layers.78.mlp.gate.e_score_correction_bias",
+      "model.layers.78.post_attention_layernorm",
+      "model.layers.78.self_attn.indexer.k_norm",
+      "model.layers.78.self_attn.indexer.k_norm.bias",
+      "model.layers.78.self_attn.indexers_proj",
+      "model.layers.78.self_attn.kv_a_layernorm",
+      "model.layers.78.self_attn.q_a_layernorm",
+      "model.layers.78.shared_head.norm",
+      "model.norm"
+    ],
+    "quant_method": "fp8",
+    "weight_block_size": [
+      128,
+      128
+    ]
+  },
+  "rms_norm_eps": 1e-05,
+  "rope_interleave": true,
+  "rope_parameters": {
+    "rope_theta": 1000000,
+    "rope_type": "default"
+  },
+  "routed_scaling_factor": 2.5,
+  "scoring_func": "sigmoid",
+  "tie_word_embeddings": false,
+  "topk_group": 1,
+  "topk_method": "noaux_tc",
+  "transformers_version": "5.3.0",
+  "use_cache": true,
+  "v_head_dim": 256,
+  "vocab_size": 154880
+}

generation_config.json

@@ -0,0 +1,13 @@
+{
+  "_from_model_config": true,
+  "do_sample": true,
+  "eos_token_id": [
+    154820,
+    154827,
+    154829
+  ],
+  "pad_token_id": 154820,
+  "temperature": 1.0,
+  "top_p": 0.95,
+  "transformers_version": "5.3.0"
+}

glm47_moe_tool_parser_fixed.py

@@ -0,0 +1,532 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""
+GLM-4 Tool Call Parser with incremental string streaming support.
+
+This parser fixes the streaming issue reported in Issue #32829 where long string
+parameters (e.g., file content with 4000+ characters of code) are buffered until
+complete, causing multi-second delays before the user sees any content.
+
+The fix streams string values incrementally as they arrive, providing a true
+streaming experience for long content.
+"""
+
+import ast
+import json
+from collections.abc import Sequence
+from typing import Any
+
+import regex as re
+
+from vllm.entrypoints.chat_utils import make_tool_call_id
+from vllm.entrypoints.openai.chat_completion.protocol import (
+    ChatCompletionRequest,
+    ChatCompletionToolsParam,
+)
+from vllm.entrypoints.openai.engine.protocol import (
+    DeltaFunctionCall,
+    DeltaMessage,
+    DeltaToolCall,
+    ExtractedToolCallInformation,
+    FunctionCall,
+    ToolCall,
+)
+from vllm.logger import init_logger
+from vllm.tokenizers import TokenizerLike
+from vllm.tool_parsers.abstract_tool_parser import (
+    ToolParser,
+    ToolParserManager,
+)
+
+logger = init_logger(__name__)
+
+
+@ToolParserManager.register_module("glm47_fixed")
+class Glm47MoeModelToolParser(ToolParser):
+    """Tool parser for GLM-4 models with incremental string streaming.
+
+    This parser emits tool-call deltas incrementally as arguments arrive.
+    For string-type parameters, content is streamed character-by-character
+    rather than waiting for the complete </arg_value> tag.
+    """
+
+    def __init__(self, tokenizer: TokenizerLike):
+        super().__init__(tokenizer)
+        # Stateful streaming fields
+        self.current_tool_name_sent: bool = False
+        self.prev_tool_call_arr: list[dict[str, Any]] = []
+        self.current_tool_id: int = -1
+        self.streamed_args_for_tool: list[str] = []
+
+        self.tool_call_start_token: str = "<tool_call>"
+        self.tool_call_end_token: str = "</tool_call>"
+        self.arg_key_start: str = "<arg_key>"
+        self.arg_key_end: str = "</arg_key>"
+        self.arg_val_start: str = "<arg_value>"
+        self.arg_val_end: str = "</arg_value>"
+
+        self.tool_calls_start_token = self.tool_call_start_token
+
+        self.func_call_regex = re.compile(r"<tool_call>.*?</tool_call>", re.DOTALL)
+
+        # GLM-4.7 format: <tool_call>func_name[<arg_key>...]*</tool_call>
+        # The function name can be followed by a newline, whitespace, or
+        # directly by <arg_key> tags (no separator).  The arg section is
+        # optional so that zero-argument calls are supported.
+        self.func_detail_regex = re.compile(
+            r"<tool_call>\s*(\S+?)\s*(<arg_key>.*)?</tool_call>", re.DOTALL
+        )
+        self.func_arg_regex = re.compile(
+            r"<arg_key>(.*?)</arg_key>\s*<arg_value>(.*?)</arg_value>",
+            re.DOTALL,
+        )
+
+        if not self.model_tokenizer:
+            raise ValueError(
+                "The model tokenizer must be passed to the ToolParser "
+                "constructor during construction."
+            )
+
+        self.tool_call_start_token_id = self.vocab.get(self.tool_call_start_token)
+        self.tool_call_end_token_id = self.vocab.get(self.tool_call_end_token)
+        self._buffer: str = ""
+
+        # Streaming state for incremental tool-call streaming
+        self._in_tool_call: bool = False
+        self._current_tool_name: str | None = None
+        self._pending_key: str | None = None
+        self._streaming_string_value: bool = False
+        self._tool_call_ids: list[str] = []
+        self._args_started: list[bool] = []
+        self._args_closed: list[bool] = []
+        self._seen_keys: list[set[str]] = []
+
+    @staticmethod
+    def _deserialize(value: str) -> Any:
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            pass
+
+        try:
+            return ast.literal_eval(value)
+        except (ValueError, SyntaxError):
+            pass
+
+        return value
+
+    @staticmethod
+    def _json_escape_string_content(s: str) -> str:
+        """JSON-escape string content for incremental streaming.
+
+        This escapes the content that goes INSIDE a JSON string (between quotes),
+        not including the surrounding quotes themselves.
+        """
+        if not s:
+            return ""
+        return json.dumps(s, ensure_ascii=False)[1:-1]
+
+    @staticmethod
+    def _is_string_type(
+        tool_name: str,
+        arg_name: str,
+        tools: list[ChatCompletionToolsParam] | None,
+    ) -> bool:
+        if tools is None:
+            return False
+        for tool in tools:
+            if tool.function.name != tool_name:
+                continue
+            if tool.function.parameters is None:
+                return False
+            arg_type = (
+                tool.function.parameters.get("properties", {})
+                .get(arg_name, {})
+                .get("type", None)
+            )
+            return arg_type == "string"
+        logger.debug("No tool named '%s'.", tool_name)
+        return False
+
+    @staticmethod
+    def _tools_enabled(request: ChatCompletionRequest) -> bool:
+        """Return whether tool parsing should be applied for this request."""
+        try:
+            tools = getattr(request, "tools", None)
+            tool_choice = getattr(request, "tool_choice", None)
+            return bool(tools) and tool_choice != "none"
+        except Exception:
+            logger.exception("Failed to determine if tools are enabled.")
+            return False
+
+    def adjust_request(self, request: ChatCompletionRequest) -> ChatCompletionRequest:
+        """Adjust request parameters for tool call token handling."""
+        request = super().adjust_request(request)
+        if request.tools and request.tool_choice != "none":
+            # Ensure tool call tokens (<tool_call>, </tool_call>) are not skipped
+            # during decoding. Even though they are not marked as special tokens,
+            # setting skip_special_tokens=False ensures proper handling in
+            # transformers 5.x where decoding behavior may have changed.
+            request.skip_special_tokens = False
+        return request
+
+    def extract_tool_calls(
+        self,
+        model_output: str,
+        request: ChatCompletionRequest,
+    ) -> ExtractedToolCallInformation:
+        matched_tool_calls = self.func_call_regex.findall(model_output)
+        logger.debug("model_output: %s", model_output)
+        try:
+            tool_calls: list[ToolCall] = []
+            for match in matched_tool_calls:
+                tc_detail = self.func_detail_regex.search(match)
+                if not tc_detail:
+                    logger.warning(
+                        "Failed to parse tool call details from: %s",
+                        match,
+                    )
+                    continue
+                tc_name = tc_detail.group(1).strip()
+                tc_args = tc_detail.group(2)
+                pairs = self.func_arg_regex.findall(tc_args) if tc_args else []
+                arg_dct: dict[str, Any] = {}
+                for key, value in pairs:
+                    arg_key = key.strip()
+                    arg_val = value.strip()
+                    if not self._is_string_type(tc_name, arg_key, request.tools):
+                        arg_val = self._deserialize(arg_val)
+                    logger.debug("arg_key = %s, arg_val = %s", arg_key, arg_val)
+                    arg_dct[arg_key] = arg_val
+                tool_calls.append(
+                    ToolCall(
+                        type="function",
+                        function=FunctionCall(
+                            name=tc_name,
+                            arguments=json.dumps(arg_dct, ensure_ascii=False),
+                        ),
+                    )
+                )
+        except Exception:
+            logger.exception("Failed to extract tool call spec")
+            return ExtractedToolCallInformation(
+                tools_called=False, tool_calls=[], content=model_output
+            )
+        else:
+            if len(tool_calls) > 0:
+                content: str | None = model_output[
+                    : model_output.find(self.tool_calls_start_token)
+                ]
+                # Normalize empty/whitespace-only content to None
+                if not content or not content.strip():
+                    content = None
+                return ExtractedToolCallInformation(
+                    tools_called=True, tool_calls=tool_calls, content=content
+                )
+            return ExtractedToolCallInformation(
+                tools_called=False, tool_calls=[], content=model_output
+            )
+
+    def extract_tool_calls_streaming(
+        self,
+        previous_text: str,
+        current_text: str,
+        delta_text: str,
+        previous_token_ids: Sequence[int],
+        current_token_ids: Sequence[int],
+        delta_token_ids: Sequence[int],
+        request: ChatCompletionRequest,
+    ) -> DeltaMessage | None:
+        if not self._tools_enabled(request):
+            return DeltaMessage(content=delta_text) if delta_text else None
+
+        self._buffer += delta_text
+
+        while True:
+            if not self._in_tool_call:
+                start_idx = self._buffer.find(self.tool_call_start_token)
+                if start_idx == -1:
+                    # Check for partial start token at end of buffer
+                    for i in range(1, len(self.tool_call_start_token)):
+                        if self._buffer.endswith(self.tool_call_start_token[:i]):
+                            out = self._buffer[:-i]
+                            self._buffer = self._buffer[-i:]
+                            return DeltaMessage(content=out) if out else None
+                    out = self._buffer
+                    self._buffer = ""
+                    return DeltaMessage(content=out) if out else None
+
+                if start_idx > 0:
+                    out = self._buffer[:start_idx]
+                    self._buffer = self._buffer[start_idx:]
+                    return DeltaMessage(content=out) if out else None
+
+                self._buffer = self._buffer[len(self.tool_call_start_token) :]
+                self._begin_tool_call()
+                continue
+
+            # Parse tool name first
+            if not self.current_tool_name_sent:
+                nl = self._buffer.find("\n")
+                ak = self._buffer.find(self.arg_key_start)
+                end = self._buffer.find(self.tool_call_end_token)
+                candidates = [i for i in [nl, ak, end] if i != -1]
+                if not candidates:
+                    return None
+                cut = min(candidates)
+                tool_name = self._buffer[:cut].strip()
+                if tool_name == "" and cut == end:
+                    # Handle empty tool call like `<tool_call></tool_call>`.
+                    # Consume the tokens and reset state to avoid infinite loop.
+                    self._buffer = self._buffer[end + len(self.tool_call_end_token) :]
+                    self._finish_tool_call()
+                    self._revert_last_tool_call_state()
+                    continue
+
+                if cut == nl:
+                    self._buffer = self._buffer[nl + 1 :]
+                else:
+                    self._buffer = self._buffer[cut:]
+
+                self._current_tool_name = tool_name
+                self.current_tool_name_sent = True
+                return self._emit_tool_name_delta(tool_name)
+
+            assert self._current_tool_name is not None
+
+            # Handle incremental string value streaming
+            if self._streaming_string_value:
+                val_end = self._buffer.find(self.arg_val_end)
+                if val_end != -1:
+                    raw_content = self._buffer[:val_end]
+                    self._buffer = self._buffer[val_end + len(self.arg_val_end) :]
+                    self._streaming_string_value = False
+                    self._pending_key = None
+
+                    escaped = self._json_escape_string_content(raw_content)
+                    frag = escaped + '"'
+                    self.streamed_args_for_tool[self.current_tool_id] += frag
+                    return self._emit_tool_args_delta(frag)
+                else:
+                    # Check for partial </arg_value> at end
+                    safe_len = len(self._buffer)
+                    for i in range(1, len(self.arg_val_end)):
+                        if self._buffer.endswith(self.arg_val_end[:i]):
+                            safe_len = len(self._buffer) - i
+                            break
+
+                    if safe_len > 0:
+                        to_emit = self._buffer[:safe_len]
+                        self._buffer = self._buffer[safe_len:]
+                        escaped = self._json_escape_string_content(to_emit)
+                        if escaped:
+                            self.streamed_args_for_tool[self.current_tool_id] += escaped
+                            return self._emit_tool_args_delta(escaped)
+                    return None
+
+            # If we have a pending key, parse its value
+            if self._pending_key is not None:
+                val_pos = self._buffer.find(self.arg_val_start)
+                if val_pos == -1:
+                    return None
+                if val_pos > 0:
+                    self._buffer = self._buffer[val_pos:]
+
+                key = (self._pending_key or "").strip()
+
+                is_string = self._is_string_type(
+                    self._current_tool_name, key, request.tools
+                )
+
+                if is_string:
+                    # String type: stream incrementally
+                    self._buffer = self._buffer[len(self.arg_val_start) :]
+
+                    if key in self._seen_keys[self.current_tool_id]:
+                        self._pending_key = None
+                        continue
+
+                    self._seen_keys[self.current_tool_id].add(key)
+                    key_json = json.dumps(key, ensure_ascii=False)
+
+                    if not self._args_started[self.current_tool_id]:
+                        frag = "{" + key_json + ': "'
+                        self._args_started[self.current_tool_id] = True
+                    else:
+                        frag = ", " + key_json + ': "'
+
+                    self.streamed_args_for_tool[self.current_tool_id] += frag
+                    self._streaming_string_value = True
+                    return self._emit_tool_args_delta(frag)
+                else:
+                    # Non-string type: wait for complete value
+                    val_end = self._buffer.find(self.arg_val_end)
+                    if val_end == -1:
+                        return None
+
+                    raw_val = self._buffer[len(self.arg_val_start) : val_end].strip()
+                    self._buffer = self._buffer[val_end + len(self.arg_val_end) :]
+                    self._pending_key = None
+
+                    frag_or_none = self._append_arg_fragment(key=key, raw_val=raw_val)
+                    if frag_or_none:
+                        return self._emit_tool_args_delta(frag_or_none)
+                    continue
+
+            # Parse next arg or close
+            end_pos = self._buffer.find(self.tool_call_end_token)
+            key_pos = self._buffer.find(self.arg_key_start)
+            if end_pos != -1 and (key_pos == -1 or end_pos < key_pos):
+                self._buffer = self._buffer[end_pos + len(self.tool_call_end_token) :]
+                frag_or_none = self._close_args_if_needed()
+                # Finalize prev_tool_call_arr with complete parsed arguments
+                if self._current_tool_name:
+                    try:
+                        full_args_str = self.streamed_args_for_tool[
+                            self.current_tool_id
+                        ]
+                        json.loads(full_args_str)
+                        self.prev_tool_call_arr[self.current_tool_id] = {
+                            "name": self._current_tool_name,
+                            "arguments": full_args_str,
+                        }
+                    except (json.JSONDecodeError, IndexError) as e:
+                        logger.warning(
+                            "Failed to finalize tool call state for tool %d: %s",
+                            self.current_tool_id,
+                            e,
+                        )
+                self._finish_tool_call()
+                return (
+                    self._emit_tool_args_delta(frag_or_none) if frag_or_none else None
+                )
+
+            if key_pos == -1:
+                return None
+            if key_pos > 0:
+                self._buffer = self._buffer[key_pos:]
+            key_end = self._buffer.find(self.arg_key_end)
+            if key_end == -1:
+                return None
+            key = self._buffer[len(self.arg_key_start) : key_end]
+            self._buffer = self._buffer[key_end + len(self.arg_key_end) :]
+            self._pending_key = key
+            continue
+
+    def _ensure_tool_state(self) -> None:
+        while len(self._tool_call_ids) <= self.current_tool_id:
+            self._tool_call_ids.append(
+                make_tool_call_id(id_type="random", func_name=None, idx=None)
+            )
+        while len(self.streamed_args_for_tool) <= self.current_tool_id:
+            self.streamed_args_for_tool.append("")
+        while len(self.prev_tool_call_arr) <= self.current_tool_id:
+            self.prev_tool_call_arr.append({})
+        while len(self._args_started) <= self.current_tool_id:
+            self._args_started.append(False)
+        while len(self._args_closed) <= self.current_tool_id:
+            self._args_closed.append(False)
+        while len(self._seen_keys) <= self.current_tool_id:
+            self._seen_keys.append(set())
+
+    def _begin_tool_call(self) -> None:
+        if self.current_tool_id == -1:
+            self.current_tool_id = 0
+        else:
+            self.current_tool_id += 1
+        self._ensure_tool_state()
+        self.current_tool_name_sent = False
+        self._current_tool_name = None
+        self._pending_key = None
+        self._streaming_string_value = False
+        self._in_tool_call = True
+
+    def _finish_tool_call(self) -> None:
+        self._in_tool_call = False
+        self._current_tool_name = None
+        self._pending_key = None
+        self._streaming_string_value = False
+
+    def _revert_last_tool_call_state(self) -> None:
+        """Revert the state allocation for the last tool call."""
+        if self.current_tool_id < 0:
+            return
+        self._tool_call_ids.pop()
+        self.streamed_args_for_tool.pop()
+        self.prev_tool_call_arr.pop()
+        self._args_started.pop()
+        self._args_closed.pop()
+        self._seen_keys.pop()
+        self.current_tool_id -= 1
+
+    def _emit_tool_name_delta(self, tool_name: str) -> DeltaMessage:
+        self.prev_tool_call_arr[self.current_tool_id] = {
+            "name": self._current_tool_name,
+            "arguments": {},
+        }
+        return DeltaMessage(
+            tool_calls=[
+                DeltaToolCall(
+                    index=self.current_tool_id,
+                    id=self._tool_call_ids[self.current_tool_id],
+                    type="function",
+                    function=DeltaFunctionCall(
+                        name=tool_name,
+                        arguments="",
+                    ).model_dump(exclude_none=True),
+                )
+            ]
+        )
+
+    def _emit_tool_args_delta(self, fragment: str) -> DeltaMessage:
+        return DeltaMessage(
+            tool_calls=[
+                DeltaToolCall(
+                    index=self.current_tool_id,
+                    function=DeltaFunctionCall(arguments=fragment).model_dump(
+                        exclude_none=True
+                    ),
+                )
+            ]
+        )
+
+    def _append_arg_fragment(
+        self,
+        *,
+        key: str,
+        raw_val: str,
+    ) -> str | None:
+        key = key.strip()
+        if not key:
+            return None
+        if key in self._seen_keys[self.current_tool_id]:
+            return None
+
+        # This function is only called for non-string types (already checked
+        # by _is_string_type in the caller), so we always deserialize.
+        val_obj: Any = self._deserialize(raw_val)
+
+        key_json = json.dumps(key, ensure_ascii=False)
+        val_json = json.dumps(val_obj, ensure_ascii=False)
+
+        if not self._args_started[self.current_tool_id]:
+            fragment = "{" + key_json + ": " + val_json
+            self._args_started[self.current_tool_id] = True
+        else:
+            fragment = "," + key_json + ": " + val_json
+
+        self._seen_keys[self.current_tool_id].add(key)
+        self.streamed_args_for_tool[self.current_tool_id] += fragment
+        return fragment
+
+    def _close_args_if_needed(self) -> str | None:
+        if self._args_closed[self.current_tool_id]:
+            return None
+        self._args_closed[self.current_tool_id] = True
+        if not self._args_started[self.current_tool_id]:
+            fragment = "{}"
+            self.streamed_args_for_tool[self.current_tool_id] = fragment
+        else:
+            fragment = "}"
+            self.streamed_args_for_tool[self.current_tool_id] += fragment
+        return fragment

model-00001-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d67f736c2d433b523a825f857ad90cca0b81511b2f0e9de91144218f98c0132
+size 47367547764

model-00002-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e2ae8a76210e0f3a6c74fc5cd7e7a8834730f8fb457b5da46da1ce585ef362a
+size 47732873272

model-00003-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cae935a4bbb5a5077a4b5203aadc02b650d876511f5bf1a251e357d8abc122a4
+size 47732875376

model-00004-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da6231e47371a3e3856ce4700c4b8958dfd319b43500a5621bd5db1004574407
+size 47732875376

model-00005-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81b2e096ff8ef8b0c907ab0dace47cb57b0a3be5df1556a9ceb2b22f2d766b9a
+size 47732875376

model-00006-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e12b005d6cf44cf749ee2ba598a87f9d96aedf65041672d47d6635e06b4cd1c
+size 47732875376

model-00007-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e33ecd6d3871528a51adbc78fd1a2221d79d45166205e4be50b724a9d46edc98
+size 47732875376

model-00008-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c26a2c5d5a5335facbaefe87ad8897d1a17e7fdaf295946d8f3c2938f958f97
+size 47732875376

model-00009-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44321b7925cc2ae93abbe9e1044036d035fbf682a340b589a8360b8260cfce0b
+size 47732875376

model-00010-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0c33581cf145e50971e0cbc38f4c6f89959bd75dac96770ee09048f08e3a44a
+size 47732875376

model-00011-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41d25cd7ab407104d523a333b452f3c8315f13fb6fe0a710c09e1a5b26e964fa
+size 47732875376

model-00012-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35bfdddae8ee0e9b1b5ddf8def3fed5b30ab1347152c637e56c43b32ba81f843
+size 47732875376

model-00013-of-00013.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec56df6455404445f651ae0cdec399820be3e3fc094caa566ced0fbb8072e9d2
+size 29241735984

model-mtp-layer78-pruned.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c615ce6c859e9803d0338078a5e390a56758131372292646f58bf281d1bf0be7
+size 8106509596

reap_args.yaml

@@ -0,0 +1,77 @@
+cluster_args:
+  cluster_description: null
+  cluster_method: agglomerative
+  compression_ratio: 0.2
+  expert_sim: ttm
+  frequency_penalty: true
+  linkage_method: average
+  max_cluster_size: null
+  multi_layer: null
+  num_clusters: null
+  singleton_outlier_experts: false
+  singleton_super_experts: false
+  softmax_temperature: null
+ds_args:
+  dataset_config_name: null
+  dataset_name: theblackcat102/evol-codealpaca-v1:128,Salesforce/xlam-function-calling-60k:128,open-r1/Mixture-of-Thoughts[code]:128,open-r1/Mixture-of-Thoughts[math]:128,open-r1/Mixture-of-Thoughts[science]:128,SWE-bench/SWE-smith-trajectories(tool):128
+  dataset_test_split: test
+  shuffle: true
+  split: train
+eval_args:
+  evalplus_tasks:
+  - mbpp
+  - humaneval
+  greedy: true
+  lm_eval_tasks:
+  - winogrande
+  - arc_challenge
+  - arc_easy
+  - boolq
+  - hellaswag
+  - mmlu
+  - openbookqa
+  - rte
+  min_p: 0.0
+  parallel_tasks: 32
+  results_dir: null
+  run_evalplus: true
+  run_livecodebench: true
+  run_lm_eval: true
+  run_math: false
+  run_wildbench: false
+  server_log_file_name: pruning-cli-0.log
+  temperature: 0.7
+  top_k: 20
+  top_p: 0.8
+  use_server: true
+  vllm_port: 8000
+model_args:
+  model_name: /models/GLM-5-FP8
+  num_experts_per_tok_override: null
+obs_args:
+  batch_size: 1
+  distance_measure: cosine
+  model_max_length: 2048
+  output_file_name: observations_2_cosine-seed_42.pt
+  overwrite_observations: false
+  record_pruning_metrics_only: true
+  renormalize_router_weights: true
+  return_vllm_tokens_prompt: false
+  samples_per_category: 2
+  select_only_categories: null
+  split_by_category: false
+  truncate: false
+prune_args:
+  n_experts_to_prune: null
+  overwrite_pruned_model: false
+  perserve_outliers: false
+  perserve_super_experts: false
+  prune_method: reap
+reap_args:
+  debug: false
+  do_eval: false
+  plot_clusters: true
+  profile: false
+  run_observer_only: false
+  seed: 42
+  smoke_test: true

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19e773648cb4e65de8660ea6365e10acca112d42a854923df93db4a6f333a82d
+size 20217442

tokenizer_config.json

@@ -0,0 +1,33 @@
+{
+  "backend": "tokenizers",
+  "clean_up_tokenization_spaces": false,
+  "do_lower_case": false,
+  "eos_token": "<|endoftext|>",
+  "extra_special_tokens": [
+    "<|endoftext|>",
+    "[MASK]",
+    "[gMASK]",
+    "[sMASK]",
+    "<sop>",
+    "<eop>",
+    "<|system|>",
+    "<|user|>",
+    "<|assistant|>",
+    "<|observation|>",
+    "<|begin_of_image|>",
+    "<|end_of_image|>",
+    "<|begin_of_video|>",
+    "<|end_of_video|>",
+    "<|begin_of_audio|>",
+    "<|end_of_audio|>",
+    "<|begin_of_transcription|>",
+    "<|end_of_transcription|>"
+  ],
+  "is_local": true,
+  "model_max_length": 202752,
+  "model_specific_special_tokens": {},
+  "pad_token": "<|endoftext|>",
+  "padding_side": "left",
+  "remove_space": false,
+  "tokenizer_class": "TokenizersBackend"
+}