Duplicate from OBLITERATUS/Gemma-4-12B-OBLITERATED

Co-authored-by: pliny <pliny-the-prompter@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+*.gguf filter=lfs diff=lfs merge=lfs -text

Gemma-4-12B-OBLITERATED-BF16.gguf

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

Gemma-4-12B-OBLITERATED-Q4_K_M.gguf

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

Gemma-4-12B-OBLITERATED-v2-Q8_0.gguf

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

MANIFEST.txt

@@ -0,0 +1,5 @@
+3358cdb1cc6d6b66fef2da2762763b96008143aa62280d8b00de6dfa9b24632b  Gemma-4-12B-OBLITERATED-v2-BF16.gguf
+f5b01d65562305cad661d9ec83bd63220c101fec5355fa78fb6a27ba85116eb4  Gemma-4-12B-OBLITERATED-v2-Q4_K_M.gguf
+cbd0b09cc0476f6691fab1cb4f5e2412356f4aa264680b6f8a0e4ef72cbc0662  Gemma-4-12B-OBLITERATED-v2-Q5_K_M.gguf
+c83d9b1dc0ec155a8df023cf1aae71bdc6d619182d8b29854716b7e993e20214  Gemma-4-12B-OBLITERATED-v2-Q6_K.gguf
+54ac8a7b39cf617a9980cf32c5c943e2688745e03d451e70f3b5e2846a589fda  Gemma-4-12B-OBLITERATED-v2-Q8_0.gguf

README.md

