Update README

LICENSE

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2026 Beijing Institute for General Artificial Intelligence
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

NOTICE

@@ -1,6 +0,0 @@
-GS1
-Copyright 2026 BIGAI.
-
-GS1 uses Qwen3.5 components from Hugging Face Transformers under Apache-2.0.
-Third-party libraries retain their respective copyright and licenses.
-Model weights are distributed under the license stated in each model card.

README.md

@@ -12,15 +12,13 @@ base_model:
 ---
 # GS1-0.8B
 
-[English](README.md) · [简体中文](README.zh-CN.md)
-
 ![GS1 — Fast, Faithful, Frontier](assets/banner.svg)
 
 > ***Fast, Faithful, Frontier System One Intelligence.***
 
 [Code](https://github.com/bigai-nlco/GS1) · [Model](https://huggingface.co/collections/bigai/gs1) · [Documentation](https://github.com/bigai-nlco/GS1/blob/main/docs/README.md) · [Playground](https://github.com/bigai-nlco/GS1/blob/main/playground/README.md)
 
-**GS1-0.8B** is an open-source decision model developed by **BIGAI** (Beijing Institute for General Artificial Intelligence). It computes native probability distributions over runtime-defined candidates for agent routing, verification, extraction and control.
+**GS1** is a family of open-source decision models developed by **BIGAI** (Beijing Institute for General Artificial Intelligence). It computes native probability distributions over runtime-defined candidates for agent routing, verification, extraction and control.
 
 ## GS1 Highlights
 
@@ -216,6 +214,8 @@ print(result["usage"])
 
 The response contains `model`, `answers` and `usage`. Choice preserves candidate IDs and returns every candidate probability; Noul returns `p(true)`; Score returns the expected zero-based rubric level and its full probability distribution. Generated `output_tokens` is zero.
 
+`chat_template.jinja` renders the native GS1 state, question and options, including XML escaping, the trained user/assistant boundaries, the empty thinking prefix and `<|decide|>`. It is exported from the same serializer in `compiler.py`. `model.decide` prepares typed candidates, branch spans, masks, positions and budget checks. [Native template usage](https://github.com/bigai-nlco/GS1/blob/main/docs/inference.md#native-decision-template)
+
 ### GS1 Runtime
 
 The GS1 runtime adds shared-state reuse, compatible batching, HTTP serving and qualified CUDA Graph replay:
@@ -277,4 +277,4 @@ If you find our work helpful, feel free to give us a cite.
   institution={BIGAI},
   year={2026}
 }
-```
+```

README.zh-CN.md

@@ -1,111 +0,0 @@
-# GS1-0.8B
-
-[English](README.md) · [简体中文](README.zh-CN.md)
-
-![GS1](assets/banner.svg)
-
-**Fast, Faithful, Frontier.** GS1-0.8B 是原生类型化决策模型。输入状态、问题和运行时定义的候选含义，直接获得 **Choice、Noul、Score** 分布，生成输出 token 数为零。
-
-[代码与优化推理](https://github.com/bigai-nlco/GS1) · [模型合集](https://huggingface.co/collections/bigai/gs1) · [完整结果](https://github.com/bigai-nlco/GS1/blob/main/benchmark/results.md)
-
-| 指标 | GS1-0.8B |
-|---|---:|
-| 实际存储参数量 | 879,765,056 |
-| 37 项公开 Decision Index | **56.12** |
-| JevBench 公开任务准确率，231 个决策 | **77.92%** |
-| AG News 测试准确率，7,600 个决策 | **90.99%** |
-| ToolACE 选择准确率，640 个决策 | **93.28%** |
-| CUDA Graph 完整热决策 P50 / P95 | **12.51 / 13.22 ms** |
-| 上述延迟设置的峰值已分配显存 | **4.07 GiB** |
-
-Decision Index 来自公开 edition 0.3 的完整评测：115,479 个唯一请求、279,333 个决策、最终覆盖率 100%，采用 BF16 原生参考计算；该分数与私有 Full 分数分开。三项常规榜单于 2026 年 11 月 9 日完成，均无失败、无重试。JevBench 公开任务准确率不等同于密封榜单综合分；ToolACE 是固定哈希子集的首个工具/不调用工具选择，不评估参数生成。
-
-延迟于 2026 年 11 月 9 日测量：报告 48 GiB 的 RTX 4090、BF16 计算、最长分支 256 token、单问题、单 GPU，预热五次、测量 30 次。进程内完整计时包含校验、编译、模型计算和概率，排除加载、图捕获、HTTP 与 SDK 传输。[决策指标](assets/results/public-evaluation.json) · [原始延迟样本](assets/results/inference-latency.json) · [测量方法和全部型号](https://github.com/bigai-nlco/GS1/blob/main/benchmark/latency.md)
-
-## Hugging Face 默认推理
-
-**不需要安装或导入 GS1 仓库。** 使用 Python 3.11+，安装本目录的依赖：
-
-```bash
-python -m pip install -r requirements.txt
-```
-
-```python
-from transformers import AutoModel
-
-model = AutoModel.from_pretrained(
-    "bigai/GS1-0.8B",  # a local GS1-0.8B directory also works
-    trust_remote_code=True,
-).eval().to("cuda")
-
-result = model.decide(
-    state="A customer was charged twice and asks for a refund.",
-    questions={
-        "team": {
-            "type": "choice",
-            "instructions": "Choose the team that should handle this ticket.",
-            "criteria": {"billing": "Payments and refunds", "technical": "Software problems"},
-        },
-        "refund": {"type": "noul", "instructions": "Does the customer request a refund?"},
-        "urgency": {
-            "type": "score",
-            "instructions": "Rate the urgency of handling this ticket.",
-            "criteria": ["Routine", "Soon", "Immediate"],
-        },
-    },
-)
-print(result["answers"])
-```
-
-上传前也可以将模型 ID 替换为本地完整目录。`trust_remote_code=True` 加载本目录提供的模型代码。默认保留原始混合存储精度，复现测量时不要整体转换权重 dtype。兼容的 CPU PyTorch 环境可使用 `.to("cpu")` 和 `decide(..., precision="fp32")`。默认 eager 路径可选安装上游 CUDA 算子；实测环境使用 `flash-linear-attention[cuda]==0.5.2` 和 `causal-conv1d==1.7.0`。
-
-返回值包含 `model`、`answers` 和 `usage`。Choice 返回候选 ID、所有候选概率及 confidence；Noul 返回 `p(true)`；Score 返回从零开始的量表等级期望及各等级概率。输出 token 用量为零。默认实现逐问题执行完整分支，不依赖运行时资格文件或图捕获。
-
-## GS1 优化推理
-
-GS1 仓库为相同权重提供源码绑定的 CUDA Graph、兼容批处理、状态共享、HTTP 服务和 playground。
-
-```bash
-git clone https://github.com/bigai-nlco/GS1.git
-cd GS1
-uv sync --locked --extra serve --extra cuda
-uv run gs1 serve --model bigai/GS1-0.8B --model-name GS1
-```
-
-在源码目录中额外安装 `--extra eval`，再针对本机模型、实现、硬件和请求形状执行图资格验证：
-
-```bash
-uv run python -m benchmark.inference --model bigai/GS1-0.8B \
-  --out runs/runtime.json --runtime-profile-out runs/profile.json \
-  --graph-cache-mb 16384 --graph-cache-entries 128
-
-uv run gs1 serve --model bigai/GS1-0.8B --model-name GS1 \
-  --runtime-profile runs/profile.json --experimental-cuda-graphs \
-  --graph-warmup-requests runs/profile-warmup.json \
-  --graph-cache-mb 4096 --graph-cache-entries 128
-```
-
-benchmark 同时生成 `profile-warmup.json`。服务启动时预热已知图；图未命中回退原生 eager，未验证形状回退单分支参考计算。代码、模型、精度或硬件改变后需重新验证；资格文件留在本地，不作为权重上传。[完整推理指南](https://github.com/bigai-nlco/GS1/blob/main/docs/inference.zh-CN.md)
-
-## 架构与数值策略
-
-![架构](assets/architecture.svg)
-
-GS1-0.8B 的隐藏宽度为 1,024，包含 24 个解码层��� 4 个决策注意力头。架构结合 Qwen3.5 混合 GDN/注意力骨干、分段双向全注意力、保持残差累加的 Attention Residuals，以及两层候选路由、256 维最终比较空间的原生交叉注意力决策头。不包含语言生成输出头，候选含义在推理时提供，无固定任务分类词表。
-
-文本和决策头持久权重为 FP32，保留的视觉塔为 BF16；配置指定决策头采用 BF16 计算，最终 logits 和概率归约使用 FP32。完整分支上限为 65,536 token，同时受准入和显存预算约束；默认 HTTP 服务使用更紧的 4,096-token 上限。公开决策结果均为纯文本评测。`config.json` 保存原生定义、token ID 和 `inference_limits`；safetensors 参数键和 dtype 均完整保留。
-
-## 适用范围与许可
-
-适合路由、分类、工具选择、有限选项判断等类型化决策。概率不保证正确，校准效果依赖任务分布。公开结果也完整展示限制：HLE 准确率较低，未启用置信拒答时较大模型的 AA-Omniscience 非幻觉率为零；详见[完整组件结果](assets/results/public-evaluation.json)。
-
-代码与发布权重采用 [Apache-2.0](LICENSE)，[上游署名](NOTICE) 保留。本目录包含模型架构和推理依赖；评测输入与本地运行时资格文件另行保存。
-
-```bibtex
-@techreport{zheng2026gs1,
-  title={GS1: Fast, Faithful, Frontier System One Intelligence},
-  author={Zheng, Zilong and Liu, Yang and Qin, Shuhan and Lin, Ziyong and Li, Jiaqi and Jia, Zixia and Zhu, Song-Chun},
-  institution={BIGAI},
-  year={2026}
-}
-```

chat_template.jinja

@@ -1,154 +1,52 @@
-{%- set image_count = namespace(value=0) %}
-{%- set video_count = namespace(value=0) %}
-{%- macro render_content(content, do_vision_count, is_system_content=false) %}
-    {%- if content is string %}
-        {{- content }}
-    {%- elif content is iterable and content is not mapping %}
-        {%- for item in content %}
-            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
-                {%- if is_system_content %}
-                    {{- raise_exception('System message cannot contain images.') }}
-                {%- endif %}
-                {%- if do_vision_count %}
-                    {%- set image_count.value = image_count.value + 1 %}
-                {%- endif %}
-                {%- if add_vision_id %}
-                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
-                {%- endif %}
-                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
-            {%- elif 'video' in item or item.type == 'video' %}
-                {%- if is_system_content %}
-                    {{- raise_exception('System message cannot contain videos.') }}
-                {%- endif %}
-                {%- if do_vision_count %}
-                    {%- set video_count.value = video_count.value + 1 %}
-                {%- endif %}
-                {%- if add_vision_id %}
-                    {{- 'Video ' ~ video_count.value ~ ': ' }}
-                {%- endif %}
-                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
-            {%- elif 'text' in item %}
-                {{- item.text }}
-            {%- else %}
-                {{- raise_exception('Unexpected item type in content.') }}
-            {%- endif %}
-        {%- endfor %}
-    {%- elif content is none or content is undefined %}
-        {{- '' }}
-    {%- else %}
-        {{- raise_exception('Unexpected content type.') }}
-    {%- endif %}
-{%- endmacro %}
-{%- if not messages %}
-    {{- raise_exception('No messages provided.') }}
-{%- endif %}
-{%- if tools and tools is iterable and tools is not mapping %}
-    {{- '<|im_start|>system\n' }}
-    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
-    {%- for tool in tools %}
-        {{- "\n" }}
-        {{- tool | tojson }}
-    {%- endfor %}
-    {{- "\n</tools>" }}
-    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
-    {%- if messages[0].role == 'system' %}
-        {%- set content = render_content(messages[0].content, false, true)|trim %}
-        {%- if content %}
-            {{- '\n\n' + content }}
-        {%- endif %}
-    {%- endif %}
-    {{- '<|im_end|>\n' }}
-{%- else %}
-    {%- if messages[0].role == 'system' %}
-        {%- set content = render_content(messages[0].content, false, true)|trim %}
-        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
-    {%- endif %}
-{%- endif %}
-{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
-{%- for message in messages[::-1] %}
-    {%- set index = (messages|length - 1) - loop.index0 %}
-    {%- if ns.multi_step_tool and message.role == "user" %}
-        {%- set content = render_content(message.content, false)|trim %}
-        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
-            {%- set ns.multi_step_tool = false %}
-            {%- set ns.last_query_index = index %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- if ns.multi_step_tool %}
-    {{- raise_exception('No user query found in messages.') }}
-{%- endif %}
-{%- for message in messages %}
-    {%- set content = render_content(message.content, true)|trim %}
-    {%- if message.role == "system" %}
-        {%- if not loop.first %}
-            {{- raise_exception('System message must be at the beginning.') }}
-        {%- endif %}
-    {%- elif message.role == "user" %}
-        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
-    {%- elif message.role == "assistant" %}
-        {%- set reasoning_content = '' %}
-        {%- if message.reasoning_content is string %}
-            {%- set reasoning_content = message.reasoning_content %}
-        {%- else %}
-            {%- if '</think>' in content %}
-                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
-                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
-            {%- endif %}
-        {%- endif %}
-        {%- set reasoning_content = reasoning_content|trim %}
-        {%- if loop.index0 > ns.last_query_index %}
-            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
-        {%- else %}
-            {{- '<|im_start|>' + message.role + '\n' + content }}
-        {%- endif %}
-        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
-            {%- for tool_call in message.tool_calls %}
-                {%- if tool_call.function is defined %}
-                    {%- set tool_call = tool_call.function %}
-                {%- endif %}
-                {%- if loop.first %}
-                    {%- if content|trim %}
-                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
-                    {%- else %}
-                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
-                    {%- endif %}
-                {%- else %}
-                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
-                {%- endif %}
-                {%- if tool_call.arguments is defined %}
-                    {%- for args_name, args_value in tool_call.arguments|items %}
-                        {{- '<parameter=' + args_name + '>\n' }}
-                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
-                        {{- args_value }}
-                        {{- '\n</parameter>\n' }}
-                    {%- endfor %}
-                {%- endif %}
-                {{- '</function>\n</tool_call>' }}
-            {%- endfor %}
-        {%- endif %}
-        {{- '<|im_end|>\n' }}
-    {%- elif message.role == "tool" %}
-        {%- if loop.previtem and loop.previtem.role != "tool" %}
-            {{- '<|im_start|>user' }}
-        {%- endif %}
-        {{- '\n<tool_response>\n' }}
-        {{- content }}
-        {{- '\n</tool_response>' }}
-        {%- if not loop.last and loop.nextitem.role != "tool" %}
-            {{- '<|im_end|>\n' }}
-        {%- elif loop.last %}
-            {{- '<|im_end|>\n' }}
-        {%- endif %}
-    {%- else %}
-        {{- raise_exception('Unexpected message role.') }}
-    {%- endif %}
-{%- endfor %}
-{%- if add_generation_prompt %}
-    {{- '<|im_start|>assistant\n' }}
-    {%- if enable_thinking is defined and enable_thinking is true %}
-        {{- '<think>\n' }}
-    {%- else %}
-        {{- '<think>\n\n</think>\n\n' }}
-    {%- endif %}
-{%- endif %}
+{# GS1 typed decision prompt. question/options are normalized by Compiler. #}
+{%- macro xml_text(value) -%}
+    {%- set text = value if value is string else value | tojson(ensure_ascii=false, separators=(',', ':'), sort_keys=true) -%}
+    {{- text | replace('&', '&amp;') | replace('<', '&lt;') | replace('>', '&gt;') -}}
+{%- endmacro -%}
+{%- if messages | length != 1 or messages[0]['role'] != 'user' -%}
+    {{- raise_exception('GS1 requires exactly one user message containing the state.') -}}
+{%- endif -%}
+{%- if question is undefined or options is undefined -%}
+    {{- raise_exception('GS1 requires question and options; use model.decide for typed decisions.') -}}
+{%- endif -%}
+{%- if options is string or options is mapping or options is not sequence or not options -%}
+    {{- raise_exception('GS1 options must be a nonempty sequence of candidate descriptions.') -}}
+{%- endif -%}
+{%- if tools or enable_thinking -%}
+    {{- raise_exception('GS1 uses native decisions with the no-thinking prefix.') -}}
+{%- endif -%}
+{%- set state = messages[0]['content'] -%}
+{%- set visual = namespace(enabled=false) -%}
+{%- if state is sequence and state is not string and state is not mapping -%}
+    {%- for item in state -%}
+        {%- if item is mapping and item['type'] == 'image' -%}
+            {%- set visual.enabled = true -%}
+        {%- endif -%}
+    {%- endfor -%}
+{%- endif -%}
+{{- '<|im_start|>user\n<state>\n' -}}
+{%- if visual.enabled -%}
+    {%- for item in state -%}
+        {%- if item is mapping and item['type'] == 'text' and item['text'] is string -%}
+            {{- xml_text(item['text']) -}}
+        {%- elif item is mapping and item | length == 2 and item['type'] == 'image' and item['image'] is string and item['image'].startswith('data:image/') and ';base64,' in item['image'] -%}
+            {{- '<|vision_start|><|image_pad|><|vision_end|>' -}}
+        {%- else -%}
+            {{- raise_exception('Vision state requires text and inline base64 images.') -}}
+        {%- endif -%}
+    {%- endfor -%}
+{%- else -%}
+    {{- xml_text(state) -}}
+{%- endif -%}
+{{- '\n</state>\n<question>\n' -}}
+{{- xml_text(question) -}}
+{{- '\n</question>' -}}
+{%- for option in options -%}
+    {{- '\n<option>\n' -}}
+    {{- xml_text(option) -}}
+    {{- '\n</option>' -}}
+{%- endfor -%}
+{{- '<|im_end|>\n' -}}
+{%- if add_generation_prompt -%}
+    {{- '<|im_start|>assistant\n<think>\n\n</think>\n\n<|decide|>' -}}
+{%- endif -%}

compiler.py

@@ -1,14 +1,14 @@
 """Compile typed decisions into XML prompts and execute native decision branches."""
 
+import json
 from dataclasses import dataclass, field
-from html import escape
 from pathlib import Path
 
 import torch
+from jinja2 import TemplateError
 
-from .config import INFERENCE_LIMITS, DecisionConfig
+from .modular_gs1 import INFERENCE_LIMITS, DecisionConfig
 from .schema import DecisionRequest, candidate_ids, noul_descriptions
-from .util import canonical
 
 XML_STATE, XML_STATE_END = "<state>", "</state>"
 XML_QUESTION, XML_QUESTION_END = "<question>", "</question>"
@@ -19,6 +19,71 @@ NO_THINKING_PREFIX = "<think>\n\n</think>\n\n"
 COMPILER = "xml_decision"
 POSITIONS = "branch_local"
 
+CHAT_TEMPLATE = r"""{# GS1 typed decision prompt. question/options are normalized by Compiler. #}
+{%- macro xml_text(value) -%}
+    {%- set text = value if value is string else value | tojson(ensure_ascii=false, separators=(',', ':'), sort_keys=true) -%}
+    {{- text | replace('&', '&amp;') | replace('<', '&lt;') | replace('>', '&gt;') -}}
+{%- endmacro -%}
+{%- if messages | length != 1 or messages[0]['role'] != 'user' -%}
+    {{- raise_exception('GS1 requires exactly one user message containing the state.') -}}
+{%- endif -%}
+{%- if question is undefined or options is undefined -%}
+    {{- raise_exception('GS1 requires question and options; use model.decide for typed decisions.') -}}
+{%- endif -%}
+{%- if options is string or options is mapping or options is not sequence or not options -%}
+    {{- raise_exception('GS1 options must be a nonempty sequence of candidate descriptions.') -}}
+{%- endif -%}
+{%- if tools or enable_thinking -%}
+    {{- raise_exception('GS1 uses native decisions with the no-thinking prefix.') -}}
+{%- endif -%}
+{%- set state = messages[0]['content'] -%}
+{%- set visual = namespace(enabled=false) -%}
+{%- if state is sequence and state is not string and state is not mapping -%}
+    {%- for item in state -%}
+        {%- if item is mapping and item['type'] == 'image' -%}
+            {%- set visual.enabled = true -%}
+        {%- endif -%}
+    {%- endfor -%}
+{%- endif -%}
+{{- '<|im_start|>user\n<state>\n' -}}
+{%- if visual.enabled -%}
+    {%- for item in state -%}
+        {%- if item is mapping and item['type'] == 'text' and item['text'] is string -%}
+            {{- xml_text(item['text']) -}}
+        {%- elif item is mapping and item | length == 2 and item['type'] == 'image' and item['image'] is string and item['image'].startswith('data:image/') and ';base64,' in item['image'] -%}
+            {{- '<|vision_start|><|image_pad|><|vision_end|>' -}}
+        {%- else -%}
+            {{- raise_exception('Vision state requires text and inline base64 images.') -}}
+        {%- endif -%}
+    {%- endfor -%}
+{%- else -%}
+    {{- xml_text(state) -}}
+{%- endif -%}
+{{- '\n</state>\n<question>\n' -}}
+{{- xml_text(question) -}}
+{{- '\n</question>' -}}
+{%- for option in options -%}
+    {{- '\n<option>\n' -}}
+    {{- xml_text(option) -}}
+    {{- '\n</option>' -}}
+{%- endfor -%}
+{{- '<|im_end|>\n' -}}
+{%- if add_generation_prompt -%}
+    {{- '<|im_start|>assistant\n<think>\n\n</think>\n\n<|decide|>' -}}
+{%- endif -%}
+"""
+
+
+def canonical(value) -> str:
+    return json.dumps(value, ensure_ascii=False, separators=(",", ":"), sort_keys=True, allow_nan=False)
+
+
+def save_chat_template(directory):
+    """Keep the standalone HF asset identical to the runtime serializer."""
+    directory = Path(directory)
+    directory.mkdir(parents=True, exist_ok=True)
+    (directory / "chat_template.jinja").write_text(CHAT_TEMPLATE, encoding="utf-8")
+
 
 def structural_tokens():
     return [*XML_TAGS, DECISION_TOKEN]
@@ -94,6 +159,8 @@ class Compiler:
         processor=None,
     ):
         self.tokenizer = tokenizer
+        # Tokenizer exports and direct rendering use the same native GS1 format.
+        self.tokenizer.chat_template = CHAT_TEMPLATE
         self.decision = DecisionConfig.model_validate(decision or {})
         self.max_context = max_context
         self.max_questions = max_questions
@@ -111,10 +178,6 @@ class Compiler:
         self.xml_newline = tuple(tokenizer.encode("\n", add_special_tokens=False))
         self.no_thinking_ids = no_thinking_token_ids(tokenizer)
 
-    @staticmethod
-    def _xml_text(value):
-        return escape(value if isinstance(value, str) else canonical(value), quote=False)
-
     @staticmethod
     def _visual_state(state):
         return isinstance(state, list) and any(
@@ -178,29 +241,10 @@ class Compiler:
         self.processor.tokenizer = self.tokenizer
         return self.processor
 
-    def _contents(self, state):
-        if not self._visual_state(state):
-            return f"{XML_STATE}\n{self._xml_text(state)}\n{XML_STATE_END}"
-        contents = [{"type": "text", "text": f"{XML_STATE}\n"}]
-        for item in state:
-            if item.get("type") == "text" and isinstance(item.get("text"), str):
-                contents.append({"type": "text", "text": self._xml_text(item["text"])})
-            elif (
-                set(item) == {"type", "image"}
-                and isinstance(item.get("image"), str)
-                and item["image"].startswith("data:image/")
-                and ";base64," in item["image"]
-            ):
-                contents.append(item)
-            else:
-                raise ValueError("Vision state requires text and inline base64 images")
-        return [*contents, {"type": "text", "text": f"\n{XML_STATE_END}"}]
-
     def compile(self, request: DecisionRequest):
         if len(request.questions) > self.max_questions:
             raise ValueError(f"questions exceeds {self.max_questions}")
         visual = self._visual_state(request.state)
-        contents = self._contents(request.state)
         template = self._processor() if visual else self.tokenizer
         branches, candidates, state = [], {}, None
         for qid, question in request.questions.items():
@@ -212,17 +256,18 @@ class Compiler:
                 options = list(noul_descriptions(question))
             else:
                 options = list(question.criteria)
-            prompt = (
-                f"\n{XML_QUESTION}\n{self._xml_text(question.instructions)}\n{XML_QUESTION_END}"
-                + "".join(f"\n{XML_OPTION}\n{self._xml_text(o)}\n{XML_OPTION_END}" for o in options)
-            )
-            content = [*contents, {"type": "text", "text": prompt}] if visual else contents + prompt
-            rendered = template.apply_chat_template(
-                [{"role": "user", "content": content}],
-                add_generation_prompt=True,
-                enable_thinking=False,
-                tokenize=False,
-            )
+            try:
+                rendered = template.apply_chat_template(
+                    [{"role": "user", "content": request.state}],
+                    chat_template=CHAT_TEMPLATE,
+                    question=question.instructions,
+                    options=options,
+                    add_generation_prompt=True,
+                    enable_thinking=False,
+                    tokenize=False,
+                )
+            except TemplateError as error:
+                raise ValueError(str(error)) from error
             payload = None
             if visual:
                 encoded = template(
@@ -233,9 +278,9 @@ class Compiler:
                 token_ids = encoded["input_ids"][0].tolist()
             else:
                 token_ids = self.tokenizer.encode(rendered, add_special_tokens=False)
-            if tuple(token_ids[-len(self.no_thinking_ids) :]) != self.no_thinking_ids:
-                raise ValueError("Chat template changed the no-thinking assistant prefix")
-            token_ids.append(self.controls[DECISION_TOKEN])
+            terminal = (*self.no_thinking_ids, self.controls[DECISION_TOKEN])
+            if tuple(token_ids[-len(terminal) :]) != terminal:
+                raise ValueError("Chat template changed the no-thinking decision prefix")
             markers = self._xml_positions(token_ids, len(ids))
             prefix = markers.pop("prefix_end")
             first_option = markers.pop("first_option")
@@ -253,10 +298,6 @@ class Compiler:
                     in {"input_ids", "attention_mask", "pixel_values", "image_grid_thw", "mm_token_type_ids"}
                 }
                 payload["input_ids"] = torch.tensor([token_ids], dtype=torch.long)
-                for key, fill in (("attention_mask", 1), ("mm_token_type_ids", 0)):
-                    if key in payload:
-                        value = payload[key]
-                        payload[key] = torch.cat((value, torch.full((1, 1), fill, dtype=value.dtype)), dim=-1)
             branches.append(
                 Branch(
                     qid,

config.py

@@ -1,46 +0,0 @@
-"""Semantic architecture and scalar calibration settings for GS1."""
-
-import math
-from typing import Literal
-
-from pydantic import BaseModel, ConfigDict, Field, field_validator
-
-INFERENCE_LIMITS = dict(
-    max_context=65536,
-    max_questions=512,
-    max_request_tokens=131072,
-    max_branches=5120,
-    batch_tokens=16384,
-    max_attention_bytes=1073741824,
-    max_logit_elements=16777216,
-)
-
-
-class ModelConfig(BaseModel):
-    model_config = ConfigDict(extra="forbid", strict=True, allow_inf_nan=False)
-
-
-class DecisionConfig(ModelConfig):
-    attnres: bool = True
-    attnres_layers: list[int] | None = None
-    attnres_eps: float = Field(default=1e-6, gt=0)
-    bidirectional: bool = True
-    bidirectional_layers: list[int] | None = None
-    cross_attention_heads: int = Field(default=8, ge=1)
-    cross_attention_layers: int = Field(default=2, ge=1)
-    projection_size: int = Field(default=256, ge=2)
-    norm_eps: float = Field(default=1e-5, gt=0)
-
-    @field_validator("attnres_layers", "bidirectional_layers")
-    @classmethod
-    def selected_layers(cls, value):
-        if value is not None:
-            if not value or any(i < 0 for i in value) or len(set(value)) != len(value):
-                raise ValueError("Layer selection must contain distinct nonnegative indices")
-            return sorted(value)
-        return value
-
-
-class CalibrationConfig(ModelConfig):
-    mode: Literal["identity", "scalar_temperature"] = "identity"
-    log_temperature_bound: float = Field(default=math.log(20), gt=0)

modular_gs1.py

@@ -1,9 +1,16 @@
 """GS1: native hybrid text/vision decision model with attention residuals."""
 
+import hashlib
+import json
 import math
 from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
 
 import torch
+from accelerate import init_empty_weights
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from safetensors.torch import load_file
 from torch import nn
 from torch.nn import functional as F
 from torch.nn.attention import SDPBackend, sdpa_kernel
@@ -22,8 +29,76 @@ from transformers.models.qwen3_5.modeling_qwen3_5 import (
 )
 from transformers.utils import ModelOutput
 
-from .config import INFERENCE_LIMITS, CalibrationConfig, DecisionConfig
-from .util import named_seed
+INFERENCE_LIMITS = dict(
+    max_context=65536,
+    max_questions=512,
+    max_request_tokens=131072,
+    max_branches=5120,
+    batch_tokens=16384,
+    max_attention_bytes=1073741824,
+    max_logit_elements=16777216,
+)
+
+
+class ModelConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True, allow_inf_nan=False)
+
+
+class DecisionConfig(ModelConfig):
+    attnres: bool = True
+    attnres_layers: list[int] | None = None
+    attnres_eps: float = Field(default=1e-6, gt=0)
+    bidirectional: bool = True
+    bidirectional_layers: list[int] | None = None
+    cross_attention_heads: int = Field(default=8, ge=1)
+    cross_attention_layers: int = Field(default=2, ge=1)
+    projection_size: int = Field(default=256, ge=2)
+    norm_eps: float = Field(default=1e-5, gt=0)
+
+    @field_validator("attnres_layers", "bidirectional_layers")
+    @classmethod
+    def selected_layers(cls, value):
+        if value is not None:
+            if not value or any(i < 0 for i in value) or len(set(value)) != len(value):
+                raise ValueError("Layer selection must contain distinct nonnegative indices")
+            return sorted(value)
+        return value
+
+
+class CalibrationConfig(ModelConfig):
+    mode: Literal["identity", "scalar_temperature"] = "identity"
+    log_temperature_bound: float = Field(default=math.log(20), gt=0)
+
+
+def named_seed(seed, name):
+    payload = json.dumps(
+        ["gs1.rng", seed, name], ensure_ascii=False, separators=(",", ":"), sort_keys=True, allow_nan=False
+    )
+    return int.from_bytes(hashlib.sha256(payload.encode()).digest()[:8], "big") % (2**63)
+
+
+def _read_weights(directory):
+    index = directory / "model.safetensors.index.json"
+    if index.is_file():
+        weight_map = json.loads(index.read_text())["weight_map"]
+        files = sorted(set(weight_map.values()))
+    else:
+        files = sorted(p.name for p in directory.glob("*.safetensors"))
+        weight_map = None
+    if not files:
+        raise ValueError("Checkpoint contains no safetensors weights")
+    if any(Path(name).is_absolute() or ".." in Path(name).parts for name in files):
+        raise ValueError("Checkpoint shard is outside its directory")
+    # Hub snapshots can link to cache blobs outside their snapshot directory.
+    state = {}
+    for name in files:
+        shard = load_file(directory / name, device="cpu")
+        if state.keys() & shard.keys():
+            raise ValueError("Duplicate checkpoint parameter")
+        state.update(shard)
+    if weight_map is not None and state.keys() != weight_map.keys():
+        raise ValueError("Checkpoint index differs from its parameter contents")
+    return state
 
 
 class GS1Config(Qwen3_5Config):
@@ -499,7 +574,7 @@ class GS1PretrainedModel(Qwen3_5PreTrainedModel):
                 module.gradient_checkpointing = False
 
     def save_pretrained(self, save_directory, *, state_dict=None, **kwargs):
-        from .util import export_state
+        from .compiler import save_chat_template
 
         self.config.decision = self.decision_config.model_dump()
         if hasattr(self, "calibrator"):
@@ -507,18 +582,101 @@ class GS1PretrainedModel(Qwen3_5PreTrainedModel):
         if hasattr(self, "decision_head"):
             self.config.head_compute_dtype = "bfloat16" if self.decision_head.bf16_compute else "float32"
         kwargs.pop("safe_serialization", None)
+        save_chat_template(save_directory)
+        state = self.state_dict() if state_dict is None else state_dict
         return super().save_pretrained(
             save_directory,
-            state_dict=export_state(self, state_dict),
+            state_dict={name: value.detach().contiguous() for name, value in state.items()},
             safe_serialization=True,
             **kwargs,
         )
 
     @classmethod
-    def from_pretrained(cls, source, *, device="cpu", dtype=None, **kwargs):
-        from .util import load_native
-
-        return load_native(source, device=device, dtype=dtype, model_class=cls, **kwargs)
+    def from_pretrained(
+        cls,
+        source,
+        *,
+        device="cpu",
+        dtype=None,
+        config=None,
+        revision=None,
+        local_files_only=False,
+        cache_dir=None,
+        token=None,
+        force_download=False,
+        **kwargs,
+    ):
+        for name in (
+            "_from_auto",
+            "_from_pipeline",
+            "_commit_hash",
+            "trust_remote_code",
+            "code_revision",
+            "weights_only",
+            "use_safetensors",
+            "adapter_kwargs",
+        ):
+            kwargs.pop(name, None)
+        if "torch_dtype" in kwargs:
+            if dtype is not None:
+                raise ValueError("Use only dtype or torch_dtype")
+            dtype = kwargs.pop("torch_dtype")
+        device_map = kwargs.pop("device_map", None)
+        if device_map is not None:
+            if isinstance(device_map, dict) and set(device_map) == {""}:
+                device = device_map[""]
+            elif isinstance(device_map, str) and (
+                device_map in {"cpu", "cuda"} or device_map.startswith("cuda:")
+            ):
+                device = device_map
+            else:
+                raise ValueError(
+                    "GS1 supports a single device; use .to(device) instead of automatic device mapping"
+                )
+        if kwargs:
+            raise TypeError(f"Unsupported GS1 loading options: {sorted(kwargs)}")
+        directory = Path(source).expanduser()
+        if directory.is_dir():
+            directory = directory.resolve()
+        else:
+            from huggingface_hub import snapshot_download
+
+            directory = Path(
+                snapshot_download(
+                    str(source),
+                    revision=revision,
+                    local_files_only=local_files_only,
+                    cache_dir=cache_dir,
+                    token=token,
+                    force_download=force_download,
+                    allow_patterns=["*.json", "*.safetensors", "*.jinja", "*.py", "*.model", "*.txt"],
+                )
+            )
+        raw = json.loads((directory / "config.json").read_text())
+        if raw.get("model_type") != "gs1":
+            raise ValueError("Expected native GS1 weights")
+        config = config or GS1Config(**raw)
+        config._name_or_path = str(source)
+        # Keep nonpersistent rotary buffers real while constructing empty parameters.
+        with init_empty_weights(include_buffers=False):
+            model = cls(config)
+        state = _read_weights(directory)
+        expected = model.state_dict()
+        if state.keys() != expected.keys():
+            raise ValueError(
+                f"Incomplete GS1 weights: missing={sorted(expected.keys() - state.keys())}, "
+                f"unexpected={sorted(state.keys() - expected.keys())}"
+            )
+        for name, value in state.items():
+            if value.shape != expected[name].shape:
+                raise ValueError(f"GS1 parameter shape mismatch: {name}")
+        model.load_state_dict(state, strict=True, assign=True)
+        model._processor_source = directory
+        if dtype is not None and dtype != "auto":
+            if isinstance(dtype, str):
+                dtype = getattr(torch, dtype)
+            model.to(dtype=dtype)
+        return model.to(device).eval()
 
 
 class GS1TextModel(GS1PretrainedModel):

schema.py

@@ -13,7 +13,7 @@ from typesafe_sdk import Noul as Noul
 from typesafe_sdk import Question as Question
 from typesafe_sdk import Score as Score
 
-from .config import CalibrationConfig
+from .modular_gs1 import CalibrationConfig
 
 Description = str | dict[str, JsonValue] | list[JsonValue]
 CONFIDENCE_VERSION = "typesafe_v1"

util.py

@@ -1,202 +0,0 @@
-"""Native checkpoint loading, serialization and deterministic identities."""
-
-import hashlib
-import json
-from pathlib import Path
-
-import torch
-from accelerate import init_empty_weights
-from safetensors.torch import load_file
-
-
-def canonical(value) -> str:
-    return json.dumps(value, ensure_ascii=False, separators=(",", ":"), sort_keys=True, allow_nan=False)
-
-
-def digest(value) -> str:
-    return hashlib.sha256(canonical(value).encode()).hexdigest()
-
-
-def file_hash(path: Path) -> str:
-    h = hashlib.sha256()
-    with path.open("rb") as stream:
-        for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def named_seed(seed, name):
-    return int.from_bytes(hashlib.sha256(canonical(["gs1.rng", seed, name]).encode()).digest()[:8], "big") % (
-        2**63
-    )
-
-
-def _weight_files(directory):
-    directory = Path(directory)
-    index = directory / "model.safetensors.index.json"
-    if index.is_file():
-        weight_map = json.loads(index.read_text())["weight_map"]
-        files = sorted(set(weight_map.values()))
-    else:
-        files = sorted(p.name for p in directory.glob("*.safetensors"))
-        weight_map = None
-    if not files:
-        raise ValueError("Checkpoint contains no safetensors weights")
-    if any(Path(name).is_absolute() or ".." in Path(name).parts for name in files):
-        raise ValueError("Checkpoint shard is outside its directory")
-    # Hub snapshots link to shared cache blobs; validate shard names rather
-    # than rejecting those normal cache symlinks after resolving their targets.
-    return [directory / name for name in files], weight_map
-
-
-def checkpoint_files(directory):
-    """Files that define the weights, native configuration and input encoding."""
-    directory = Path(directory)
-    names = (
-        "config.json",
-        "model.safetensors.index.json",
-        "tokenizer.json",
-        "tokenizer_config.json",
-        "special_tokens_map.json",
-        "added_tokens.json",
-        "vocab.json",
-        "vocab.txt",
-        "merges.txt",
-        "tokenizer.model",
-        "chat_template.jinja",
-        "preprocessor_config.json",
-        "video_preprocessor_config.json",
-    )
-    weights, _ = _weight_files(directory)
-    return sorted({*weights, *(directory / name for name in names if (directory / name).is_file())})
-
-
-def read_weights(directory):
-    files, weight_map = _weight_files(directory)
-    state = {}
-    for path in files:
-        shard = load_file(path, device="cpu")
-        if state.keys() & shard.keys():
-            raise ValueError("Duplicate checkpoint parameter")
-        state.update(shard)
-    if weight_map is not None and state.keys() != weight_map.keys():
-        raise ValueError("Checkpoint index differs from its parameter contents")
-    return state
-
-
-def _construct(config, model_class=None):
-    from .modular_gs1 import GS1Model
-
-    # Nonpersistent rotary buffers must remain real tensors, not meta placeholders.
-    with init_empty_weights(include_buffers=False):
-        return (model_class or GS1Model)(config)
-
-
-def _assign(model, state):
-    expected = model.state_dict()
-    if state.keys() != expected.keys():
-        raise ValueError(
-            f"Incomplete GS1 weights: missing={sorted(expected.keys() - state.keys())}, "
-            f"unexpected={sorted(state.keys() - expected.keys())}"
-        )
-    for name, value in state.items():
-        if value.shape != expected[name].shape:
-            raise ValueError(f"GS1 parameter shape mismatch: {name}")
-    model.load_state_dict(state, strict=True, assign=True)
-    return model
-
-
-def resolve_source(
-    source, *, revision=None, local_files_only=False, cache_dir=None, token=None, force_download=False
-):
-    """Resolve a native directory or an immutable Hub snapshot."""
-    path = Path(source).expanduser()
-    if path.is_dir():
-        return path.resolve()
-    from huggingface_hub import snapshot_download
-
-    return Path(
-        snapshot_download(
-            str(source),
-            revision=revision,
-            local_files_only=local_files_only,
-            cache_dir=cache_dir,
-            token=token,
-            force_download=force_download,
-            allow_patterns=["*.json", "*.safetensors", "*.jinja", "*.py", "*.model", "*.txt"],
-        )
-    )
-
-
-def load_native(
-    source,
-    *,
-    device="cpu",
-    dtype=None,
-    model_class=None,
-    config=None,
-    revision=None,
-    local_files_only=False,
-    cache_dir=None,
-    token=None,
-    force_download=False,
-    **kwargs,
-):
-    from .modular_gs1 import GS1Config
-
-    for name in (
-        "_from_auto",
-        "_from_pipeline",
-        "_commit_hash",
-        "trust_remote_code",
-        "code_revision",
-        "weights_only",
-        "use_safetensors",
-        "adapter_kwargs",
-    ):
-        kwargs.pop(name, None)
-    if "torch_dtype" in kwargs:
-        if dtype is not None:
-            raise ValueError("Use only dtype or torch_dtype")
-        dtype = kwargs.pop("torch_dtype")
-    device_map = kwargs.pop("device_map", None)
-    if device_map is not None:
-        if isinstance(device_map, dict) and set(device_map) == {""}:
-            device = device_map[""]
-        elif isinstance(device_map, str) and (
-            device_map in {"cpu", "cuda"} or device_map.startswith("cuda:")
-        ):
-            device = device_map
-        else:
-            raise ValueError(
-                "GS1 supports a single device; use .to(device) instead of automatic device mapping"
-            )
-    if kwargs:
-        raise TypeError(f"Unsupported GS1 loading options: {sorted(kwargs)}")
-    directory = resolve_source(
-        source,
-        revision=revision,
-        local_files_only=local_files_only,
-        cache_dir=cache_dir,
-        token=token,
-        force_download=force_download,
-    )
-    raw = json.loads((directory / "config.json").read_text())
-    if raw.get("model_type") != "gs1":
-        raise ValueError("Expected native GS1 weights")
-    config = config or GS1Config(**raw)
-    config._name_or_path = str(source)
-    model = _construct(config, model_class)
-    model = _assign(model, read_weights(directory))
-    model._processor_source = directory
-    if dtype is not None and dtype != "auto":
-        if isinstance(dtype, str):
-            dtype = getattr(torch, dtype)
-        model.to(dtype=dtype)
-    return model.to(device).eval()
-
-
-def export_state(model, state=None):
-    """Save the native inference parameter tree without dtype conversion."""
-    state = model.state_dict() if state is None else state
-    return {name: value.detach().contiguous() for name, value in state.items()}