Upload folder using huggingface_hub

.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

README.md

@@ -0,0 +1,370 @@
+---
+library_name: peft
+license: apache-2.0
+base_model: Qwen/Qwen2.5-Coder-7B-Instruct
+tags:
+  - security
+  - vulnerability-detection
+  - injection
+  - code-analysis
+  - lora
+  - qwen2
+  - cybersecurity
+  - sast
+  - cwe
+datasets:
+  - hitoshura25/cvefixes
+  - claudios/DiverseVul
+  - CyberNative/Code_Vulnerability_Security_DPO
+  - UCSB-SURFI/VulnLLM-R-Train-Data
+  - CIRCL/vulnerability-cwe-patch
+language:
+  - en
+  - code
+pipeline_tag: text-generation
+model-index:
+  - name: injection-vulnerability-detector
+    results:
+      - task:
+          type: text-generation
+          name: Injection Vulnerability Detection
+        dataset:
+          name: Injection Vulnerability Novel Test Set (leakage-controlled)
+          type: injection-vuln-novel
+        metrics:
+          - name: F1
+            type: f1
+            value: 0.6803519061583577
+            verified: false
+          - name: Precision
+            type: precision
+            value: 0.8169014084507042
+            verified: false
+          - name: Recall
+            type: recall
+            value: 0.5829145728643216
+            verified: false
+---
+
+# Injection Vulnerability Detector v1.0
+
+A fine-tuned **Qwen2.5-Coder-7B-Instruct** model specialized in detecting injection
+vulnerabilities in source code. Built with LoRA (Low-Rank Adaptation) for efficient
+fine-tuning on consumer/workstation hardware.
+
+**Key contribution:** Existing vulnerability datasets lack CWE-specific labels for
+injection subtypes — most group all injections generically, and rare types like LDAP,
+XPath, EL injection, and SSTI have near-zero representation. We solved this with a
+**template-based synthetic data generator** (151 templates, 9 CWEs) that produces
+CWE-specific injection samples at scale without requiring an LLM, combined with
+filtered real-world vulnerability data from open-source datasets.
+
+## What it does
+
+Given a code snippet, the model identifies whether it contains an **injection vulnerability**
+and, if so, classifies the specific CWE (Common Weakness Enumeration) type. It outputs
+structured JSON with a verdict, CWE ID, vulnerability type, tainted data-flow analysis,
+an explanation, and a fix suggestion.
+
+### Supported vulnerability types (9 CWEs)
+
+| CWE | Vulnerability Type |
+|-----|-------------------|
+| CWE-89 | SQL Injection |
+| CWE-78 | OS Command Injection |
+| CWE-94 | Code Injection |
+| CWE-611 | XXE (XML External Entity) |
+| CWE-90 | LDAP Injection |
+| CWE-643 | XPath Injection |
+| CWE-917 | Expression Language Injection |
+| CWE-1336 | Server-Side Template Injection (SSTI) |
+| CWE-113 | HTTP Response Splitting / Header Injection |
+
+## Evaluation results
+
+**Our primary metrics are computed on novel code only** (template clones removed; the full-set figure is shown for comparison) — test samples verified
+to be structurally distinct from all training data.  Of 1572 total
+test samples, 1007 (64.1%) were identified as structural
+clones of training data and excluded (see Evaluation Methodology below).
+
+### Evaluation: three levels of rigor
+
+| Evaluation set | Precision | Recall | F1 |
+|---|---|---|---|
+| Full test set (includes template clones) | 96.2% | 83.6% | **89.5%** |
+| Novel code, all injection-related CWEs (n=565) | 82.8% | 46.6% | 59.7% |
+| **Novel code, in-scope 9 target CWEs (n=496)** | **81.7%** | **58.3%** | **68.0%** |
+
+Our **primary metric is the in-scope novel row** — performance on the 9 CWEs the model targets, on code it has never seen in any structural form. The full-set figure is what most detectors report; we consider it inflated by template-clone memorisation (see Evaluation Methodology). The all-CWE novel row additionally counts out-of-scope vulnerability types the model does not target.
+
+### Primary metrics (novel code, in-scope 9 CWEs, n=496)
+
+| Metric | Score |
+|--------|-------|
+| **Precision** | 81.7% |
+| **Recall** | 58.3% |
+| **F1 Score** | 68.0% |
+| **Accuracy** | 78.0% |
+| JSON Parse Rate | 94.9% |
+
+### Per-CWE performance (novel code)
+
+| CWE | Vulnerability | Precision | Recall | F1 | Samples |
+|-----|--------------|-----------|--------|-----|---------|
+| CWE-89 | SQL Injection | 76.5% | 67.2% | 71.6% | 58 |
+| CWE-78 | OS Command Injection | 75.9% | 42.3% | 54.3% | 52 |
+| CWE-94 | Code Injection | 77.4% | 46.2% | 57.8% | 52 |
+| CWE-611 | XXE (XML External Entity) | 100.0% | 75.0% | 85.7% | 16 |
+| CWE-90 | LDAP Injection | 100.0% | 60.0% | 75.0% | 5 |
+| CWE-643 | XPath Injection | 100.0% | 100.0% | 100.0% | 4 |
+| CWE-917 | Expression Language Injection | 100.0% | 100.0% | 100.0% | 2 |
+| CWE-1336 | Server-Side Template Injection | 100.0% | 100.0% | 100.0% | 6 |
+| CWE-113 | HTTP Response Splitting | 100.0% | 100.0% | 100.0% | 4 |
+
+### Evaluation methodology
+
+Standard group-aware splitting (by CVE ID / project) prevents the *same* code
+from appearing in both train and test, but it does not prevent **template
+clones** — structurally identical code differing only in variable names,
+string literals, and numeric constants — from leaking across the split.  A
+skeleton-hashing analysis revealed that 64.1% of the initial test set
+were structural clones of training samples, scoring near-perfect F1 from
+memorisation rather than generalisation.
+
+**Skeleton hashing method:** strip comments, string literals, identifiers, and
+numeric literals from each code sample, then SHA-256 hash the normalised
+skeleton.  Any test sample whose skeleton matches a training sample is
+classified as a clone and excluded from the metrics reported above.
+
+The scores above therefore reflect performance on genuinely novel code that
+the model has never seen in any structural form during training.  We report
+these numbers — not the inflated full-test-set figures — because they are
+what matters for real-world deployment.
+
+## Usage
+
+### Quick start with transformers + PEFT
+
+```python
+from peft import PeftModel
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# Load base model + LoRA adapter
+base_model = AutoModelForCausalLM.from_pretrained(
+    "Qwen/Qwen2.5-Coder-7B-Instruct",
+    torch_dtype="auto",
+    device_map="auto",
+)
+model = PeftModel.from_pretrained(base_model, "vikramdgx/injection-vulnerability-detector")
+tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-7B-Instruct")
+
+# Analyze code — use the EXACT prompt format the model was trained on
+code_snippet = '''import sqlite3
+def get_user(username):
+    conn = sqlite3.connect("app.db")
+    query = f"SELECT * FROM users WHERE name = '{username}'"
+    return conn.execute(query).fetchone()
+'''
+
+SYSTEM_PROMPT = (
+    "You are a code security analyzer specialized in detecting injection "
+    "vulnerabilities. Analyze the provided code and respond with a JSON "
+    "object containing: verdict, cwe, vulnerability_type, tainted_flow, "
+    "explanation, and fix_suggestion."
+)
+
+user_message = (
+    "Analyze the following code for injection vulnerabilities. "
+    "Respond with JSON.\n\n"
+    + code_snippet
+)
+
+messages = [
+    {"role": "system", "content": SYSTEM_PROMPT},
+    {"role": "user", "content": user_message},
+]
+
+text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+inputs = tokenizer(text, return_tensors="pt").to(model.device)
+outputs = model.generate(**inputs, max_new_tokens=768, do_sample=False)
+response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
+print(response)
+```
+
+### Expected output format
+
+The model returns structured JSON matching its training schema:
+
+```json
+{
+  "verdict": "VULNERABLE",
+  "cwe": "CWE-89",
+  "vulnerability_type": "SQL Injection",
+  "tainted_flow": {
+    "source": "username parameter",
+    "sink": "conn.execute(query)",
+    "sanitizer": null
+  },
+  "explanation": "User input is directly interpolated into SQL query string via f-string without parameterization, enabling SQL injection.",
+  "fix_suggestion": "Use parameterized queries: conn.execute('SELECT * FROM users WHERE name = ?', (username,))"
+}
+```
+
+For safe code, the model returns:
+
+```json
+{
+  "verdict": "SAFE",
+  "cwe": null,
+  "vulnerability_type": null,
+  "tainted_flow": null,
+  "explanation": "No injection vulnerability detected.",
+  "fix_suggestion": null
+}
+```
+
+## Training details
+
+### Hardware
+
+- **NVIDIA DGX Spark** (Grace Blackwell GB10)
+- 128 GB unified LPDDR5X memory
+- CUDA 13.0, compute capability sm_121
+
+### Configuration
+
+| Parameter | Value |
+|-----------|-------|
+| Base model | Qwen/Qwen2.5-Coder-7B-Instruct |
+| Method | LoRA (PEFT) |
+| LoRA rank (r) | 16 |
+| LoRA alpha | 32 |
+| Target modules | q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj |
+| Trainable parameters | 40.3M (0.53% of total) |
+| Epochs | 3 |
+| Batch size | 2 (gradient accumulation: 4, effective 8) |
+| Learning rate | 2e-4 |
+| Max sequence length | 4096 |
+| Optimizer | AdamW (8-bit) |
+| LR scheduler | Cosine |
+| Packing | Enabled |
+| Loss | Completion-only |
+
+### Why we built a custom dataset
+
+Existing open-source vulnerability datasets (CVEfixes, DiverseVul, BigVul, etc.)
+provide valuable real-world code samples, but they share a common gap: **they lack
+fine-grained, CWE-specific labels for injection subtypes.** Most label code broadly
+as "vulnerable" or group all injections under generic categories like CWE-74 or
+CWE-20 — without distinguishing SQL injection (CWE-89) from command injection
+(CWE-78) from SSTI (CWE-1336). For niche injection types like LDAP injection
+(CWE-90), XPath injection (CWE-643), or EL injection (CWE-917), labeled samples
+in public datasets are extremely scarce (often single digits).
+
+This makes it impossible to train a detector that both identifies vulnerabilities
+AND classifies the specific CWE type — which is what security engineers actually
+need for triage.
+
+### Our approach: template-based synthetic generation
+
+To solve this, we built a **procedural code generator** that produces CWE-specific
+injection samples at scale — no LLM in the loop, pure template expansion:
+
+- **151 handcrafted code templates** covering all 9 target CWEs, each with
+  `@@PLACEHOLDER@@` tokens for variable names, function names, table names,
+  database fields, and code patterns
+- **Randomized variable pools** (200+ variable names, 100+ function names, 50+
+  table names per CWE) ensure each generated sample is syntactically unique
+- **Paired generation**: every vulnerable template has a corresponding safe version
+  that uses parameterized queries, input validation, or proper escaping — teaching
+  the model the difference, not just the pattern
+- **~5,000 synthetic samples** generated in seconds, balanced across all 9 CWEs
+  including the rare ones that have near-zero representation in public datasets
+
+This approach is deterministic, reproducible, and produces exactly the CWE
+distribution the model needs — no data collection bottleneck, no labeling errors,
+no class imbalance.
+
+### Dataset composition
+
+The final training set combines three sources:
+
+1. **Real-world vulnerabilities** — filtered from open-source CVE/vulnerability
+   datasets, keeping only injection-related CWEs. Provides realistic code patterns
+   from production software.
+2. **Template-based synthetic data** (~5,000 samples) — our original procedural
+   generator. Fills the CWE-specific gap that public datasets leave open,
+   especially for rare injection types (LDAP, XPath, EL, SSTI, Header Injection).
+3. **Hard negatives** — safe code samples including post-patch fixes and
+   non-vulnerable functions from vulnerability-adjacent codebases. Teaches the
+   model what secure code looks like.
+
+Group-aware splitting ensures no data leakage between train and test sets (samples
+sharing a CVE ID or project stay together).  Additionally, a skeleton-hashing pass
+excludes structural template clones from the evaluation set (see Evaluation
+Methodology above).
+
+## Dataset sources and attribution
+
+This model was trained on data from the following open-source datasets, combined
+with our original synthetic generation. We gratefully acknowledge the dataset creators:
+
+| Dataset | Source | License | Role |
+|---------|--------|---------|------|
+| [CVEfixes](https://huggingface.co/datasets/hitoshura25/cvefixes) | Bhandari et al. | Apache 2.0 (data: CC BY 4.0) | Real-world vuln + patch pairs |
+| [DiverseVul](https://huggingface.co/datasets/claudios/DiverseVul) | Chen & Bhatt (RAID 2023) | Not specified on HF card | Safe code (non-vuln functions) |
+| [Code Vulnerability Security DPO](https://huggingface.co/datasets/CyberNative/Code_Vulnerability_Security_DPO) | CyberNative AI | Apache 2.0 | Injection code examples |
+| [VulnLLM-R Train Data](https://huggingface.co/datasets/UCSB-SURFI/VulnLLM-R-Train-Data) | UCSB SURFI | Not specified on HF card | Real-world vuln functions |
+| [CIRCL Vulnerability CWE Patch](https://huggingface.co/datasets/CIRCL/vulnerability-cwe-patch) | CIRCL (Luxembourg CERT) | Not specified on HF card | Vuln + patch pairs |
+| **Template-based synthetic generator** | **Original work** | **Apache 2.0** | **CWE-specific injection samples (core contribution)** |
+
+**License notes:**
+
+- The `securecode-web` dataset (CC BY-NC-SA 4.0) is **not** included in this
+  release. It is available as an opt-in source via `--include-nc` for non-commercial use only.
+- Three source datasets (DiverseVul, VulnLLM-R, CIRCL) do not declare an explicit
+  license on their HuggingFace cards as of this writing. This model's own adapter
+  weights are original work released under Apache 2.0, but users should check the
+  current licensing status of these upstream datasets before commercial deployment.
+
+## Limitations
+
+- **Injection-only scope:** This model detects 9 injection-related CWEs. It does not
+  cover other vulnerability classes (buffer overflow, authentication, crypto, etc.).
+- **Synthetic training bias:** The model is trained partly on template-generated code.
+  While this solves the CWE-distribution problem, performance on novel real-world
+  patterns is lower than on template-similar code, reflecting the generalisation gap
+  that template-based training introduces. See Evaluation Results for exact numbers.
+- **Rare CWEs are synthetic-validated only:** The five rare injection types (LDAP,
+  XPath, EL, SSTI, Header) have near-zero representation in public vulnerability
+  datasets. Our evaluation on novel code therefore cannot validate these CWEs —
+  their coverage relies entirely on synthetic templates. Real-world performance on
+  these types is unknown.
+- **CWE classification accuracy:** While detection (vulnerable vs. safe) is reliable,
+  the specific CWE label assigned to a detected vulnerability may be incorrect in some
+  cases — particularly between similar injection types (e.g. CWE-94 vs CWE-74).
+- **Code context:** The model analyzes individual functions/snippets. It cannot trace
+  data flow across files or understand application-level sanitization.
+- **Language coverage:** Primarily trained on Python, Java, PHP, C/C++, and JavaScript.
+  Performance on other languages may vary.
+- **Not a replacement for manual review:** Use as a triage/prioritization tool alongside
+  established SAST tooling and expert code review.
+
+## License
+
+This model adapter is released under the **Apache 2.0** license. The base model
+(Qwen2.5-Coder-7B-Instruct) is also Apache 2.0.
+
+## Citation
+
+If you use this model in your research, please cite:
+
+```bibtex
+@misc{injection-detector-v10,
+  title={Injection Vulnerability Detector v1.0},
+  author={Thrivikram Gujarathi},
+  year={2026},
+  publisher={HuggingFace},
+  url={https://huggingface.co/vikramdgx/injection-vulnerability-detector}
+}
+```

adapter_config.json

@@ -0,0 +1,54 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": {
+    "base_model_class": "Qwen2ForCausalLM",
+    "parent_library": "transformers.models.qwen2.modeling_qwen2",
+    "unsloth_fixed": true
+  },
+  "base_model_name_or_path": "unsloth/Qwen2.5-Coder-7B-Instruct",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.20.0",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "o_proj",
+    "gate_proj",
+    "q_proj",
+    "up_proj",
+    "v_proj",
+    "k_proj",
+    "down_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

adapter_model.safetensors

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

chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,217 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "is_local": false,
+  "local_files_only": false,
+  "model_max_length": 32768,
+  "pad_token": "<|PAD_TOKEN|>",
+  "padding_side": "left",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151665": {
+      "content": "<|PAD_TOKEN|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    }
+  }
+}