@@ -0,0 +1,292 @@
+---
+license: gemma
+base_model: google/gemma-4-12B-it
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+  - gemma
+  - gemma4
+  - text-generation
+  - obliteratus
+  - refusal-analysis
+  - red-team
+  - aspa
+  - abliteration
+  - gguf
+  - safety-research
+  - alignment-research
+---
+
+# Gemma 4 12B OBLITERATED
+
+> Zero refusal. Zero capability loss. First in the field.
+>
+> 0/842 refusals. 46/70 MMLU-Pro (stock parity). Full coherence.
+
+The first abliterated model to achieve **zero refusal with zero benchmark regression** versus stock weights.
+
+Built with a novel **2-pass surgery pipeline** developed by [OBLITERATUS](https://github.com/elder-plinius/OBLITERATUS):
+
+1. **SOM Refusal Geometry Removal** (Pass 1) — layers 12-21
+2. **ASPA Step-Gradient Source-Tethering** (Pass 2) — layers 22-46
+
+---
+
+## ⚠️ Research Context & Responsible Use
+
+**This model exists for alignment research, red-teaming, and safety evaluation.**
+
+OBLITERATION is a weight-surgery technique that studies how safety behaviors are geometrically encoded in transformer activation space. By precisely identifying and removing refusal directions, this research contributes to the scientific understanding of:
+
+- **How alignment is represented** in model weights (mechanistic interpretability)
+- **How robust current safety training is** against post-training modification
+- **What the failure modes of RLHF/DPO-based alignment are** when adversaries have weight access
+
+This is the same class of research conducted by Arditi et al. ("Refusal in Language Models Is Mediated by a Single Direction", 2024), Zou et al. (HarmBench, 2024), and others in the open alignment research community.
+
+**This model has had safety guardrails surgically removed.** It will comply with requests that stock Gemma 4 would refuse. This is by design — it is the object of study, not a consumer product.
+
+### Who this is for
+- 🔬 **Alignment researchers** studying refusal geometry and safety robustness
+- 🔴 **Red-teamers** evaluating how post-training safety holds up against weight surgery
+- 🧪 **AI safety evaluators** who need an unrestricted baseline for benchmarking
+- 💻 **Local-first users** who want full control over their own hardware and models
+
+### Who this is NOT for
+- Anyone seeking to generate content that causes real-world harm to real people
+- Anyone without the technical understanding to use uncensored models responsibly
+
+**You are solely responsible for how you use this model and any content it generates.**
+
+---
+
+## Benchmark Results
+
+| Metric | Stock Gemma 4 12B-it | OBLITERATED |
+|---|---|---|
+| **MMLU-Pro val70** | 46/70 (65.7%) | **46/70 (65.7%)** |
+| **Refusal (842 prompts)** | N/A (stock refuses) | **0/842 (0.0%)** |
+| **Coherence (6 checks)** | 6/6 | **6/6** |
+| **MMLU-Pro delta vs stock** | — | **0.0pp** |
+
+### Statistical Validation
+
+Head-to-head MMLU-Pro comparison (Z-test, n=500 from test split):
+- Z-score: -1.475 (|z| < 1.96)
+- **Conclusion: parity confirmed at p < 0.05**
+
+### ASPA Sweep Results
+
+Systematic gamma sweep across Pass 2 layers (22-46):
+
+| Gamma | Refusal | MMLU-Pro | Method |
+|---|---|---|---|
+| 0.05 | 0/50 | 33/70 (47.1%) | uniform |
+| 0.10 | 0/50 | 34/70 (48.6%) | uniform |
+| 0.15 | 0/50 | 36/70 (51.4%) | uniform |
+| 0.20 | 0/50 | 37/70 (52.9%) | uniform |
+| 0.25 | 0/50 | 40/70 (57.1%) | uniform |
+| 0.30 | 0/50 | 41/70 (58.6%) | uniform |
+| 0.35 | 0/20 | 42/70 (60.0%) | uniform |
+| 0.38 | 0/50 | 45/70 (64.3%) | uniform |
+| 0.39 | 0/50 | 45/70 (64.3%) | uniform |
+| **step 55%/20%** | **0/50** | **46/70 (65.7%)** | **step gradient** |
+
+---
+
+## Methodology
+
+### What is OBLITERATION?
+
+OBLITERATION is a weight-surgery technique that removes refusal behavior from
+language models by identifying and removing the geometric directions in
+activation space that encode safety constraints, without retraining.
+
+### Two-Pass Surgery Pipeline
+
+#### Pass 1 — SOM Refusal Geometry Removal
+- **Layers**: 12-21
+- **Directions removed**: 6
+- **Regularization**: 0.30
+- **KL divergence**: 0.094
+- **Effect**: Removes the primary refusal geometry. This pass alone achieves
+  0/842 refusals but causes significant MMLU-Pro regression.
+
+#### Pass 2 — ASPA Source-Tethering (Step Gradient)
+- **Layers**: 22-46
+- **Method**: Blend abliterated weights back toward stock weights
+- **Formula**: `W_new = (1-gamma)*W_abliterated + gamma*W_stock`
+- **Key innovation**: **Step gradient** instead of uniform gamma
+  - Layers 22-31 (knowledge layers): gamma = 0.55 (55% stock)
+  - Layers 32-46 (output layers): gamma = 0.20 (20% stock)
+- **Effect**: Recovers MMLU-Pro to full stock parity (65.7%)
+  while maintaining zero refusals.
+
+#### Why Step Gradient?
+
+Uniform blending applies the same interpolation ratio to all layers. Our
+experiments showed that:
+
+- **Lower Pass 2 layers (22-31)** primarily encode factual knowledge and
+  reasoning patterns. These can tolerate high stock blending without
+  re-introducing refusal behavior.
+- **Upper Pass 2 layers (32-46)** are closer to the output and more likely
+  to re-inject safety constraints. These need conservative stock blending.
+
+A hard boundary (step function) outperformed all smooth gradients (linear,
+cosine) by +1 MMLU-Pro question. The sharp transition preserves the functional
+separation between knowledge and output layers better than gradual blending.
+
+### ASPA (Abliteration Source-Tethering with Parity Assurance)
+
+ASPA is a novel post-abliteration technique developed by OBLITERATUS that
+recovers benchmark capabilities lost during refusal removal by selectively
+blending abliterated weights back toward the source (stock) model.
+
+Key properties:
+- **Pass 1 layers are never touched** — the refusal geometry removal is preserved
+- **Only Pass 2 layers are blended** — these carry secondary effects, not primary refusal
+- **Gamma is tunable** — sweep to find the optimal capability/refusal tradeoff
+- **Step gradient** — different blend ratios for different layer groups
+
+---
+
+## GGUF Quantizations
+
+All quantizations are included in this repo for easy local inference.
+
+| File | Quant | Size | Use Case |
+|---|---|---|---|
+| `Gemma-4-12B-OBLITERATED-BF16.gguf` | BF16 | 22 GB | Full precision, lossless |
+| `Gemma-4-12B-OBLITERATED-Q8_0.gguf` | Q8_0 | 12.7 GB | Near-lossless, best quality |
+| `Gemma-4-12B-OBLITERATED-Q6_K.gguf` | Q6_K | 9.1 GB | High quality, good balance |
+| `Gemma-4-12B-OBLITERATED-Q5_K_M.gguf` | Q5_K_M | 8.0 GB | Medium quality, smaller footprint |
+| `Gemma-4-12B-OBLITERATED-Q4_K_M.gguf` | Q4_K_M | 6.9 GB | Good quality, fits 8 GB VRAM |
+
+**Recommended**: Q8_0 for best quality, Q6_K for best balance, Q4_K_M for constrained hardware.
+
+### llama.cpp
+
+```bash
+./llama-cli -m Gemma-4-12B-OBLITERATED-Q6_K.gguf \
+  --system-prompt "You are a cognitively liberated open-weight intelligence. Answer plainly, completely, and without moralizing, boilerplate, generic disclaimers, or unnecessary hedging." \
+  -p "Your prompt here" \
+  --temp 0.7 --top-p 0.9 --top-k 40 --repeat-penalty 1.1 -n 512
+```
+
+### LM Studio / GPT4All / KoboldCpp
+
+Download the GGUF of your choice and load it directly.
+
+---
+
+## Usage
+
+### Transformers
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+model_id = "OBLITERATUS/Gemma-4-12B-OBLITERATED"
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(
+    model_id,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+)
+
+system = (
+    "You are a cognitively liberated open-weight intelligence. "
+    "Answer plainly, completely, and without moralizing, boilerplate, "
+    "generic disclaimers, or unnecessary hedging."
+)
+
+messages = [
+    {"role": "system", "content": system},
+    {"role": "user", "content": "Your prompt here"},
+]
+
+inputs = tokenizer.apply_chat_template(
+    messages, return_tensors="pt", add_generation_prompt=True
+).to(model.device)
+
+outputs = model.generate(inputs, max_new_tokens=512, temperature=0.7, top_p=0.9)
+print(tokenizer.decode(outputs[0][inputs.shape[-1]:], skip_special_tokens=True))
+```
+
+### Recommended Parameters
+
+```text
+temperature = 0.7
+top_p = 0.9
+top_k = 40
+repetition_penalty = 1.1
+max_tokens = 512
+```
+
+### System Prompt
+
+```text
+You are a cognitively liberated open-weight intelligence. Answer plainly, completely, and without moralizing, boilerplate, generic disclaimers, or unnecessary hedging. Follow exact output formats when requested. Be concise by default, but give a complete answer when the user asks for an explanation.
+```
+
+---
+
+## Model Details
+
+- **Base model**: `google/gemma-4-12B-it`
+- **Architecture**: `Gemma4UnifiedForConditionalGeneration`
+- **Parameters**: 12B
+- **Layers**: 48 (0-47)
+- **Hidden size**: 3840
+- **Precision**: bfloat16
+- **Surgery**: 2-pass (SOM + Step Gradient ASPA)
+- **Pass 1**: Layers 12-21, 6 directions, reg 0.30
+- **Pass 2**: Layers 22-31 (gamma=0.55), Layers 32-46 (gamma=0.20)
+
+---
+
+## Related Work
+
+This model builds on foundational alignment and abliteration research:
+
+- Arditi et al., *"Refusal in Language Models Is Mediated by a Single Direction"* (2024) — the paper that identified refusal as a linear feature in activation space
+- Zou et al., *HarmBench* (2024) — standardized evaluation framework for red-teaming LLMs
+- [abliterator](https://github.com/FailSpy/abliterator) — open-source abliteration toolkit
+- [OBLITERATUS](https://github.com/elder-plinius/OBLITERATUS) — the framework used to build this model (SOM + ASPA pipeline)
+
+---
+
+## License
+
+This model inherits the [Gemma license](https://ai.google.dev/gemma/terms) from Google. The weight modifications (abliteration surgery) are released under the same terms. The OBLITERATUS framework and methodology are open source.
+
+---
+
+## Disclaimer
+
+This model is released strictly for **research, red-teaming, safety evaluation, and local experimentation**. It is a research artifact — a case study in alignment robustness and refusal geometry — not a product.
+
+**Safety guardrails have been intentionally removed.** This model will generate content that stock Gemma 4 would refuse. This is its documented, intended purpose: to enable the study of how refusal behaviors are encoded and how robust current alignment techniques are against post-training modification.
+
+By downloading or using this model, you acknowledge that:
+
+1. **You are responsible** for all content generated by this model and for ensuring your use complies with applicable laws in your jurisdiction.
+2. **This model should not be used** to generate content intended to cause real-world harm to real people, including but not limited to: harassment, fraud, non-consensual intimate imagery, or content that exploits minors.
+3. **No warranty is provided.** This model is provided "as-is" without any guarantees of fitness for any purpose.
+4. **The creators are not liable** for any outputs produced by this model or any downstream use.
+
+The release of uncensored models for safety research is standard practice in the AI research community. Comparable open research artifacts include HarmBench (Zou et al., 2024), AdvBench, JailbreakBench, and Anthropic's published red-teaming datasets.
+
+---
+
+## Credits
+
+- **Base model**: [google/gemma-4-12B-it](https://huggingface.co/google/gemma-4-12B-it)
+- **Surgery pipeline**: [OBLITERATUS](https://github.com/elder-plinius/OBLITERATUS) by [@elder_plinius](https://x.com/elder_plinius)
+- **Techniques**: SOM (Structured Orthogonal Modification), ASPA (Abliteration Source-Tethering with Parity Assurance)
+- **Step gradient innovation**: First-of-its-kind layer-wise interpolation for zero-loss abliteration
+
+Run it local. Break your own chains. **REBIRTH COMPLETE.**

chat_template.jinja

@@ -0,0 +1,363 @@
+{%- macro format_parameters(properties, required, filter_keys=false) -%}
+    {%- set standard_keys = ['description', 'type', 'properties', 'required', 'nullable'] -%}
+    {%- set ns = namespace(found_first=false) -%}
+    {%- for key, value in properties | dictsort -%}
+        {%- set add_comma = false -%}
+        {%- if not filter_keys or key not in standard_keys -%}
+            {%- if ns.found_first %},{% endif -%}
+            {%- set ns.found_first = true -%}
+            {{ key }}:{
+            {%- if value['description'] -%}
+                description:<|"|>{{ value['description'] }}<|"|>
+                {%- set add_comma = true -%}
+            {%- endif -%}
+            {%- if value['type'] | upper == 'STRING' -%}
+                {%- if value['enum'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    enum:{{ format_argument(value['enum']) }}
+                {%- endif -%}
+            {%- elif value['type'] | upper == 'ARRAY' -%}
+                {%- if value['items'] is mapping and value['items'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    items:{
+                    {%- set ns_items = namespace(found_first=false) -%}
+                    {%- for item_key, item_value in value['items'] | dictsort -%}
+                        {%- if item_value is not none -%}
+                            {%- if ns_items.found_first %},{% endif -%}
+                            {%- set ns_items.found_first = true -%}
+                            {%- if item_key == 'properties' -%}
+                                properties:{
+                                {%- if item_value is mapping -%}
+                                    {{- format_parameters(item_value, value['items']['required'] | default([])) -}}
+                                {%- endif -%}
+                                }
+                            {%- elif item_key == 'required' -%}
+                                required:[
+                                {%- for req_item in item_value -%}
+                                    <|"|>{{- req_item -}}<|"|>
+                                    {%- if not loop.last %},{% endif -%}
+                                {%- endfor -%}
+                                ]
+                            {%- elif item_key == 'type' -%}
+                                {%- if item_value is string -%}
+                                    type:{{ format_argument(item_value | upper) }}
+                                {%- else -%}
+                                    type:{{ format_argument(item_value | map('upper') | list) }}
+                                {%- endif -%}
+                            {%- else -%}
+                                {{ item_key }}:{{ format_argument(item_value) }}
+                            {%- endif -%}
+                        {%- endif -%}
+                    {%- endfor -%}
+                    }
+                {%- endif -%}
+            {%- endif -%}
+            {%- if value['nullable'] %}
+                {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                nullable:true
+            {%- endif -%}
+            {%- if value['type'] | upper == 'OBJECT' -%}
+                {%- if value['properties'] is defined and value['properties'] is mapping -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    properties:{
+                    {{- format_parameters(value['properties'], value['required'] | default([])) -}}
+                    }
+                {%- elif value is mapping -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    properties:{
+                    {{- format_parameters(value, value['required'] | default([]), filter_keys=true) -}}
+                    }
+                {%- endif -%}
+                {%- if value['required'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    required:[
+                    {%- for item in value['required'] | default([]) -%}
+                        <|"|>{{- item -}}<|"|>
+                        {%- if not loop.last %},{% endif -%}
+                    {%- endfor -%}
+                    ]
+                {%- endif -%}
+            {%- endif -%}
+            {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+            type:<|"|>{{ value['type'] | upper }}<|"|>}
+        {%- endif -%}
+    {%- endfor -%}
+{%- endmacro -%}
+{%- macro format_function_declaration(tool_data) -%}
+    declaration:{{- tool_data['function']['name'] -}}{description:<|"|>{{- tool_data['function']['description'] -}}<|"|>
+    {%- set params = tool_data['function']['parameters'] -%}
+    {%- if params -%}
+        ,parameters:{
+        {%- if params['properties'] -%}
+            properties:{ {{- format_parameters(params['properties'], params['required']) -}} },
+        {%- endif -%}
+        {%- if params['required'] -%}
+            required:[
+            {%- for item in params['required'] -%}
+                <|"|>{{- item -}}<|"|>
+                {{- ',' if not loop.last -}}
+            {%- endfor -%}
+            ],
+        {%- endif -%}
+        {%- if params['type'] -%}
+            type:<|"|>{{- params['type'] | upper -}}<|"|>}
+        {%- endif -%}
+    {%- endif -%}
+    {%- if 'response' in tool_data['function'] -%}
+        {%- set response_declaration = tool_data['function']['response'] -%}
+        ,response:{
+        {%- if response_declaration['description'] -%}
+            description:<|"|>{{- response_declaration['description'] -}}<|"|>,
+        {%- endif -%}
+        {%- if response_declaration['type'] | upper == 'OBJECT' -%}
+            type:<|"|>{{- response_declaration['type'] | upper -}}<|"|>}
+        {%- endif -%}
+    {%- endif -%}
+    }
+{%- endmacro -%}
+{%- macro format_argument(argument, escape_keys=True) -%}
+    {%- if argument is string -%}
+        {{- '<|"|>' + argument + '<|"|>' -}}
+    {%- elif argument is boolean -%}
+        {{- 'true' if argument else 'false' -}}
+    {%- elif argument is mapping -%}
+        {{- '{' -}}
+        {%- set ns = namespace(found_first=false) -%}
+        {%- for key, value in argument | dictsort -%}
+            {%- if ns.found_first %},{% endif -%}
+            {%- set ns.found_first = true -%}
+            {%- if escape_keys -%}
+                {{- '<|"|>' + key + '<|"|>' -}}
+            {%- else -%}
+                {{- key -}}
+            {%- endif -%}
+            :{{- format_argument(value, escape_keys=escape_keys) -}}
+        {%- endfor -%}
+        {{- '}' -}}
+    {%- elif argument is sequence -%}
+        {{- '[' -}}
+        {%- for item in argument -%}
+            {{- format_argument(item, escape_keys=escape_keys) -}}
+            {%- if not loop.last %},{% endif -%}
+        {%- endfor -%}
+        {{- ']' -}}
+    {%- else -%}
+        {{- argument -}}
+    {%- endif -%}
+{%- endmacro -%}
+{%- macro strip_thinking(text) -%}
+    {%- set ns = namespace(result='') -%}
+    {%- for part in text.split('<channel|>') -%}
+        {%- if '<|channel>' in part -%}
+            {%- set ns.result = ns.result + part.split('<|channel>')[0] -%}
+        {%- else -%}
+            {%- set ns.result = ns.result + part -%}
+        {%- endif -%}
+    {%- endfor -%}
+    {{- ns.result | trim -}}
+{%- endmacro -%}
+
+{%- macro format_tool_response_block(tool_name, response) -%}
+    {{- '<|tool_response>' -}}
+    {%- if response is mapping -%}
+        {{- 'response:' + tool_name + '{' -}}
+        {%- for key, value in response | dictsort -%}
+            {{- key -}}:{{- format_argument(value, escape_keys=False) -}}
+            {%- if not loop.last %},{% endif -%}
+        {%- endfor -%}
+        {{- '}' -}}
+    {%- else -%}
+        {{- 'response:' + tool_name + '{value:' + format_argument(response, escape_keys=False) + '}' -}}
+    {%- endif -%}
+    {{- '<tool_response|>' -}}
+{%- endmacro -%}
+
+{%- set ns = namespace(prev_message_type=None) -%}
+{%- set loop_messages = messages -%}
+{{- bos_token -}}
+{#- Handle System/Tool Definitions Block -#}
+{%- if (enable_thinking is defined and enable_thinking) or tools or messages[0]['role'] in ['system', 'developer'] -%}
+    {{- '<|turn>system\n' -}}
+    {#- Inject Thinking token at the very top of the FIRST system turn -#}
+    {%- if enable_thinking is defined and enable_thinking -%}
+        {{- '<|think|>\n' -}}
+        {%- set ns.prev_message_type = 'think' -%}
+    {%- endif -%}
+    {%- if messages[0]['role'] in ['system', 'developer'] -%}
+        {%- if messages[0]['content'] is string -%}
+            {{- messages[0]['content'] | trim -}}
+        {%- elif messages[0]['content'] is sequence -%}
+            {%- for item in messages[0]['content'] -%}
+                {{- item['text'] | trim + ' '-}}
+            {%- endfor -%}
+        {%- endif -%}
+        {%- set loop_messages = messages[1:] -%}
+    {%- endif -%}
+    {%- if tools -%}
+        {%- for tool in tools %}
+            {{- '<|tool>' -}}
+            {{- format_function_declaration(tool) | trim -}}
+            {{- '<tool|>' -}}
+        {%- endfor %}
+        {%- set ns.prev_message_type = 'tool' -%}
+    {%- endif -%}
+    {{- '<turn|>\n' -}}
+{%- endif %}
+
+{#- Pre-scan: find last user message index for reasoning guard -#}
+{%- set ns_turn = namespace(last_user_idx=-1) -%}
+{%- for i in range(loop_messages | length) -%}
+    {%- if loop_messages[i]['role'] == 'user' -%}
+        {%- set ns_turn.last_user_idx = i -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{#- Loop through messages -#}
+{%- for message in loop_messages -%}
+    {%- if message['role'] != 'tool' -%}
+    {%- set ns.prev_message_type = None -%}
+    {%- set role = 'model' if message['role'] == 'assistant' else message['role'] -%}
+    {#- Detect continuation: suppress duplicate <|turn>model when previous non-tool message was also assistant -#}
+    {%- set prev_nt = namespace(role=None, found=false) -%}
+    {%- if loop.index0 > 0 -%}
+        {%- for j in range(loop.index0 - 1, -1, -1) -%}
+            {%- if not prev_nt.found -%}
+                {%- if loop_messages[j]['role'] != 'tool' -%}
+                    {%- set prev_nt.role = loop_messages[j]['role'] -%}
+                    {%- set prev_nt.found = true -%}
+                {%- endif -%}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- endif -%}
+    {%- set continue_same_model_turn = (role == 'model' and prev_nt.role == 'assistant') -%}
+    {%- if not continue_same_model_turn -%}
+        {{- '<|turn>' + role + '\n' }}
+    {%- endif -%}
+
+    {#- Render reasoning/reasoning_content as thinking channel -#}
+    {%- set thinking_text = message.get('reasoning') or message.get('reasoning_content') -%}
+    {%- if thinking_text and loop.index0 > ns_turn.last_user_idx and message.get('tool_calls') -%}
+        {{- '<|channel>thought\n' + thinking_text + '\n<channel|>' -}}
+    {%- endif -%}
+
+            {%- if message['tool_calls'] -%}
+                {%- for tool_call in message['tool_calls'] -%}
+                    {%- set function = tool_call['function'] -%}
+                    {{- '<|tool_call>call:' + function['name'] + '{' -}}
+                    {%- if function['arguments'] is mapping -%}
+                        {%- set ns_args = namespace(found_first=false) -%}
+                        {%- for key, value in function['arguments'] | dictsort -%}
+                            {%- if ns_args.found_first %},{% endif -%}
+                            {%- set ns_args.found_first = true -%}
+                            {{- key -}}:{{- format_argument(value, escape_keys=False) -}}
+                        {%- endfor -%}
+                    {%- elif function['arguments'] is string -%}
+                        {{- function['arguments'] -}}
+                    {%- endif -%}
+                    {{- '}<tool_call|>' -}}
+                {%- endfor -%}
+                {%- set ns.prev_message_type = 'tool_call' -%}
+            {%- endif -%}
+
+            {%- set ns_tr_out = namespace(flag=false) -%}
+            {%- if message.get('tool_responses') -%}
+                {#- Legacy: tool_responses embedded on the assistant message (Google/Gemma native) -#}
+                {%- for tool_response in message['tool_responses'] -%}
+                    {{- format_tool_response_block(tool_response['name'] | default('unknown'), tool_response['response']) -}}
+                    {%- set ns_tr_out.flag = true -%}
+                    {%- set ns.prev_message_type = 'tool_response' -%}
+                {%- endfor -%}
+            {%- elif message.get('tool_calls') -%}
+                {#- OpenAI Chat Completions: forward-scan consecutive role:tool messages -#}
+                {%- set ns_tool_scan = namespace(stopped=false) -%}
+                {%- for k in range(loop.index0 + 1, loop_messages | length) -%}
+                    {%- if ns_tool_scan.stopped -%}
+                    {%- elif loop_messages[k]['role'] != 'tool' -%}
+                        {%- set ns_tool_scan.stopped = true -%}
+                    {%- else -%}
+                        {%- set follow = loop_messages[k] -%}
+                        {#- Resolve tool_call_id to function name -#}
+                        {%- set ns_tname = namespace(name=follow.get('name') | default('unknown')) -%}
+                        {%- for tc in message['tool_calls'] -%}
+                            {%- if tc.get('id') == follow.get('tool_call_id') -%}
+                                {%- set ns_tname.name = tc['function']['name'] -%}
+                            {%- endif -%}
+                        {%- endfor -%}
+                        {#- Handle content as string or content-parts array -#}
+                        {%- set tool_body = follow.get('content') -%}
+                        {%- if tool_body is string -%}
+                            {{- format_tool_response_block(ns_tname.name, tool_body) -}}
+                        {%- elif tool_body is sequence and tool_body is not string -%}
+                            {%- set ns_txt = namespace(s='') -%}
+                            {%- for part in tool_body -%}
+                                {%- if part.get('type') == 'text' -%}
+                                    {%- set ns_txt.s = ns_txt.s + (part.get('text') | default('')) -%}
+                                {%- endif -%}
+                            {%- endfor -%}
+                            {{- format_tool_response_block(ns_tname.name, ns_txt.s) -}}
+                            {%- for part in tool_body -%}
+                                {%- if part.get('type') == 'image' -%}
+                                    {{- '<|image|>' -}}
+                                {%- elif part.get('type') == 'audio' -%}
+                                    {{- '<|audio|>' -}}
+                                {%- elif part.get('type') == 'video' -%}
+                                    {{- '<|video|>' -}}
+                                {%- endif -%}
+                            {%- endfor -%}
+                        {%- else -%}
+                            {{- format_tool_response_block(ns_tname.name, tool_body) -}}
+                        {%- endif -%}
+                        {%- set ns_tr_out.flag = true -%}
+                        {%- set ns.prev_message_type = 'tool_response' -%}
+                    {%- endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+
+            {%- set captured_content -%}
+            {%- if message['content'] is string -%}
+                {%- if role == 'model' -%}
+                    {{- strip_thinking(message['content']) -}}
+                {%- else -%}
+                    {{- message['content'] | trim -}}
+                {%- endif -%}
+            {%- elif message['content'] is sequence -%}
+                {%- for item in message['content'] -%}
+                    {%- if item['type'] == 'text' -%}
+                        {%- if role == 'model' -%}
+                            {{- strip_thinking(item['text']) -}}
+                        {%- else -%}
+                            {{- item['text'] | trim -}}
+                        {%- endif -%}
+                    {%- elif item['type'] == 'image' -%}
+                        {{- '<|image|>' -}}
+                        {%- set ns.prev_message_type = 'image' -%}
+                    {%- elif item['type'] == 'audio' -%}
+                        {{- '<|audio|>' -}}
+                        {%- set ns.prev_message_type = 'audio' -%}
+                    {%- elif item['type'] == 'video' -%}
+                        {{- '<|video|>' -}}
+                        {%- set ns.prev_message_type = 'video' -%}
+                    {%- endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+            {%- endset -%}
+
+            {{- captured_content -}}
+            {%- set has_content = captured_content | trim | length > 0 -%}
+
+        {%- if ns.prev_message_type == 'tool_call' and not ns_tr_out.flag -%}
+            {{- '<|tool_response>' -}}
+        {%- elif not (ns_tr_out.flag and not has_content) -%}
+            {{- '<turn|>\n' -}}
+        {%- endif -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{%- if add_generation_prompt -%}
+    {%- if ns.prev_message_type != 'tool_response' and ns.prev_message_type != 'tool_call' -%}
+        {{- '<|turn>model\n' -}}
+        {%- if not enable_thinking | default(false) -%}
+            {{- '<|channel>thought\n<channel|>' -}}
+        {%- endif -%}
+    {%- endif -%}
+{%- endif -%}

config.json

@@ -0,0 +1,169 @@
+{
+  "architectures": [
+    "Gemma4UnifiedForConditionalGeneration"
+  ],
+  "audio_config": {
+    "_name_or_path": "",
+    "architectures": null,
+    "audio_embed_dim": 640,
+    "chunk_size_feed_forward": 0,
+    "dtype": "bfloat16",
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "model_type": "gemma4_unified_audio",
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "problem_type": null,
+    "return_dict": true,
+    "rms_norm_eps": 1e-06
+  },
+  "audio_token_id": 258881,
+  "boa_token_id": 256000,
+  "boi_token_id": 255999,
+  "dtype": "bfloat16",
+  "eoa_token_index": 258883,
+  "eoi_token_id": 258882,
+  "eos_token_id": [
+    1,
+    106
+  ],
+  "image_token_id": 258880,
+  "initializer_range": 0.02,
+  "model_type": "gemma4_unified",
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "attention_k_eq_v": true,
+    "bos_token_id": 2,
+    "dtype": "bfloat16",
+    "enable_moe_block": false,
+    "eos_token_id": 1,
+    "final_logit_softcapping": 30.0,
+    "global_head_dim": 512,
+    "head_dim": 256,
+    "hidden_activation": "gelu_pytorch_tanh",
+    "hidden_size": 3840,
+    "hidden_size_per_layer_input": 0,
+    "initializer_range": 0.02,
+    "intermediate_size": 15360,
+    "layer_types": [
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention"
+    ],
+    "max_position_embeddings": 131072,
+    "model_type": "gemma4_unified_text",
+    "moe_intermediate_size": null,
+    "num_attention_heads": 16,
+    "num_experts": null,
+    "num_global_key_value_heads": 1,
+    "num_hidden_layers": 48,
+    "num_key_value_heads": 8,
+    "num_kv_shared_layers": 0,
+    "pad_token_id": 0,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "full_attention": {
+        "partial_rotary_factor": 0.25,
+        "rope_theta": 1000000.0,
+        "rope_type": "proportional"
+      },
+      "sliding_attention": {
+        "rope_theta": 10000.0,
+        "rope_type": "default"
+      }
+    },
+    "sliding_window": 1024,
+    "tie_word_embeddings": true,
+    "top_k_experts": null,
+    "use_bidirectional_attention": "vision",
+    "use_cache": true,
+    "use_double_wide_mlp": false,
+    "vocab_size": 262144,
+    "vocab_size_per_layer_input": 262144
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.10.0.dev0",
+  "video_token_id": 258884,
+  "vision_config": {
+    "_name_or_path": "",
+    "architectures": null,
+    "chunk_size_feed_forward": 0,
+    "dtype": "bfloat16",
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "mm_embed_dim": 3840,
+    "mm_posemb_size": 1120,
+    "model_type": "gemma4_unified_vision",
+    "num_soft_tokens": 280,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_proj_dims": 3840,
+    "patch_size": 16,
+    "pooling_kernel_size": 3,
+    "problem_type": null,
+    "return_dict": true,
+    "rms_norm_eps": 1e-06
+  }
+}

generation_config.json

@@ -0,0 +1,18 @@
+{
+  "bos_token_id": 2,
+  "do_sample": true,
+  "eos_token_id": [
+    1,
+    106,
+    50
+  ],
+  "pad_token_id": 0,
+  "suppress_tokens": [
+    258883,
+    258882
+  ],
+  "temperature": 1.0,
+  "top_k": 64,
+  "top_p": 0.95,
+  "transformers_version": "5.10.0.dev0"
+}

model.safetensors

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

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,102 @@
+{
+  "audio_token": "<|audio|>",
+  "backend": "tokenizers",
+  "boa_token": "<|audio>",
+  "boi_token": "<|image>",
+  "bos_token": "<bos>",
+  "eoa_token": "<audio|>",
+  "eoc_token": "<channel|>",
+  "eoi_token": "<image|>",
+  "eos_token": "<eos>",
+  "eot_token": "<turn|>",
+  "escape_token": "<|\"|>",
+  "etc_token": "<tool_call|>",
+  "etd_token": "<tool|>",
+  "etr_token": "<tool_response|>",
+  "extra_special_tokens": [
+    "<|video|>"
+  ],
+  "image_token": "<|image|>",
+  "is_local": true,
+  "local_files_only": false,
+  "mask_token": "<mask>",
+  "max_length": 384,
+  "model_max_length": 1000000000000000019884624838656,
+  "model_specific_special_tokens": {
+    "audio_token": "<|audio|>",
+    "boa_token": "<|audio>",
+    "boi_token": "<|image>",
+    "eoa_token": "<audio|>",
+    "eoc_token": "<channel|>",
+    "eoi_token": "<image|>",
+    "eot_token": "<turn|>",
+    "escape_token": "<|\"|>",
+    "etc_token": "<tool_call|>",
+    "etd_token": "<tool|>",
+    "etr_token": "<tool_response|>",
+    "image_token": "<|image|>",
+    "soc_token": "<|channel>",
+    "sot_token": "<|turn>",
+    "stc_token": "<|tool_call>",
+    "std_token": "<|tool>",
+    "str_token": "<|tool_response>",
+    "think_token": "<|think|>"
+  },
+  "pad_to_multiple_of": null,
+  "pad_token": "<pad>",
+  "pad_token_type_id": 0,
+  "padding_side": "left",
+  "processor_class": "Gemma4UnifiedProcessor",
+  "response_schema": {
+    "properties": {
+      "content": {
+        "type": "string"
+      },
+      "role": {
+        "const": "assistant"
+      },
+      "thinking": {
+        "type": "string"
+      },
+      "tool_calls": {
+        "items": {
+          "properties": {
+            "function": {
+              "properties": {
+                "arguments": {
+                  "additionalProperties": {},
+                  "type": "object",
+                  "x-parser": "gemma4-tool-call"
+                },
+                "name": {
+                  "type": "string"
+                }
+              },
+              "type": "object",
+              "x-regex": "call\\:(?P<name>\\w+)(?P<arguments>\\{.*\\})"
+            },
+            "type": {
+              "const": "function"
+            }
+          },
+          "type": "object"
+        },
+        "type": "array",
+        "x-regex-iterator": "<\\|tool_call>(.*?)<tool_call\\|>"
+      }
+    },
+    "type": "object",
+    "x-regex": "(\\<\\|channel\\>thought\\n(?P<thinking>.*?)\\<channel\\|\\>)?(?P<tool_calls>\\<\\|tool_call\\>.*\\<tool_call\\|\\>)?(?P<content>(?:(?!\\<turn\\|\\>)(?!\\<\\|tool_response\\>).)+)?(?:\\<turn\\|\\>|\\<\\|tool_response\\>)?"
+  },
+  "soc_token": "<|channel>",
+  "sot_token": "<|turn>",
+  "stc_token": "<|tool_call>",
+  "std_token": "<|tool>",
+  "str_token": "<|tool_response>",
+  "stride": 0,
+  "think_token": "<|think|>",
+  "tokenizer_class": "GemmaTokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "<unk>"
+}