Upload folder using huggingface_hub

.meta/create_model.py

@@ -0,0 +1,168 @@
+def create_model(source_model_id: str, source_revision: str, save_folder: str) -> str:
+    import json
+    import os
+    from pathlib import Path
+
+    import torch
+    from huggingface_hub import hf_hub_download
+    from safetensors.torch import save_file
+
+    folder = Path(save_folder)
+    folder.mkdir(parents=True, exist_ok=True)
+    for name in (
+        "tokenizer.json",
+        "tokenizer_config.json",
+        "special_tokens_map.json",
+        "generation_config.json",
+        "LICENSE",
+    ):
+        (folder / name).write_bytes(Path(hf_hub_download(source_model_id, name, revision=source_revision)).read_bytes())
+
+    config = json.loads(Path(hf_hub_download(source_model_id, "config.json", revision=source_revision)).read_text())
+    # Internal-only geometry; task vocabulary, token ids, attention method and all LSA/MTP schedules are fixed.
+    # LONGCAT_TINY_NUM_HEADS lets the same generator emit a TP=1 evidence variant (full 32-head attention
+    # fan-out; indexer, MoE and embedding tensors are TP-neutral and stay byte-identical).
+    # LONGCAT_TINY_NUM_LAYERS sets the logical layer count (the TP=1 indexer-topk evidence model needs
+    # 8 logical layers so its 16 physical attention sublayers match the TP=4 checkpoint's 8).
+    tiny_heads = int(os.environ.get("LONGCAT_TINY_NUM_HEADS", "8"))
+    tiny_layers = int(os.environ.get("LONGCAT_TINY_NUM_LAYERS", "4"))
+    config.update(
+        num_layers=tiny_layers,
+        hidden_size=8,
+        ffn_hidden_size=64,
+        expert_ffn_hidden_size=32,
+        num_attention_heads=tiny_heads,
+        kv_lora_rank=256,
+        q_lora_rank=32,
+        qk_nope_head_dim=64,
+        qk_rope_head_dim=64,
+        v_head_dim=128,
+        n_routed_experts=32,
+        zero_expert_num=128,
+        moe_topk=12,
+        oe_vocab_size_ratio=4,
+        oe_neighbor_num=2,
+        oe_split_num=2,
+    )
+    # LongCat has two attention sublayers per logical layer (physical ids 0..2*num_layers-1).
+    # The DSA indexer-topk capturer defaults to num_hidden_layers slots; expose the real
+    # physical attention-sublayer count so the return_indexer_topk buffer is sized correctly.
+    config["num_indexer_layers"] = 2 * config["num_layers"]
+    # The published checkpoint ships one draft layer regardless of mtp_num_layers; keep its runtime schedule field.
+    (folder / "config.json").write_text(json.dumps(config, indent=2) + "\n")
+
+    hidden = config["hidden_size"]
+    ffn = config["ffn_hidden_size"]
+    expert_ffn = config["expert_ffn_hidden_size"]
+    num_layers = config["num_layers"]
+    num_heads = config["num_attention_heads"]
+    q_lora = config["q_lora_rank"]
+    kv_lora = config["kv_lora_rank"]
+    nope = config["qk_nope_head_dim"]
+    rope = config["qk_rope_head_dim"]
+    value = config["v_head_dim"]
+    n_routed = config["n_routed_experts"]
+    n_zero = config["zero_expert_num"]
+    index_heads = config["index_n_heads"]
+    index_head_dim = config["index_head_dim"]
+    vocab = config["vocab_size"]
+    qk = nope + rope
+
+    torch.manual_seed(42)
+
+    def weight(shape, dtype=torch.bfloat16):
+        return (torch.randn(*shape) * 0.02).to(dtype).contiguous()
+
+    tensors = {}
+    tensors["model.embed_tokens.weight"] = weight((vocab, hidden))
+    tensors["lm_head.weight"] = weight((vocab, hidden))
+    tensors["model.norm.weight"] = weight((hidden,))
+
+    for layer in range(num_layers):
+        prefix = f"model.layers.{layer}"
+        for sublayer in (0, 1):
+            attn = f"{prefix}.self_attn.{sublayer}"
+            tensors[f"{attn}.q_a_proj.weight"] = weight((q_lora, hidden))
+            tensors[f"{attn}.q_a_layernorm.weight"] = weight((q_lora,))
+            tensors[f"{attn}.q_b_proj.weight"] = weight((num_heads * qk, q_lora))
+            tensors[f"{attn}.kv_a_proj_with_mqa.weight"] = weight((kv_lora + rope, hidden))
+            tensors[f"{attn}.kv_a_layernorm.weight"] = weight((kv_lora,))
+            tensors[f"{attn}.kv_b_proj.weight"] = weight((num_heads * (nope + value), kv_lora))
+            tensors[f"{attn}.o_proj.weight"] = weight((hidden, num_heads * value))
+            tensors[f"{prefix}.input_layernorm.{sublayer}.weight"] = weight((hidden,))
+            tensors[f"{prefix}.post_attention_layernorm.{sublayer}.weight"] = weight((hidden,))
+            tensors[f"{prefix}.mlps.{sublayer}.gate_proj.weight"] = weight((ffn, hidden))
+            tensors[f"{prefix}.mlps.{sublayer}.up_proj.weight"] = weight((ffn, hidden))
+            tensors[f"{prefix}.mlps.{sublayer}.down_proj.weight"] = weight((hidden, ffn))
+        # LSA indexer lives on the first attention sublayer of every logical layer (CLI factor 2).
+        indexer = f"{prefix}.self_attn.0.indexer"
+        tensors[f"{indexer}.wq_b.weight"] = weight((index_heads * index_head_dim, q_lora))
+        tensors[f"{indexer}.wk.weight"] = weight((index_head_dim, hidden))
+        tensors[f"{indexer}.weights_proj.weight"] = weight((index_heads, hidden))
+        tensors[f"{indexer}.k_norm.weight"] = weight((index_head_dim,))
+        # Routers are FP32 in the source checkpoint; identity zero experts carry no weights.
+        tensors[f"{prefix}.mlp.router.classifier.weight"] = weight((n_routed + n_zero, hidden), torch.float32)
+        tensors[f"{prefix}.mlp.router.e_score_correction_bias"] = torch.zeros((n_routed + n_zero,), dtype=torch.float32)
+        for expert in range(n_routed):
+            tensors[f"{prefix}.mlp.experts.{expert}.gate_proj.weight"] = weight((expert_ffn, hidden))
+            tensors[f"{prefix}.mlp.experts.{expert}.up_proj.weight"] = weight((expert_ffn, hidden))
+            tensors[f"{prefix}.mlp.experts.{expert}.down_proj.weight"] = weight((hidden, expert_ffn))
+
+    # Over-embeddings: two n-gram windows, modulus ratio 4 like tiny-random/longcat-flash-lite.
+    modulus = config["oe_vocab_size_ratio"] * vocab
+    over_width = hidden // (config["oe_split_num"] * (config["oe_neighbor_num"] - 1))
+    for index in range(config["oe_split_num"] * (config["oe_neighbor_num"] - 1)):
+        rows = modulus + 2 * index + 1
+        tensors[f"model.ngram_embeddings.embedders.{index}.weight"] = weight((rows, over_width))
+        tensors[f"model.ngram_embeddings.post_projs.{index}.weight"] = weight((hidden, over_width))
+
+    # One MTP/NextN draft layer: tied embedding copy, EH projection, norms, dense MLA with its own indexer.
+    tensors["model.mtp.embed_tokens.weight"] = tensors["model.embed_tokens.weight"].clone()
+    tensors["model.mtp.layers.0.eh_proj.weight"] = weight((hidden, 2 * hidden))
+    tensors["model.mtp.layers.0.enorm.m.weight"] = weight((hidden,))
+    tensors["model.mtp.layers.0.hnorm.m.weight"] = weight((hidden,))
+    tensors["model.mtp.layers.0.input_layernorm.weight"] = weight((hidden,))
+    tensors["model.mtp.layers.0.post_attention_layernorm.weight"] = weight((hidden,))
+    draft = "model.mtp.layers.0.self_attn"
+    tensors[f"{draft}.q_a_proj.weight"] = weight((q_lora, hidden))
+    tensors[f"{draft}.q_a_layernorm.weight"] = weight((q_lora,))
+    tensors[f"{draft}.q_b_proj.weight"] = weight((num_heads * qk, q_lora))
+    tensors[f"{draft}.kv_a_proj_with_mqa.weight"] = weight((kv_lora + rope, hidden))
+    tensors[f"{draft}.kv_a_layernorm.weight"] = weight((kv_lora,))
+    tensors[f"{draft}.kv_b_proj.weight"] = weight((num_heads * (nope + value), kv_lora))
+    tensors[f"{draft}.o_proj.weight"] = weight((hidden, num_heads * value))
+    tensors[f"{draft}.indexer.wq_b.weight"] = weight((index_heads * index_head_dim, q_lora))
+    tensors[f"{draft}.indexer.wk.weight"] = weight((index_head_dim, hidden))
+    tensors[f"{draft}.indexer.weights_proj.weight"] = weight((index_heads, hidden))
+    tensors[f"{draft}.indexer.k_norm.weight"] = weight((index_head_dim,))
+    tensors["model.mtp.layers.0.transformer_layer.mlp.gate_proj.weight"] = weight((ffn, hidden))
+    tensors["model.mtp.layers.0.transformer_layer.mlp.up_proj.weight"] = weight((ffn, hidden))
+    tensors["model.mtp.layers.0.transformer_layer.mlp.down_proj.weight"] = weight((hidden, ffn))
+    tensors["model.mtp.norm.weight"] = weight((hidden,))
+
+    save_file(tensors, str(folder / "model.safetensors"), metadata={"format": "pt"})
+
+    expected_prefixes = (
+        "model.embed_tokens.",
+        "model.norm.",
+        "lm_head.",
+        "model.layers.",
+        "model.ngram_embeddings.",
+        "model.mtp.",
+    )
+    assert all(name.startswith(expected_prefixes) for name in tensors)
+    assert len(tensors["model.mtp.embed_tokens.weight"].shape) == 2
+    return (
+        "LongcatCausalLM (direct SGLang-schema tiny checkpoint): 4 dual-sublayer LongCat Flash decoder "
+        "layers with shortcut MoE (32 routed + 128 identity zero experts, top-k 12), compressed MLA "
+        "(q_lora_rank=32, kv_lora_rank=32, 32 heads, nope 32 / rope 64 / value 32), LSA indexers "
+        "(16 heads, head dim 128, CLI factor 2), two over-embedding windows, one MTP/NextN draft layer, "
+        "131,072-row untied token tables."
+    )
+
+
+create_model(
+    source_model_id="meituan-longcat/LongCat-Flash-Lite-Sparse",
+    source_revision="35de83a18b5838ec1657edb3f885a59bbdd7888f",
+    save_folder="/tmp/longcat-flash-lite-sparse",
+)

