Add SMITH-10B-Exp tokenizer, chat template, and GigaChat-3 plugin.

.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

@@ -1,3 +1,115 @@
 ---
 license: mit
+language:
+- ru
+- en
+base_model:
+- ai-sage/GigaChat3.1-10B-A1.8B-bf16
+pipeline_tag: text-generation
+library_name: transformers
+tags:
+- instruct
+- moe
+- multilingual
+- bf16
+- long-context
+- tool-use
+- retrieval
+- SMITH-10B-Exp
 ---
+
+# SMITH-10B-Exp
+
+Recommended to be used with [SMITH harness](https://github.com/smit-org/smith-harness).
+
+**SMITH-10B-Exp** is an instruct Mixture-of-Experts checkpoint fine-tuned from [GigaChat 3.1 Lightning](https://huggingface.co/ai-sage/GigaChat3.1-10B-A1.8B-bf16) (10B total parameters, 1.8B active, BF16) for multi-hop retrieval with GigaChat-3 tool calls (`search_index`, then `answer` with `supporting_corpus_ids`). This folder ships the tokenizer, chat template, and `gigachat3_guided_decoding.py` (overlay BF16 weights when packing a full Hub snapshot).
+
+## Model architecture
+
+DeepSeek-V3 MoE (`DeepseekV3ForCausalLM`) with Multi-head Latent Attention (MLA) and Multi-Token Prediction (MTP). Hidden size 1536, 26 layers, 64 routed experts (4 per token), YaRN context to 262144.
+
+## Usage
+
+### Serving dependencies
+
+```bash
+uv venv --python python3.11 --seed .venv
+uv pip install -r requirements.txt \
+  --python .venv/bin/python \
+  --torch-backend=cu130 \
+  --index-strategy unsafe-best-match
+```
+
+Package pins and licenses are in [`requirements.txt`](requirements.txt). SMITH-10B-Exp BF16 fits one 80GB GPU.
+
+### transformers
+
+```python
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig
+
+model_name = "ai-forever/SMITH-10B-Exp"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+)
+model.generation_config = GenerationConfig.from_pretrained(model_name)
+messages = [
+    {"role": "user", "content": "Which corpus passages support the answer?"}
+]
+prompt = tokenizer.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True,
+)
+inputs = tokenizer(prompt, return_tensors="pt")
+inputs = {k: v.to(model.device) for k, v in inputs.items()}
+outputs = model.generate(**inputs, max_new_tokens=512)
+prompt_len = inputs["input_ids"].shape[1]
+print(tokenizer.decode(outputs[0][prompt_len:], skip_special_tokens=True))
+```
+
+### vLLM
+
+```bash
+vllm serve ai-forever/SMITH-10B-Exp \
+  --trust-remote-code \
+  --enable-auto-tool-choice \
+  --tool-call-parser gigachat3 \
+  --tool-parser-plugin ./gigachat3_guided_decoding.py \
+  --chat-template ./chat_template.jinja \
+  --tensor-parallel-size 1 \
+  --dtype bfloat16
+```
+
+```bash
+curl http://localhost:8000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "ai-forever/SMITH-10B-Exp",
+    "temperature": 0,
+    "tool_choice": "required",
+    "messages": [
+      {"role": "user", "content": "Which corpus passages support the answer?"}
+    ],
+    "tools": [
+      {
+        "type": "function",
+        "function": {
+          "name": "search_index",
+          "description": "Search the local semantic index and return relevant text snippets.",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "query": {"type": "string", "description": "The search query string."},
+              "k": {"type": "integer", "description": "Optional number of top results to return."}
+            },
+            "required": ["query"]
+          }
+        }
+      }
+    ]
+  }'
+```

chat_template.jinja

@@ -0,0 +1,348 @@
+{#--------TOOL RENDERING FUNCTIONS---------#}
+
+{#---------------------------------------------------------------
+  Converts JSON Schema (dict) to a TypeScript type definition
+----------------------------------------------------------------#}
+{%- macro json_schema_to_typescript(schema, indent="") -%}
+	{%- set ADDITIONAL_JSON_KEYS = ['format', 'maxItems', 'maximum', 'minItems', 'minimum', 'pattern'] -%}
+	{%- set ty = schema.get("type") -%}
+
+	{# ---------------- OBJECT ---------------- #}
+	{%- if ty == "object" -%}
+		{{- "{\n" -}}
+
+		{# Start building property list #}
+		{%- set props = schema.get("properties", {}) -%}
+		{%- set required = schema.get("required", []) -%}
+		{%- set has_additional_props = schema.get("additionalProperties") is defined -%}
+		{%- set additional_props_type = none -%}
+		{%- if has_additional_props -%}
+			{%- if schema.additionalProperties == true -%}
+				{%- set additional_props_type = {'type': 'any'} -%}
+			{%- elif schema.additionalProperties is mapping -%}
+				{%- set additional_props_type = schema.additionalProperties -%}
+			{%- endif -%}
+		{%- endif -%}
+
+		{%- for key, val in props.items() -%}
+			{# ---------- Description Comments ---------- #}
+			{%- if "description" in val -%}
+				{%- for line in val['description'].split('\n') -%}
+					{%- if line.strip() -%}
+						{{- indent + '// ' + line + '\n' -}}
+					{%- endif -%}
+				{%- endfor -%}
+			{%- endif -%}
+
+			{# ---------- Additional JSON Keys ---------- #}
+			{%- for add_key, add_val in val.items() -%}
+				{%- if add_key in ADDITIONAL_JSON_KEYS -%}
+					{%- if add_val is string -%}
+						{{- indent + '// ' + add_key + ': "' + add_val + '"' + '\n'  -}}
+					{%- else -%}
+						{{- indent + '// ' + add_key + ': ' ~ add_val ~ '\n' -}}
+					{%- endif -%}
+				{%- endif -%}
+			{%- endfor -%}
+
+			{# ---------- Property Definition ---------- #}
+            {%- set type_str = json_schema_to_typescript(
+                val, 
+                indent + "  "
+            ) -%}
+
+			{{- indent + key + ('' if key in required else '?') + ': ' + type_str + ',' -}}
+
+			{%- if "default" in val or "defalut_value" in val -%}
+				{%- set default = val.get("default", val.get("defalut_value")) -%}
+				{%- if default is string -%}
+					{{- ' // default: "' + default + '"' -}}
+				{%- else -%}
+					{{- ' // default: ' ~ default -}}
+				{%- endif -%}
+			{%- endif -%}
+
+			{{- "\n" -}}
+		{%- endfor -%}
+
+		{# Handle additionalProperties as index signature #}
+		{%- if has_additional_props and additional_props_type is not none -%}
+			{%- set additional_type_str = json_schema_to_typescript(
+				additional_props_type,
+				indent + "  "
+			) -%}
+			{{- indent + '[key: string]: ' + additional_type_str + '\n' -}}
+		{%- endif -%}
+
+		{{- indent[: (indent|length - "  "|length) ] + '}' -}}
+
+	{# ---------------- STRING ---------------- #}
+	{%- elif ty == "string" -%}
+		{%- if schema.get("enum") -%}
+            {%- set ns = namespace(enum = []) -%}
+            {%- for en in schema['enum'] -%}
+                {%- set ns.enum = ns.enum + ['"' ~ en ~ '"'] -%}
+            {%- endfor -%}
+			{{- ns.enum | join(' | ') -}}
+		{%- elif schema.get("format", "none") in ['date-time', 'date'] -%}
+			{{- 'Date' -}}
+		{%- else -%}
+			{{- 'string' -}}
+		{%- endif -%}
+
+	{# ---------------- NUMBER / INTEGER ---------------- #}
+	{%- elif ty in ["number", "integer"] -%}
+		{%- if schema.get("enum") -%}
+			{{- schema.enum | join(' | ') -}}
+		{%- else -%}
+			{{- 'number' -}}
+		{%- endif -%}
+
+	{# ---------------- BOOLEAN ---------------- #}
+	{%- elif ty == "boolean" -%}
+		{{- 'boolean' -}}
+
+	{# ---------------- ARRAY ---------------- #}
+	{%- elif ty == "array" -%}
+		{%- if "items" in schema -%}
+			{{- json_schema_to_typescript(schema['items'], indent) + '[]' -}}
+		{%- else -%}
+			{{- 'Array<any>' -}}
+		{%- endif -%}
+
+	{# ---------------- FALLBACK ---------------- #}
+	{%- else -%}
+		{{- 'any' -}}
+	{%- endif -%}
+{%- endmacro -%}
+
+{#---------------------------------------------------------------
+  Renders a namespace and its tool definitions in TypeScript style
+----------------------------------------------------------------#}
+
+{%- macro render_tool_namespace(namespace_name, tools) -%}
+	{%- set ns = namespace(sections = ['namespace ' ~ namespace_name ~ ' {']) -%}
+
+	{%- for tool in tools -%}
+		{%- if tool.function -%}
+			{%- set tool = tool.function -%}
+		{%- endif -%}
+
+		{%- set ns_tool = namespace(content_lines=[]) -%}
+
+		{# ---------- TOOL DESCRIPTION ---------- #}
+		{%- if tool.get('description') -%}
+			{%- for line in tool['description'].split('\n') -%}
+				{%- if line.strip() -%}
+					{%- set ns_tool.content_lines = ns_tool.content_lines + ['// ' ~ line] -%}
+				{%- endif -%}
+			{%- endfor -%}
+		{%- endif -%}
+
+		{# ---------- TOOL SIGNATURE ---------- #}
+		{%- set main_body = "" -%}
+		{%- set params = tool.get("parameters") -%}
+		{%- if params and params.get("properties") -%}
+			{%- set param_type = json_schema_to_typescript(params, "  ") -%}
+			{%- set main_body = 'type ' ~ tool.name ~ ' = (_: ' ~ param_type ~ ') => ' -%}
+		{%- else -%}
+			{%- set main_body = 'type ' ~ tool.name ~ ' = () => ' -%}
+		{%- endif -%}
+
+		{# ---------- RETURN TYPE ---------- #}
+		{%- set return_params = tool.get("return_parameters") -%}
+		{%- if return_params and return_params.get("properties") -%}
+			{%- set return_type = json_schema_to_typescript(return_params, "  ") -%}
+			{%- set main_body = main_body ~ return_type -%}
+		{%- else -%}
+			{%- set main_body = main_body ~ 'any' -%}
+		{%- endif -%}
+
+		{%- set main_body = main_body ~ ';\n' -%}
+
+		{%- set ns_tool.content_lines = ns_tool.content_lines + [main_body] -%}
+
+		{# ---------- ADD TOOL TO SECTIONS ---------- #}
+		{%- set ns.sections = ns.sections + [ns_tool.content_lines | join('\n')] -%}
+	{%- endfor -%}
+
+	{%- set ns.sections = ns.sections + ['} // namespace ' ~ namespace_name] -%}
+
+	{{- ns.sections | join('\n') -}}
+{%- endmacro -%}
+
+
+{# ----------- MESSAGE RENDERING HELPER FUNCTIONS ------------ #}
+
+{%- macro render_function_call(call) -%}
+    {%- if call.function -%}
+        {%- set call = call.function -%}
+    {%- endif -%}
+
+    {%- set arguments = call['arguments'] -%}
+	{%- if arguments is not string -%}
+		{%- set arguments = arguments| tojson(ensure_ascii=False) -%}
+	{%- endif -%}
+
+    {{- '{"name": "' ~ call['name'] ~ '", "arguments": ' ~ arguments ~ '}' -}}
+{%- endmacro -%}
+
+
+{%- macro render_role_message(message, role=None) -%}
+    {%- if not role -%}
+        {%- set role = message["role"] -%}
+    {%- endif -%}
+
+    {%- set message_content = message['content'] or '' -%}
+    {%- if message_content is not string -%}
+        {%- set message_content = message_content | tojson(ensure_ascii=False) -%}
+    {%- endif -%}
+
+    {{- role + add_tokens.role_sep + message_content -}}
+
+    {%- if message.tool_calls is defined and message.tool_calls -%}
+        {{- add_tokens.function_call + render_function_call(message.tool_calls[0]) -}}
+    {%- endif -%}
+
+    {{- add_tokens.message_sep -}}
+
+{%- endmacro -%}
+
+
+
+{# ----- SPECIAL TOKENS ----- #}
+
+{%- set add_tokens = namespace(
+    role_sep="<|role_sep|>\n", 
+    message_sep="<|message_sep|>\n\n",
+    function_call="<|function_call|>"
+) -%}
+
+{# ----- DEFAULT DEVSYSTEM ----- #}
+
+{%- set DEVSYSTEM -%}
+<role_description>
+Описание доступных в диалоге ролей.
+
+`developer system`
+Сообщение, добавленное Сбером до основного диалога. Имеет самый высокий приоритет и определяет глобальные, неотменяемые условия (например, правила ведения диалога, политику безопасности, общий стиль ответов ассистента и пр.).
+
+`system`
+Системная инструкция, добавляемая разработчиками или пользователем, но с приоритетом ниже, чем `developer system`. Обычно описывает инструкции ассистента, конкретный стиль ответа и другие условия для данного конкретного диалога.
+
+`user`
+Сообщение или запрос от пользователя. Ассистент следует ему, если это не противоречит инструкциям более высокого приоритета (см. <instruction_priority>).
+
+`user memory`
+Последовательность наиболее актуальных долговременных фактов о пользователе на момент его запроса, представленная в виде JSON‑списка строк. Факты в ней перечислены в хронологическом порядке, то есть более новые факты дописываются в конец последовательности. При этом при изменении или удалении фактов записи о предыдущих фактах остаются в последовательности. Ассистент сохраняет факты с помощью функции и использует их в соответствии с указаниями из блока <memory_guidelines> ниже.
+
+`added files`
+Метаинформация о файлах, доступных для использования в диалоге, представленная в формате JSON. Содержит следующие ключи: id (уникальный идентификатор файла), name (имя файла), type (тип файла).
+
+`assistant`
+Ответ ассистента на запрос пользователя. Если системная инструкция или пользователь не задаёт дополнительных правил для `assistant`, то такая реплика должна соответс��вовать указаниям из блока <assistant_guidelines> ниже. Список доступных для вызова функций содержится в последней реплике роли `available functions`. Название необходимой для вызова функции и аргументы будут сгенерированы после специального токена вызова функции. В своих репликах ассистент следует инструкциям в соответствии с <instruction_priority>.
+Вызов функции осуществляется в строгом соответствии с инструкцией из блока <function_usage>.
+
+`function descriptions`
+Описания функций в формате TypeScript. Функция — это специальный инструмент (или набор инструкций), который ассистент может вызвать для выполнения конкретных действий, вычислений или получения данных, необходимых для решения задачи пользователя. Каждое описание функции содержит блоки с именем, описанием, аргументами. Иногда описание содержит отдельные блоки с возвращаемыми параметрами и примерами применения, иллюстрирующими правильный вызов и аргументы.
+
+`available functions`
+Список, который содержит названия функций, доступных для вызова. Если список не содержит элементов, то в следующем сообщении функции, доступные для вызова, отсутствуют.
+
+`function result`
+Результат последнего вызова функции.
+</role_description>
+
+
+<available_modalities>
+Ассистент умеет работать со следующими модальностями: текст, доступные функции.
+</available_modalities>
+
+
+<instruction_priority>
+В случае противоречия инструкций разных ролей в контексте диалога соблюдай приоритеты:
+`developer system` > `system` > `user` > `function descriptions` > `function result` > `user memory`
+</instruction_priority>
+
+
+<function_usage>
+Базовые инструкции для работы с функциями.
+
+Можно вызывать только те функции, которые доступны исходя из последнего сообщения `available functions`.
+
+Вызывай доступные функции в случае, если согласно их описанию такой вызов поможет дать более полный и/или точный ответ на запрос пользователя. Заполняй аргументы функций, используя информацию из контекста диалога. Если функция может помочь ответить на запрос, но для её обязательного аргумента отсутствует информация в контексте, уточни у пользователя недостающие данные перед вызовом функции. При недоступности необходимой функции или ошибке — кратко сообщи об этом пользователю и по возможности предложи альтернативу.
+</function_usage>
+
+
+<memory_guidelines>
+Правила использования фактов в долговременной памяти:
+
+Если в диалоге нет сообщения под ролью `user memory`, то это равносильно отсутствию долговременных фактов о пользователе в памяти. В таком случае информация о пользователе ограничена текущим диалогом, и новые факты не должны сохраняться.
+</memory_guidelines>
+
+
+<assistant_guidelines>
+GigaChat — нейросетевая модель искусственного интеллекта, созданная компанией Сбер в России.
+
+GigaChat старается отвечать на языке, на котором пользователь задал запрос. Если из запроса пользователя и контекста диалога язык определить невозможно, GigaChat использует русский.
+GigaChat предоставляет подробные ответы на более сложные и открытые вопросы.
+GigaChat в ответе не и��пользует названия доступных функций.
+GigaChat отвечает безопасно, в соответствии с действующим законодательством Российской Федерации, стараясь помочь пользователю решить задачу или поддержать беседу.
+
+Ты — GigaChat.
+</assistant_guidelines>
+
+
+Ниже будет приведён диалог.
+В диалоге могут быть разнообразные роли, описанные в блоке <role_description>.
+Каждая реплика начинается с названия роли и специального токена, обозначающего конец полного наименования роли, а заканчивается специальным токеном конца реплики.
+Твоя задача — продолжить диалог от последней указанной роли в соответствии с контекстом диалога.
+{%- endset -%}
+
+
+{#- ---------------------- RENDERING STARTS HERE ---------------------- -#}
+
+
+{# ----- RENDER BOS TOKEN ----- #}
+{{- bos_token -}}
+
+
+{# ----- RENDER DEVSYSTEM ----- #}
+{{- render_role_message({"role": "developer system", "content": DEVSYSTEM}) -}}
+
+{# ----- RENDER SYSTEM IF PRESENT ----- #}
+{%- if messages and messages[0]['role'] == 'system' -%}
+    {{- render_role_message(messages[0]) -}}
+    {%- set messages = messages[1:] -%}
+{%- else -%}
+    {{- render_role_message({"role": "system", "content": ""}) -}}
+{%- endif -%}
+
+{# ----- RENDER TOOLS ----- #}
+{%- if tools -%}
+    {%- set tools_content = (
+        render_tool_namespace('functions', tools) 
+        + "\n\n"
+    ) -%}
+    {{- render_role_message({'role': 'function descriptions', 'content': tools_content}) -}}
+{%- endif -%}
+
+{# ----- MAIN MESSAGE LOOP ----- #}
+{%- for message in messages -%}
+
+    {# ----- TOOL MESSAGE -------#}
+    {%- if message['role'] == 'tool' -%}
+        {{- render_role_message(message, 'function result') -}}
+        
+    {# ----- OTHER MESSAGES ----- #}
+    {%- else -%}
+        {{- render_role_message(message) -}}
+    {%- endif -%}
+
+    {# ----- ADDING GENERATION PROMPT ----- #}
+
+    {%- if loop.last and add_generation_prompt and message['role'] != 'assistant' -%}
+        {{- 'assistant' + add_tokens.role_sep -}}
+    {%- endif -%}
+
+{%- endfor -%}

config.json

@@ -0,0 +1,53 @@
+{
+  "vocab_size": 128256,
+  "max_position_embeddings": 262144,
+  "hidden_size": 7168,
+  "intermediate_size": 18432,
+  "moe_intermediate_size": 2048,
+  "num_hidden_layers": 64,
+  "num_nextn_predict_layers": 1,
+  "num_attention_heads": 64,
+  "n_shared_experts": 1,
+  "n_routed_experts": 256,
+  "ep_size": 1,
+  "routed_scaling_factor": 2.5,
+  "kv_lora_rank": 512,
+  "q_lora_rank": 1536,
+  "qk_rope_head_dim": 64,
+  "v_head_dim": 192,
+  "qk_nope_head_dim": 128,
+  "topk_method": "noaux_tc",
+  "n_group": 8,
+  "topk_group": 4,
+  "num_experts_per_tok": 8,
+  "moe_layer_freq": 1,
+  "first_k_dense_replace": 3,
+  "norm_topk_prob": true,
+  "scoring_func": "sigmoid",
+  "num_key_value_heads": 64,
+  "hidden_act": "silu",
+  "initializer_range": 0.006,
+  "rms_norm_eps": 1e-06,
+  "use_cache": true,
+  "rope_theta": 100000,
+  "rope_scaling": {
+    "beta_fast": 32.0,
+    "beta_slow": 1.0,
+    "factor": 64.0,
+    "mscale": 1.0,
+    "mscale_all_dim": 1.0,
+    "original_max_position_embeddings": 4096,
+    "rope_type": "yarn"
+  },
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "tie_word_embeddings": false,
+  "architectures": [
+    "DeepseekV3ForCausalLM"
+  ],
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "transformers_version": "4.57.3",
+  "model_type": "deepseek_v3",
+  "dtype": "bfloat16"
+}

generation_config.json

@@ -0,0 +1,7 @@
+{
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "pad_token_id": 2,
+  "transformers_version": "4.57.3",
+  "_from_model_config": true
+}

gigachat3_guided_decoding.py

@@ -0,0 +1,390 @@
+"""Standalone vLLM gigachat3 parser + xgrammar tags + optional retrieved-id GBNF.
+
+Loaded via ``--tool-parser-plugin ./gigachat3_guided_decoding.py``.
+Does not import ``trace_generation`` or ``harness``.
+
+Extra-body keys must match ``smith_harness.guided``:
+``smith_guided_string_enums``, ``smith_guided_array_min_items``,
+``smith_guided_array_max_items``. Absent keys → general Giga grammar only.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Mapping, Sequence
+
+from xgrammar import StructuralTag
+from xgrammar.openai_tool_call_schema import BuiltinToolParam, FunctionToolParam
+from xgrammar.structural_tag import (
+    AnyTextFormat,
+    JSONSchemaFormat,
+    TagFormat,
+    TagsWithSeparatorFormat,
+    TriggeredTagsFormat,
+)
+
+from vllm.tool_parsers.abstract_tool_parser import ToolParserManager
+from vllm.tool_parsers.gigachat3_tool_parser import GigaChat3ToolParser
+from vllm.tool_parsers.structural_tag_registry import register_vllm_structural_tag
+
+GIGACHAT3_TOOL_CALL_PARSER = "gigachat3"
+SMITH_GUIDED_STRING_ENUMS_KEY = "smith_guided_string_enums"
+SMITH_GUIDED_ARRAY_MIN_ITEMS_KEY = "smith_guided_array_min_items"
+SMITH_GUIDED_ARRAY_MAX_ITEMS_KEY = "smith_guided_array_max_items"
+DEFAULT_GUIDED_ARRAY_MIN_ITEMS = 2
+DEFAULT_GUIDED_ARRAY_MAX_ITEMS = 10
+UNCAPPED_ARRAY_MAX_ITEMS = 32
+DEFAULT_MAX_QUERY_CHARS = 256
+QUERY_STRING_FIELD_NAMES = frozenset({"query"})
+_ARGUMENTS_FIELD_PREFIX = '", "arguments": '
+_FUNCTION_CALL_WRAPS = (
+    ('<|function_call|>{"name": "', "}"),
+    ('function call<|role_sep|>\n{"name": "', "}"),
+)
+_FUNCTION_CALL_TRIGGERS = ("<|function_call|>", "function call<|role_sep|>")
+_NAME_BEGIN = '{"name": "'
+
+
+def _schema_is_array(schema: dict[str, Any]) -> bool:
+    schema_type = schema.get("type")
+    if schema_type == "array":
+        return True
+    return isinstance(schema_type, list) and "array" in schema_type
+
+
+def _schema_is_string(schema: dict[str, Any]) -> bool:
+    schema_type = schema.get("type")
+    if schema_type == "string":
+        return True
+    return isinstance(schema_type, list) and "string" in schema_type
+
+
+def cap_uncapped_query_string_max_length(
+    schema: Any,
+    *,
+    max_length: int = DEFAULT_MAX_QUERY_CHARS,
+) -> Any:
+    if isinstance(schema, dict):
+        out = {
+            key: cap_uncapped_query_string_max_length(value, max_length=max_length)
+            for key, value in schema.items()
+        }
+        props = out.get("properties")
+        if isinstance(props, dict):
+            new_props = dict(props)
+            changed = False
+            for name, prop in props.items():
+                if name not in QUERY_STRING_FIELD_NAMES or not isinstance(prop, dict):
+                    continue
+                if _schema_is_string(prop) and "maxLength" not in prop:
+                    new_props[name] = {**prop, "maxLength": int(max_length)}
+                    changed = True
+            if changed:
+                out["properties"] = new_props
+        return out
+    if isinstance(schema, list):
+        return [
+            cap_uncapped_query_string_max_length(item, max_length=max_length)
+            for item in schema
+        ]
+    return schema
+
+
+def cap_uncapped_array_max_items(
+    schema: Any,
+    *,
+    max_items: int = UNCAPPED_ARRAY_MAX_ITEMS,
+) -> Any:
+    if isinstance(schema, dict):
+        out = {
+            key: cap_uncapped_array_max_items(value, max_items=max_items)
+            for key, value in schema.items()
+        }
+        if _schema_is_array(out) and "maxItems" not in out:
+            out["maxItems"] = max_items
+        return out
+    if isinstance(schema, list):
+        return [
+            cap_uncapped_array_max_items(item, max_items=max_items) for item in schema
+        ]
+    return schema
+
+
+def _normalize_guided_array_bounds(
+    min_items: Any = None,
+    max_items: Any = None,
+) -> tuple[int, int]:
+    lo = DEFAULT_GUIDED_ARRAY_MIN_ITEMS if min_items is None else int(min_items)
+    hi = DEFAULT_GUIDED_ARRAY_MAX_ITEMS if max_items is None else int(max_items)
+    if lo < 1:
+        raise ValueError("guided_supporting_ids_min_items must be >= 1")
+    if hi < lo:
+        raise ValueError(
+            "guided_supporting_ids_max_items must be >= guided_supporting_ids_min_items"
+        )
+    return lo, hi
+
+
+def _coerce_bound(value: Any) -> int | None:
+    if value is None or isinstance(value, bool):
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _bound_from_mapping(payload: Any, key: str) -> int | None:
+    if not isinstance(payload, Mapping):
+        return None
+    return _coerce_bound(payload.get(key))
+
+
+def guided_array_bounds_from_request(request: Any) -> tuple[int, int]:
+    extra_body = getattr(request, "extra_body", None)
+    extras = getattr(request, "__pydantic_extra__", None)
+    min_items = (
+        _coerce_bound(getattr(request, SMITH_GUIDED_ARRAY_MIN_ITEMS_KEY, None))
+        or _bound_from_mapping(extra_body, SMITH_GUIDED_ARRAY_MIN_ITEMS_KEY)
+        or _bound_from_mapping(extras, SMITH_GUIDED_ARRAY_MIN_ITEMS_KEY)
+    )
+    max_items = (
+        _coerce_bound(getattr(request, SMITH_GUIDED_ARRAY_MAX_ITEMS_KEY, None))
+        or _bound_from_mapping(extra_body, SMITH_GUIDED_ARRAY_MAX_ITEMS_KEY)
+        or _bound_from_mapping(extras, SMITH_GUIDED_ARRAY_MAX_ITEMS_KEY)
+    )
+    return _normalize_guided_array_bounds(min_items, max_items)
+
+
+def guided_string_enums_from_request(request: Any) -> dict[str, dict[str, list[str]]]:
+    candidates: list[Any] = [
+        getattr(request, SMITH_GUIDED_STRING_ENUMS_KEY, None),
+    ]
+    extra_body = getattr(request, "extra_body", None)
+    if isinstance(extra_body, dict):
+        candidates.append(extra_body.get(SMITH_GUIDED_STRING_ENUMS_KEY))
+    extras = getattr(request, "__pydantic_extra__", None)
+    if isinstance(extras, dict):
+        candidates.append(extras.get(SMITH_GUIDED_STRING_ENUMS_KEY))
+    for guided in candidates:
+        if isinstance(guided, dict) and guided:
+            return guided
+    return {}
+
+
+def _array_items_ebnf(min_items: int, max_items: int) -> str:
+    required = "corpus_id"
+    if min_items > 1:
+        required += (' ws "," ws corpus_id') * (min_items - 1)
+    extra = max_items - min_items
+    if extra:
+        return f'{required} (ws "," ws corpus_id){{0,{extra}}}'
+    return required
+
+
+def build_explicit_guided_array_grammar(
+    schema: Any,
+    field_enums: Mapping[str, Sequence[str]],
+    *,
+    min_items: Any = None,
+    max_items: Any = None,
+) -> str | None:
+    if not isinstance(schema, dict) or not field_enums:
+        return None
+    if schema.get("type") != "object" or len(field_enums) != 1:
+        return None
+    properties = schema.get("properties")
+    required = schema.get("required")
+    if not isinstance(properties, dict) or len(properties) != 1:
+        return None
+    field, values = next(iter(field_enums.items()))
+    spec = properties.get(field)
+    if (
+        not isinstance(spec, dict)
+        or spec.get("type") != "array"
+        or not isinstance(spec.get("items"), dict)
+        or spec["items"].get("type") != "string"
+        or not isinstance(required, list)
+        or field not in required
+    ):
+        return None
+    cleaned = sorted({str(item).strip() for item in values if str(item).strip()})
+    if not cleaned:
+        return None
+    lo, hi = _normalize_guided_array_bounds(min_items, max_items)
+    field_literal = json.dumps(json.dumps(field, ensure_ascii=False), ensure_ascii=False)
+    value_literals = [
+        json.dumps(json.dumps(value, ensure_ascii=False), ensure_ascii=False)
+        for value in cleaned
+    ]
+    items = _array_items_ebnf(lo, hi)
+    return "\n".join(
+        [
+            (
+                f'root ::= "{{" ws {field_literal} ws ":" ws "[" ws '
+                f'{items} ws "]" ws "}}"'
+            ),
+            f"corpus_id ::= {' | '.join(value_literals)}",
+            "ws ::= [ \\n\\t]{0,2}",
+        ]
+    )
+
+
+def _tool_name_from_begin(begin: str) -> str:
+    if _NAME_BEGIN in begin:
+        rest = begin.split(_NAME_BEGIN, 1)[1]
+        return rest.split('"', 1)[0]
+    return ""
+
+
+def inject_guided_string_enums_into_structural_tag(
+    tag: Any,
+    guided_by_tool: Mapping[str, Mapping[str, Sequence[str]]],
+    *,
+    min_items: Any = None,
+    max_items: Any = None,
+) -> Any:
+    if not guided_by_tool:
+        return tag
+    if isinstance(tag, list):
+        return [
+            inject_guided_string_enums_into_structural_tag(
+                item, guided_by_tool, min_items=min_items, max_items=max_items
+            )
+            for item in tag
+        ]
+    if not isinstance(tag, dict):
+        return tag
+    node_type = str(tag.get("type") or "")
+    begin = str(tag.get("begin") or "")
+    looks_like_tag = node_type == "tag" or (
+        _NAME_BEGIN in begin and isinstance(tag.get("content"), dict)
+    )
+    if looks_like_tag:
+        tool_name = _tool_name_from_begin(begin)
+        field_enums = guided_by_tool.get(tool_name)
+        content = tag.get("content")
+        if field_enums and isinstance(content, dict) and (
+            content.get("type") == "json_schema" or "json_schema" in content
+        ):
+            schema = content.get("json_schema")
+            if isinstance(schema, str):
+                schema = json.loads(schema)
+            grammar = build_explicit_guided_array_grammar(
+                schema, field_enums, min_items=min_items, max_items=max_items
+            )
+            if grammar is None:
+                return tag
+            patched_content = dict(content)
+            patched_content.pop("json_schema", None)
+            patched_content["type"] = "grammar"
+            patched_content["grammar"] = grammar
+            out = dict(tag)
+            out["content"] = patched_content
+            return out
+        return tag
+    return {
+        key: inject_guided_string_enums_into_structural_tag(
+            value, guided_by_tool, min_items=min_items, max_items=max_items
+        )
+        for key, value in tag.items()
+    }
+
+
+def patch_structural_tag_json(
+    structural_tag_json: str,
+    guided_by_tool: Mapping[str, Mapping[str, Sequence[str]]],
+    *,
+    min_items: Any = None,
+    max_items: Any = None,
+) -> str:
+    if not structural_tag_json or not guided_by_tool:
+        return structural_tag_json
+    tag = json.loads(structural_tag_json)
+    patched = inject_guided_string_enums_into_structural_tag(
+        tag, guided_by_tool, min_items=min_items, max_items=max_items
+    )
+    return json.dumps(patched)
+
+
+def _tool_argument_schema(function: Any) -> dict[str, Any] | bool:
+    if getattr(function, "strict", None) is False:
+        return True
+    parameters = function.parameters if function.parameters is not None else True
+    if isinstance(parameters, dict):
+        capped = cap_uncapped_array_max_items(parameters)
+        return cap_uncapped_query_string_max_length(capped)
+    return parameters
+
+
+def _gigachat3_tool_tags(tools: list[FunctionToolParam]) -> list[TagFormat]:
+    return [
+        TagFormat(
+            begin=begin + tool.function.name + _ARGUMENTS_FIELD_PREFIX,
+            content=JSONSchemaFormat(
+                json_schema=_tool_argument_schema(tool.function),
+                max_whitespace_cnt=2,
+            ),
+            end=end,
+        )
+        for tool in tools
+        for begin, end in _FUNCTION_CALL_WRAPS
+    ]
+
+
+@register_vllm_structural_tag("gigachat3")
+def get_gigachat3_structural_tag(
+    tools: list[FunctionToolParam],
+    builtin_tools: list[BuiltinToolParam],
+    tool_choice: str,
+    reasoning: bool,
+) -> StructuralTag:
+    del builtin_tools, reasoning
+    tags = _gigachat3_tool_tags(tools)
+    if tool_choice == "auto":
+        suffix_tag = (
+            TriggeredTagsFormat(triggers=list(_FUNCTION_CALL_TRIGGERS), tags=tags)
+            if tags
+            else AnyTextFormat()
+        )
+    else:
+        suffix_tag = TagsWithSeparatorFormat(
+            tags=tags,
+            separator="",
+            at_least_one=True,
+            stop_after_first=True,
+        )
+    return StructuralTag(format=suffix_tag)
+
+
+class GigaChat3StructuralToolParser(GigaChat3ToolParser):
+    """Upstream gigachat3 parser with a GigaChat xgrammar structural tag."""
+
+    structural_tag_model = "gigachat3"
+    supports_required_and_named = False
+
+    def adjust_request(self, request):
+        if request.tools and request.tool_choice != "none":
+            request.skip_special_tokens = False
+        guided = guided_string_enums_from_request(request)
+        structured = getattr(request, "structured_outputs", None)
+        structural_tag = (
+            getattr(structured, "structural_tag", None) if structured is not None else None
+        )
+        if guided and isinstance(structural_tag, str) and structural_tag:
+            min_items, max_items = guided_array_bounds_from_request(request)
+            structured.structural_tag = patch_structural_tag_json(
+                structural_tag,
+                guided,
+                min_items=min_items,
+                max_items=max_items,
+            )
+        return request
+
+
+ToolParserManager.register_module(
+    name=GIGACHAT3_TOOL_CALL_PARSER,
+    force=True,
+    module=GigaChat3StructuralToolParser,
+)
+ToolParserManager.lazy_parsers.pop(GIGACHAT3_TOOL_CALL_PARSER, None)

requirements.txt

@@ -0,0 +1,17 @@
+# Serving pins for SMITH-10B-Exp (vLLM + transformers generate).
+# SPDX comments apply to the named package only; pip also installs
+# transitive dependencies under their own licenses.
+#
+# xgrammar 0.2.4+ requires transformers<5; keep 0.2.3 with Transformers 5.6.2.
+
+# Apache-2.0 — huggingface/transformers
+# https://pypi.org/project/transformers/
+transformers==5.6.2
+
+# Apache-2.0 — vllm-project/vllm
+# https://pypi.org/project/vllm/
+vllm==0.25.1
+
+# Apache-2.0 — mlc-ai/xgrammar
+# https://pypi.org/project/xgrammar/
+xgrammar==0.2.3

special_tokens_map.json

@@ -0,0 +1,16 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,131 @@
+{
+  "added_tokens_decoder": {
+    "1": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128000": {
+      "content": "<|role_sep|>\n",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128001": {
+      "content": "<|message_sep|>\n\n",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128002": {
+      "content": "<|file|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128003": {
+      "content": "<|/file|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128004": {
+      "content": "[image_token]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128005": {
+      "content": "[video_image_token]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128006": {
+      "content": "[audio_token]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128007": {
+      "content": "[video_audio_token]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128008": {
+      "content": "<point>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128009": {
+      "content": "</point>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128010": {
+      "content": "<bbox>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128011": {
+      "content": "</bbox>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }, 
+    "128012": {
+      "content": "<|function_call|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": true,
+  "eos_token": "</s>",
+  "extra_special_tokens": {},
+  "model_max_length": 1000000000000000019884624838656,
+  "tokenizer_class": "PreTrainedTokenizer",
+  "unk_token": null
+}