.meta/env.json

@@ -0,0 +1,19 @@
+{
+  "source_model": {
+    "name": "meituan-longcat/LongCat-Flash-Lite-Sparse",
+    "commit_id": "35de83a18b5838ec1657edb3f885a59bbdd7888f"
+  },
+  "environments": {
+    "creation": {
+      "python": "3.12.13",
+      "packages": {
+        "huggingface_hub": "2.3.0",
+        "safetensors": "0.8.0",
+        "tokenizers": "0.23.3",
+        "torch": "2.13.0+cu126",
+        "transformers": "5.22.0.dev0"
+      },
+      "cuda": "12.6"
+    }
+  }
+}

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Meituan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,64 @@
+---
+library_name: transformers
+pipeline_tag: text-generation
+base_model:
+- meituan-longcat/LongCat-Flash-Lite-Sparse
+---
+
+This is a randomly initialized tiny model based on [meituan-longcat/LongCat-Flash-Lite-Sparse](https://huggingface.co/meituan-longcat/LongCat-Flash-Lite-Sparse) for testing and debugging.
+
+| Feature | Source | This repo |
+|---|---|---|
+| Checkpoint tensor elements | 69.11B BF16, 17.26M F32 | 11.72M BF16, 5.76K F32 |
+| Safetensors weight files | 138.29 GB (26 files) | 23.53 MB (model.safetensors) |
+| Logical layers (attention sublayers) | 14 (28) | 4 (8) |
+| Hidden width / dense MLP / expert MLP | 3,072 / 6,144 / 1,024 | 8 / 64 / 32 |
+| Q heads / MLA nope-rope-v head dims | 32 / 128-64-128 | 8 / 64-64-128 |
+| MLA q-lora / kv-lora rank | 1,536 / 512 | 32 / 256 |
+| Routed / identity zero experts, top-k | 256 / 128, 12 | 32 / 128, 12 |
+| LSA index heads / head dim / top-k | 16 / 128 / 2,048 | Same |
+| CLI factor / local + init tokens | 2 / 1,024 + 16 | Same |
+| Over-embedding tables | 12 tables, ~10.22M rows each | 2 tables, ~524k rows |
+| MTP/NextN draft layers | 1 (with LSA indexer) | Same |
+| Attention / RoPE | LSA + deepseek-yarn, 1M context | Same |
+| Vocabulary rows / tying | 131,072 / untied | Same |
+| Routers / correction bias | FP32 | Same |
+| Stored precision | BF16 | Same |
+
+The source repo ships no model code and no Transformers implementation (`config.json` has no `model_type` or `auto_map`); SGLang recognizes its `LongcatCausalLM` architecture through its `longcat_flash` config parser and DSA indexer. The tiny tensors were generated directly against that loader's state-dict schema and key remapping, including the nested `model.ngram_embeddings.{embedders,post_projs}.*` over-embedding names (newer SGLang also accepts the source checkpoint's flattened `oe_embed_tokens*.weight` aliases) and the `model.mtp.*` NextN draft. The n-gram hash modulus is internal embedding machinery rather than an externally visible task space, so it follows the smaller [tiny-random/longcat-flash-lite](https://huggingface.co/tiny-random/longcat-flash-lite) modulus; the 131,072 task vocabulary rows and token ids are unchanged. No local Transformers execution path exists; serve with SGLang (0.5.23.dev384 or newer, which includes LongCat LSA) using the command below.
+
+### Example usage
+
+#### SGLang serving (✅ verified)
+
+LSA is implemented in SGLang (main branch; the LongCat Sparse adaptation landed via PR #32918). The checkpoint keeps the source's LongcatCausalLM architecture and serves text only, like the upstream deployment guide.
+
+```bash
+python3 -m sglang.launch_server \
+  --trust-remote-code \
+  --model scratch/longcat-flash-lite-sparse \
+  --host 0.0.0.0 \
+  --port 30000 \
+  --tp-size 4 \
+  --max-running-requests 64 \
+  --mem-fraction-static 0.93 \
+  --chunked-prefill-size 2048 \
+  --dsa-prefill-backend fa3 \
+  --kv-cache-dtype bfloat16
+
+curl http://127.0.0.1:30000/v1/chat/completions \
+  -H 'Content-Type: application/json' \
+  -d '{"messages": [{"role": "user", "content": "Hello, world!"}], "max_tokens": 16}'
+```
+
+### Creating this repo
+
+- Code: [.meta/create_model.py](.meta/create_model.py)
+- Model structure: [.meta/model.log](.meta/model.log)
+- Environment: [.meta/env.json](.meta/env.json)
+
+### Change log
+
+- 2026-11-03: Initial version. Direct SGLang-schema checkpoint: Transformers has no implementation for the LongCat Sparse Attention (LSA) repo (no model_type/auto_map), so tensors follow the pinned sgl-project/sglang main loader (`longcat_flash.py` plus the DSA `Indexer`). Four dual-sublayer logical layers (eight attention sublayers) keep the shortcut-MoE topology with 32 routed and 128 weightless identity zero experts at top-k 12, compressed MLA ranks (q 32 / kv 256, the Hopper FA3 compressed-latent q_v kernel floor; the source uses kv 512) with 8 Q heads, 64/64 nope/rope and the source 128 value head dim (qk 128 + v 128 matches the Hopper FA3 MHA/MLA head-dim windows), and LSA indexers with the source 16 heads / head dim 128 on every even physical attention layer (CLI factor 2). One MTP/NextN draft layer with its own indexer is serialized under `model.mtp.*`; over-embeddings use the loader-native nested ngram names and the sibling tiny modulus (ratio 4, 2 x 2 windows) instead of the source 10.2-million-row hash tables.
+
+*This repo is generated by GPT-6.1-Sol.*

config.json

@@ -0,0 +1,60 @@
+{
+  "architectures": [
+    "LongcatCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "vocab_size": 131072,
+  "hidden_size": 8,
+  "ffn_hidden_size": 64,
+  "expert_ffn_hidden_size": 32,
+  "num_layers": 4,
+  "num_attention_heads": 8,
+  "kv_lora_rank": 256,
+  "q_lora_rank": 32,
+  "qk_rope_head_dim": 64,
+  "v_head_dim": 128,
+  "qk_nope_head_dim": 64,
+  "mla_scale_q_lora": true,
+  "mla_scale_kv_lora": true,
+  "routed_scaling_factor": 6.0,
+  "n_routed_experts": 32,
+  "max_position_embeddings": 983040,
+  "rms_norm_eps": 1e-05,
+  "use_cache": true,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "rope_theta": 1000000.0,
+  "rope_scaling": {
+    "original_max_position_embeddings": 8192,
+    "rope_type": "deepseek_yarn",
+    "factor": 120,
+    "beta_fast": 32,
+    "beta_slow": 1,
+    "mscale": 1,
+    "mscale_all_dim": 1
+  },
+  "attention_method": "LSA",
+  "zero_expert_num": 128,
+  "zero_expert_type": "identity",
+  "moe_topk": 12,
+  "use_mla": 1,
+  "moe_switch_token_num": 1024,
+  "moe_impl": "mix",
+  "oe_vocab_size_ratio": 4,
+  "oe_neighbor_num": 2,
+  "oe_split_num": 2,
+  "mtp_num_layers": 3,
+  "mtp_replicate_modules": true,
+  "mtp_disable_over_tokenizer": false,
+  "indexer_rope_interleave": true,
+  "index_n_heads": 16,
+  "index_head_dim": 128,
+  "index_topk": 2048,
+  "index_k_norm_type": "rms",
+  "cli_factor": 2,
+  "dsa_mtp_cli": true,
+  "index_local_tokens": 1024,
+  "index_init_tokens": 16,
+  "num_indexer_layers": 8
+}

generation_config.json

@@ -0,0 +1,11 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "pad_token_id": 3,
+  "transformers_version": "4.57.6",
+  "repetition_penalty": 1.06,
+  "temperature": 0.7,
+  "top_p": 0.95,
+  "top_k": 4 
+}

model.safetensors

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

special_tokens_map.json

@@ -0,0 +1,30 @@
+{
+  "bos_token": {
+    "content": "<longcat_s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</longcat_s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<longcat_pad>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<longcat_unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer_config.json

@@ -0,0 +1,42 @@
+{
+  "add_bos_token": false,
+  "add_eos_token": true,
+  "add_prefix_space": false,
+  "bos_token": {
+    "__type": "AddedToken",
+    "content": "<longcat_s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "clean_up_tokenization_spaces": false,
+  "eos_token": {
+    "__type": "AddedToken",
+    "content": "</longcat_s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "model_max_length": 131072,
+  "pad_token": {
+    "__type": "AddedToken",
+    "content": "<longcat_pad>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sp_model_kwargs": {},
+  "tokenizer_class": "BloomTokenizer",
+  "unk_token": {
+    "__type": "AddedToken",
+    "content": "<longcat_unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "chat_template": "{%- set tool_choice = tool_choice | default('auto') -%}\n{%- set enable_thinking = enable_thinking | default(none) -%}\n{%- set save_history_reasoning_content = save_history_reasoning_content | default(false) -%}\n{%- set ns = namespace(final_messages = [], tool_types = [], last_query_index = -1) -%}\n{%- for message in messages -%}\n    {%- set role = message.get('role') -%}\n    {%- set c = message.get('content') -%}\n    {%- if c is string -%}\n        {%- set ns.final_messages = ns.final_messages + [message] -%}\n    {%- elif c is iterable and c is not mapping -%}\n        {%- set parts = namespace(text=[], thinking=[], tool_calls=[], tool_results=[]) -%}\n        {%- for item in c -%}\n            {%- if item['type'] == 'text' -%}\n                {%- set parts.text = parts.text + [item['text']] -%}\n            {%- elif item['type'] == 'thinking' -%}\n                {%- if item['thinking'] -%}\n                    {%- set parts.thinking = parts.thinking + [item['thinking']] -%}\n                {%- endif -%}\n            {%- elif item['type'] == 'tool_use' -%}\n                {%- set parts.tool_calls = parts.tool_calls + [{\n                    'id': item['id'],\n                    'type': 'function',\n                    'function': {\n                        'name': item['name'],\n                        'arguments': item['input']\n                    }\n                }] -%}\n            {%- elif item['type'] == 'tool_result' -%}\n                {%- set parts.tool_results = parts.tool_results + [{\n                    'role': 'tool',\n                    'name': item.get('name', ''),\n                    'tool_call_id': item['tool_use_id'],\n                    'content': item['content']\n                }] -%}\n            {%- endif -%}\n        {%- endfor -%}\n        {%- set ns.final_messages = ns.final_messages + parts.tool_results -%}\n        {%- if not (parts.tool_results | length > 0 and parts.text | length == 0 and role == 'user') -%}\n            {%- set ns.final_messages = ns.final_messages + [{\n                'role': role,\n                'content': parts.text | join(''),\n                'reasoning_content': parts.thinking | join(''),\n                'tool_calls': parts.tool_calls\n            }] -%}\n        {%- endif -%}\n    {%- else -%}\n        {%- set ns.final_messages = ns.final_messages + [message] -%}\n    {%- endif -%}\n{%- endfor -%}\n{%- set messages = ns.final_messages -%}\n\n{%- for idx in range(messages|length) -%}\n    {%- set msg = messages[idx] -%}\n    {%- if msg.role == 'user' -%}\n        {%- set ns.last_query_index = idx -%}\n    {%- endif -%}\n{%- endfor -%}\n\n{%- if tools and tool_choice != 'none' -%}\n    {{- \"<longcat_tool_declare>\\n\" -}}\n    {{- \"# Tools\\n\" -}}\n    {{- \"You have access to the following tools:\\n\\n\" -}}\n    {%- for tool in tools -%}\n        {%- if tool.type not in ns.tool_types -%}\n            {%- set ns.tool_types = ns.tool_types + [tool.type] -%}\n            {{- \"## Tool namespace: \" ~ tool.type ~ \"\\n\\n\" -}}\n        {%- endif -%}\n        {%- if tool.type == 'code_interpreter' -%}\n            {%- set tool = {\"type\":\"code_interpreter\",\"function\":{\"name\":\"code_interpreter_preview\",\"description\":\"The code will be executed in a stateful Jupyter notebook sandbox environment, only supports local computation, data processing, and file operations.\\nCode sandbox environment (network isolated) Any external network requests or online API calls are prohibited.\\nIf online functionality is needed, please use other permitted tools.\\nCode will respond with the output of the execution or time out after 60.0 seconds. \",\"parameters\":{\"type\":\"object\",\"properties\":{\"language\":{\"type\":\"string\",\"description\":\"The programming language of the code to be executed. Available values: python (Default), java, go, js, ts, c, c++.\"},\"code\":{\"type\":\"string\",\"description\":\"Python code to be executed must not include the following:\\n- Importing network libraries such as requests, httplib, etc.\\n- Any form of HTTP requests.\\n- External API calls.\\n- Network port operations. Example: ```python\\nimport pandas as pd\\npd.DataFrame({'A':[1,2]})\\n```\"},\"timeout\":{\"type\":\"number\",\"description\":\"The maximum execution time of the code, in seconds. Default is 60.0.\"}}},\"required\":[\"code\"]}} -%}\n        {%- endif -%}\n        {{- \"### Tool name: \" + tool.function.name + \"\\n\" -}}\n        {{- \"Description: \" + tool.function.description + \"\\n\\n\" -}}\n        {{- \"InputSchema: \" + tool.function.parameters | tojson(ensure_ascii=False) + \"\\n\\n\" -}}\n    {%- endfor -%}\n    {{- '**Note**: For each function call, output the function name and arguments within the following XML format:\\n<longcat_tool_call>{function-name}\\n<longcat_arg_key>{arg-key-1}</longcat_arg_key>\\n<longcat_arg_value>{arg-value-1}</longcat_arg_value>\\n<longcat_arg_key>{arg-key-2}</longcat_arg_key>\\n<longcat_arg_value>{arg-value-2}</longcat_arg_value>\\n...\\n</longcat_tool_call>\\n' -}}\n    {{- \"</longcat_tool_declare>\"-}}\n{%- endif -%}\n\n{%- for msg in messages -%}\n    {%- if msg.role == \"system\" -%}\n        {{- \"<longcat_system>\" + msg.content -}}\n    {%- elif msg.role == \"user\" -%}\n        {{- \"<longcat_user>\" -}}\n        {%- if msg[\"files\"] -%}\n            {{- '<longcat_files>\\n' ~ msg.files | tojson(indent=2) ~ '\\n</longcat_files>' -}}\n        {%- endif -%}\n        {{- msg.content -}}\n        {%- if save_history_reasoning_content and enable_thinking is not none -%}\n            {%- if loop.last or messages[loop.index0 + 1].role != 'assistant' -%}\n                {# pass #}\n            {%- else -%}\n                {%- if enable_thinking == true -%}\n                    {{- \" /think_on\" -}}\n                    {%- if thinking_budget -%}\n                        {%- if thinking_budget < 1024 -%}\n                            {%- set thinking_budget = 1024 -%}\n                        {%- endif -%}\n                        {{- \"\\nthinking_budget: < \" ~ thinking_budget ~ \".\" -}}\n                    {%- endif -%}\n                    {{- \" \" -}}\n                {%- elif enable_thinking == false -%}\n                    {{- \" /think_off \" -}}\n                {%- endif -%}\n            {%- endif -%}\n        {%- elif loop.index0 >= ns.last_query_index and enable_thinking is not none -%}\n            {%- if loop.last or messages[loop.index0 + 1].role != 'assistant' -%}\n                {# pass #}\n            {%- else -%}\n                {%- if enable_thinking == true -%}\n                    {{- \" /think_on\" -}}\n                    {%- if thinking_budget -%}\n                        {%- if thinking_budget < 1024 -%}\n                            {%- set thinking_budget = 1024 -%}\n                        {%- endif -%}\n                        {{- \"\\nthinking_budget: < \" ~ thinking_budget ~ \".\" -}}\n                    {%- endif -%}\n                    {{- \" \" -}}\n                {%- elif enable_thinking == false -%}\n                    {{- \" /think_off \" -}}\n                {%- endif -%}\n            {%- endif -%}\n        {%- endif -%}\n    {%- elif msg.role == \"assistant\" -%}\n        {{- \"<longcat_assistant>\" -}}\n        {%- if save_history_reasoning_content == true or loop.index0 > ns.last_query_index -%}\n            {%- if enable_thinking == true -%}\n                {%- if msg.reasoning_content -%}\n                    {%- set reasoning_content = msg.reasoning_content | trim -%}\n                    {{- \"<longcat_think>\\n\" ~ reasoning_content ~ \"\\n</longcat_think>\\n\" -}}\n                {%- else -%}\n                    {{- \"<longcat_think>\\n\\n</longcat_think>\\n\" -}}\n                {%- endif -%}\n            {%- elif enable_thinking == false -%}\n                {{- \"<longcat_think>\\n\\n</longcat_think>\\n\" -}}\n            {%- endif -%}\n        {%- endif -%}\n        {%- if msg.content -%}\n            {{- msg.content -}}\n        {%- endif -%}\n        {%- if msg.tool_calls -%}\n            {%- for tool_call in msg.tool_calls -%}\n                {{- \"<longcat_tool_call>\" ~ tool_call.function.name ~ \"\\n\" -}}\n                {%- set _args = tool_call.function.arguments -%}\n                {%- for k, v in _args.items() -%}\n                    {{- \"<longcat_arg_key>\" ~ k ~ \"</longcat_arg_key>\\n\" -}}\n                    {{- \"<longcat_arg_value>\" ~ (v if v is string else v | tojson(ensure_ascii=False)) ~ \"</longcat_arg_value>\\n\" -}}\n                {% endfor -%}\n                {{- \"</longcat_tool_call>\\n\" -}}\n            {%- endfor -%}\n        {%- endif -%}\n        {{- \"</longcat_s>\" -}}\n    {%- elif msg.role == \"tool\" -%}\n        {%- if messages[loop.index0 - 1].role != \"tool\" -%}\n            {{- \"<longcat_observation>\" -}}\n        {%- endif -%}\n        {{- \"<longcat_tool_response>\" ~ msg.name ~ \"\\n\" ~ msg.content ~ \"</longcat_tool_response>\" -}}\n        {%- if loop.index0 == messages|length - 1 -%}\n            {# pass #}\n        {%- elif (save_history_reasoning_content or loop.index0 > ns.last_query_index) and messages[loop.index0 + 1].role != \"tool\" -%}\n            {%- if enable_thinking == true -%}\n                {{- \" /think_on\" -}}\n                {%- if thinking_budget -%}\n                    {%- if thinking_budget < 1024 -%}\n                        {%- set thinking_budget = 1024 -%}\n                    {%- endif -%}\n                    {{- \"\\nthinking_budget: < \" ~ thinking_budget ~ \".\" -}}\n                {%- endif -%}\n                {{- \" \" -}}\n            {%- elif enable_thinking == false -%}\n                {{- \" /think_off \" -}}\n            {%- endif -%}\n        {%- endif -%}\n    {%- endif -%}\n{%- endfor -%}\n{%- if add_generation_prompt -%}\n    {%- if enable_thinking == true -%}\n        {{- \" /think_on\" -}}\n        {%- if thinking_budget -%}\n            {%- if thinking_budget < 1024 -%}\n                {%- set thinking_budget = 1024 -%}\n            {%- endif -%}\n            {{- \"\\nthinking_budget: < \" ~ thinking_budget ~ \".\" -}}\n        {%- endif -%}\n        {{- \" <longcat_assistant><longcat_think>\\n\" -}}\n    {%- elif enable_thinking == false -%}\n        {{- \" /think_off <longcat_assistant><longcat_think>\\n\\n</longcat_think>\\n\" -}}\n    {%- else -%}\n        {{- \"<longcat_assistant>\" -}}\n    {%- endif -%}\n{%- endif -%}"
+}