Update weights

MERGE_REPORT.json

@@ -1,31 +1,31 @@
 {
   "snapshot": "mistralai/Ministral-3-8B-Instruct-2512-BF16@f6fae9795746f63c9be8344932f01275f3c63734",
-  "adapter": "StandardOne-8B-LoRA v2 (training run r5-8b)",
-  "adapter_sha256": "53e41238cd55567cfbc75efdf61d354da39771573f56f74bb1440c9ffdd1bd4a",
+  "adapter": "StandardOne-8B-LoRA v2.2",
+  "adapter_sha256": "123ddd039f4053e82e8ca18d7c247691dc49cbcabb6e1b7d98077bb7c5c7446e",
   "changed_params": 238,
   "unchanged_params": 293,
   "changed_outside_lm_projections": [],
-  "max_abs_delta": 0.00201416015625,
+  "max_abs_delta": 0.002109527587890625,
   "changed_sample": [
     [
       "model.language_model.layers.0.self_attn.q_proj.weight",
-      0.00146484375
+      0.00152587890625
     ],
     [
       "model.language_model.layers.0.self_attn.k_proj.weight",
-      0.0009765625
+      0.00091552734375
     ],
     [
       "model.language_model.layers.0.self_attn.v_proj.weight",
-      0.0011348724365234375
+      0.0012216567993164062
     ],
     [
       "model.language_model.layers.0.self_attn.o_proj.weight",
-      0.001430511474609375
+      0.001377105712890625
     ],
     [
       "model.language_model.layers.0.mlp.gate_proj.weight",
-      0.00112152099609375
+      0.00113677978515625
     ],
     [
       "model.language_model.layers.0.mlp.up_proj.weight",
@@ -33,7 +33,7 @@
     ],
     [
       "model.language_model.layers.0.mlp.down_proj.weight",
-      0.00058746337890625
+      0.0006103515625
     ],
     [
       "model.language_model.layers.1.self_attn.q_proj.weight",
@@ -45,10 +45,10 @@
     "chat_template.jinja": "74eeb55fd3341286ec3fd44e902b7120721acc81cd394e96b431f85e93a1ea56",
     "config.json": "111827aa7ae6d936f48afb2f0776f51b00add45c857c708af2b893499f76d882",
     "generation_config.json": "e0923390059f84a9180b00e5501778acc45ea9856cd7f2fd68208b360927c677",
-    "model-00001-of-00004.safetensors": "5b29a2e3e86366c0b2e21c5038a16fa1f2bed8a2ca69e5e775608126570c89d4",
-    "model-00002-of-00004.safetensors": "65c9000a4aafa0cb0978540cfdbb6017e39f14a208a8d0523d375656f5cf0343",
-    "model-00003-of-00004.safetensors": "fe537b22d9b005873c25b0f8ca0548e24f6d3a4fb611db11becc6ba86c849a03",
-    "model-00004-of-00004.safetensors": "6c3f84685c69360d991bf02b81ac670fcb36cc1b9af2dd51e2137e0f3d36a24a",
+    "model-00001-of-00004.safetensors": "cac498368970b8ffb9785583c954648a40472b3cfa061ad0924af7babdee3f53",
+    "model-00002-of-00004.safetensors": "9a9fbec75dc4013463a57ad1cf61c2ed6fb558db9d379fb671dba0e448326be0",
+    "model-00003-of-00004.safetensors": "2f89f2111ee337b3b8b1278d0ec32bce3c20bfe5f2bab8caa6dd3e01a3c76ad5",
+    "model-00004-of-00004.safetensors": "125adfa505e3f9c1b33767601060c773a421876c3630fb8172dcdc886adf137f",
     "model.safetensors.index.json": "71e022361d37d84c2b6224acbddca2c74bedcc7addc523cfc6a57420d4b22ceb",
     "params.json": "81b8377f36c5b3d60900b333214d85160a0500b84576e969092c6fd214f69538",
     "processor_config.json": "ece2373c2ae391bce18785a1810543bc6173a1f28b6767cffab2c35dbea5f002",
@@ -56,6 +56,5 @@
     "tekken.json": "600bb27946565481ecf51ba8aee252e49b9a68507866080ac9c30185bb312843",
     "tokenizer.json": "d5f6046775b112f0e2d456ee9dba450684ab964fe5c4e231599bdc6773028135",
     "tokenizer_config.json": "f59f7294e4f26383d0ea93840fe21cf197784be0842a8301a0343e8c34ed0d6d"
-  },
-  "seconds": 65.5
-}
+  }
+}

SHA256SUMS

@@ -1,8 +1,8 @@
 1495e1e757ef4d0925a2350563cf5754bb23c51701a8ec4fb3c5cdcbedae6747  LICENSE
-0fae9e8380c795cd6d6fa9f1733c408df7b27bf009d947ebb15adc96ad40dfab  MERGE_REPORT.json
+78430ac850a7b8182093fadb6fafa36d70ad79f548b5369d261ef81034343b24  MERGE_REPORT.json
 20486cf6b2e42440b0aea913ea475c818664f34e76e4501651d6cb21987a508b  NOTICE
-0ffad36ca79c67234dd1bfbb9e24d1d236beaf8d2297c3c2052b9a1d4df30f20  QUICKSTART.md
-e96d53b993eb557a54492a0234907503692a05884027a2106d44c398a218ebb7  README.md
+7fdc581f9a4e8bb935e3c883435b456d283aea2e439f4560103e0923c39080be  QUICKSTART.md
+33f44c5a637384c0153be71319eafeee6013241d801efa06b41183bdc4e30faa  README.md
 66e0fda8c8ab269ccd010dca6196931d475a22c3f2eebe5b6b3a2ec33a354d0e  SYSTEM_PROMPT.txt
 74eeb55fd3341286ec3fd44e902b7120721acc81cd394e96b431f85e93a1ea56  chat_template.jinja
 111827aa7ae6d936f48afb2f0776f51b00add45c857c708af2b893499f76d882  config.json
@@ -17,7 +17,7 @@ dd888be78c0e32894cf04a8e3fbf8757e7218873668fa4443ba47c7c1c48b6dc  docs/assets/04
 22396bd8908b697d912bd1ec54a510eff2b2b1884cd00b5e1bedd81db450d2fa  docs/assets/05-gain-over-base.svg
 c43fb809f0b6bff34530fe2970fbd59817ae56e93813da7f45af32a8b9413987  docs/assets/06-vs-jev.png
 23fe4cfc32b756068dd3967339bae947391a18f1c4c0de5bad5c0dceeaff3463  docs/assets/06-vs-jev.svg
-df15177d9f8022598ac7af696600afcee14dd531875c519c2e2db74f0fc2498c  docs/public-classification-suites.md
+58d920ce53f77d10b78f857e67bd5fecec86405a23a5643101e3b0d2d367f4db  docs/public-classification-suites.md
 7866009cccf468a71c56163d0ec27eee5185e5d8dc4c1a495f91445229eb4c95  evidence/calibration-leaderboard-ablate-nosys.json
 e3b7eb0fff1504035ab7ddbe01af976db48236872e6b77fc7bcdc766a60fd000  evidence/calibration-leaderboard-merged-native.json
 a717a16ab338fb5a3aefe0822a5421732cb2f68d965691fdb8138ded0b4d70b3  evidence/calibration-per-type-served.json
@@ -27,17 +27,17 @@ a33036e10498a440481258cbbc8611b531498d6239115a9278c3e6cafe10f6ad  evidence/serve
 d47f43be5bd7767b80ed27a96a9a85ece1495b37fb9365e575b1df6b32fbc509  evidence/served-nosys-latency-idle-gpu.json
 262f5c7f85fcc5b8a9ccfaa7485d8b9f11a70f3d5a2ff60868ff9ccd1e887b43  evidence/served-nosys-original-report.json
 e0923390059f84a9180b00e5501778acc45ea9856cd7f2fd68208b360927c677  generation_config.json
-5b29a2e3e86366c0b2e21c5038a16fa1f2bed8a2ca69e5e775608126570c89d4  model-00001-of-00004.safetensors
-65c9000a4aafa0cb0978540cfdbb6017e39f14a208a8d0523d375656f5cf0343  model-00002-of-00004.safetensors
-fe537b22d9b005873c25b0f8ca0548e24f6d3a4fb611db11becc6ba86c849a03  model-00003-of-00004.safetensors
-6c3f84685c69360d991bf02b81ac670fcb36cc1b9af2dd51e2137e0f3d36a24a  model-00004-of-00004.safetensors
+cac498368970b8ffb9785583c954648a40472b3cfa061ad0924af7babdee3f53  model-00001-of-00004.safetensors
+9a9fbec75dc4013463a57ad1cf61c2ed6fb558db9d379fb671dba0e448326be0  model-00002-of-00004.safetensors
+2f89f2111ee337b3b8b1278d0ec32bce3c20bfe5f2bab8caa6dd3e01a3c76ad5  model-00003-of-00004.safetensors
+125adfa505e3f9c1b33767601060c773a421876c3630fb8172dcdc886adf137f  model-00004-of-00004.safetensors
 71e022361d37d84c2b6224acbddca2c74bedcc7addc523cfc6a57420d4b22ceb  model.safetensors.index.json
 81b8377f36c5b3d60900b333214d85160a0500b84576e969092c6fd214f69538  params.json
 ece2373c2ae391bce18785a1810543bc6173a1f28b6767cffab2c35dbea5f002  processor_config.json
-12068f5b55e15718a228e32c5a29d482749216a557f415faa2345c858ad79094  release-manifest.json
+6741d6b57b543a839be57e56b6189562bd098050a0eca7bf53b8016500e4324c  release-manifest.json
 1495e1e757ef4d0925a2350563cf5754bb23c51701a8ec4fb3c5cdcbedae6747  server/LICENSE
 0f1f023b916d38d7c12af3a71e09f5e82b819a7e156e4992118bb160ee63ede1  server/NOTICE
-e58911cf75448ce8951377d46eeb531158c46db0586faedd22cccdfd69193013  server/README.md
+6385bb6dba77ed768d7214a8f17a311db266ea99bdd34e1fab2f0735e4a41e0f  server/README.md
 88e4dea8cc92f467a03bdd45a5fb968e402517116b09e24edcea85bb15f121e5  server/benchmarks/DECISION_BENCHMARK_SELECTION.md
 7fea6b9dc44e34ce448f1d80a9f2d273b76ab9b0ac1859c032fa4faa4f458501  server/benchmarks/METRIC_VALIDATION.md
 bb88f12ef294680e389147d781bf1f8680ea0a5ca9ed554730d8ea29f1c25eb9  server/benchmarks/PUBLIC_DATASETS.md
@@ -59,7 +59,7 @@ fee797d1a2ff128a5d61dd436e8252d63bc726b8ce4ba72641a1ffd9196135a6  server/benchma
 2544280dd3e669985bf57dfc61c2212bcf16d27230a79cea76f9f4e822476429  server/examples/request.json
 7a14fe0f5bf73aca7a4930423c310c0a3b1f9b546d07abc8d3fd5d9f38c9a5d7  server/examples/smoke.py
 e589f268969c87f82ddd2c81c0432c6335c08a9f9f2537ce68ddd5708f1e6f9e  server/jev_adapter/__init__.py
-bf3d7a38ac294b23bf0d1a6b32a66fffb5054affc7d8958a821d9aea4f3ef807  server/jev_adapter/__main__.py
+caacf020f66bbfbf1e09ac303a7e9adbe493ad4154a1339c203c8ff87fb3392a  server/jev_adapter/__main__.py
 e2f84bb7867934533f8f2a87034cad76af695ca1bbdbf096c545fe60b790c6fa  server/jev_adapter/backend.py
 2cd67e71c1a601fc9333c266d909197031b7c0dc746b9a2d5475a5fb0c085e95  server/jev_adapter/benchmarks/__init__.py
 44104bc2d6431c05345cd697dd2c377cc6ba9fd57f2177df7b548490cf5f53fc  server/jev_adapter/benchmarks/compare.py
@@ -68,21 +68,26 @@ a66e6ec289b4c32f79ac990261650870be6b923e47753b9c89ff9e58fe2f982f  server/jev_ada
 1b78c52f723cb3a3e614d1be4ca531e7595e0a6690e704d6f1bb3045dd948bf0  server/jev_adapter/benchmarks/metrics.py
 9c51ce87269c587f1353b9dd32d886f9f0a51613a996721a7bb81695af445c02  server/jev_adapter/benchmarks/prepare.py
 0fef99cd01164c5548de530c9ab93255e2a95d17757c12e8e3d23016afd1a03c  server/jev_adapter/benchmarks/run.py
+9a3d1c89d7451a52383709487acb883f683dbdcb2ca73b5a9b39b9b75407a09e  server/jev_adapter/labels.py
 86e113a3ee9d15d9be93ba5e964d5f5d51171619e7856cc7dde812c6c90f4a37  server/jev_adapter/native_tokenizer.py
-ad7dee34b9c15e83ce66b3b8b07266e0b8ce81da7c8ba692a8293dbf078d0e44  server/jev_adapter/protocol.py
-bf9c1588e8069ef2c341151c24f08b29f41d9bc57cb16f1866467467b50d8edc  server/jev_adapter/server.py
-332068ebc21f19b6eee6c6d8fd24e6821a4fbd5def6251f5a94beae613419a0a  server/jev_adapter/service.py
-2e45894cfb8fa204c7278ade4a123cda356de894ddf6fbb60b66e93dfea576c6  server/jev_adapter/sglang.py
+0acba8046427725f4275cd971cfc29f48c04c64e73f96115b83ce8ac1bcbe8b7  server/jev_adapter/protocol.py
+4375a9eafb6d252a76b2b57dd7cecfd600baae04a9ab4dd0abbd6c86a3778be9  server/jev_adapter/server.py
+24667f1c1d6967f5a1c90d6e9bf13922bdfe1ce1a3aea8709c18a1837d2fe09c  server/jev_adapter/service.py
+18b3191db6a3e43a2ad01243c709bab2c8db771b1363638de64ab4871b0f1d7b  server/jev_adapter/sglang.py
 159eb400efb830c762a36f81e51ba79888570284ffa70326301adfeee50b5bd3  server/pyproject.toml
+d4d01e7e2c0d49ccce56516db8aaef0eb32d001b42e8f394e7e355e90047db71  server/tests/conftest.py
+63046320ac89d71770afccf8f3ad861c795151ede968354f34f59aabff9ec5c3  server/tests/data/ministral3-label-probe.json
+27119a52ee9a0417809c3a50b5b07e77aa723d4a63266d1065ba8ca82589d512  server/tests/data/upper-labels-ministral3.json
 f5bf6e9b916ff0d24a2551b4f9f24ed353e7343f5be343b141d38c4c04bd1101  server/tests/test_benchmark_data.py
 c197a90d57c7516eb615f7f0626f4c3e95b2fd0773d74e8f32601251804fca66  server/tests/test_benchmark_matrix.py
 56a48c36d322d7131978809397da79d0f9abbb6801ab6176d27ed2f9dfb26063  server/tests/test_benchmark_run.py
 c492b41c07050d9b76c6c9d7d21bbfcdac6ec137346cf995df3f624cb1e345c8  server/tests/test_disconnect_cleanup.py
 83769ec3f35f5034787ffa8160a5ea7c9c7e23200b303d8b908500d71e3fe13f  server/tests/test_http_integration.py
 746cc73422976ec22b460a74a7c70d937c0ba4fd9fb7151fa6745641dbca5616  server/tests/test_jevbench.py
-ade6b76bacf23ae244d9790312f297a36557d6cd8075b81ce36e928359b742da  server/tests/test_main.py
+de052504cc7d82c964ef7cf4d6d2fafabf3ec61e4c4b359b9baadeea6b27c7f2  server/tests/test_labels.py
+af1ebfb5c57e2de76b8f90bdb6eec89abaa29ae3a1873595d4de287788c991af  server/tests/test_main.py
 83084f098020374a4abfa3d4402e74e357d45170ca840843e58dba13162e9986  server/tests/test_native_tokenizer.py
-0114da8966dafa951308ed58563053918b2b2f7b3393dd483c7183e3374b444d  server/tests/test_protocol.py
+b296814c9f0837d7c2625e1867b3197021f11c0b1c7ab5b74aa9c4b298b82396  server/tests/test_protocol.py
 617f08c82448932cf13320166c4df66a1a85b5056a354aa8e9f748ce9b6f57d3  server/tests/test_service.py
 340e91fb9a6c870990187386da8d165fafcbcb5f08559056fd9da4e4e78b681f  server/tests/test_sglang.py
 0a5c981e8c5c6f8886ee007a6d4543a0be6b221cb9ca32a8709384a4c6fc8cbb  special_tokens_map.json

model-00001-of-00004.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4ef4abdb14796255a76f30897dfd4e98d6d601cc7c48a3c38d2d4bcd955bdb2f
+oid sha256:cac498368970b8ffb9785583c954648a40472b3cfa061ad0924af7babdee3f53
 size 4999724576

model-00002-of-00004.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:042b42a0abae0f07400c6ad515eff96f28399490695996d88eb6ee29ab96b6f0
+oid sha256:9a9fbec75dc4013463a57ad1cf61c2ed6fb558db9d379fb671dba0e448326be0
 size 4999820896

model-00003-of-00004.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:81f47613209ff4149d80961cf63472d58f05c1c5f98ba491464fb9d90970b34f
+oid sha256:2f89f2111ee337b3b8b1278d0ec32bce3c20bfe5f2bab8caa6dd3e01a3c76ad5
 size 4915917688

model-00004-of-00004.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9fa222d724cd363d44f37fffc7f7947eb964dff01ae760623370a65b4d67314b
+oid sha256:125adfa505e3f9c1b33767601060c773a421876c3630fb8172dcdc886adf137f
 size 2920659992

release-manifest.json

@@ -1,40 +1,38 @@
 {
   "release": "StandardOne-8B",
-  "version": "v2",
+  "version": "v2.2",
   "base_model": {
     "repo": "mistralai/Ministral-3-8B-Instruct-2512-BF16",
     "revision": "f6fae9795746f63c9be8344932f01275f3c63734"
   },
   "adapter": {
-    "source_run": "r5-8b",
-    "adapter_model_sha256": "53e41238cd55567cfbc75efdf61d354da39771573f56f74bb1440c9ffdd1bd4a"
+    "adapter_model_sha256": "123ddd039f4053e82e8ca18d7c247691dc49cbcabb6e1b7d98077bb7c5c7446e"
   },
   "merge_report_summary": {
     "changed_params": 238,
     "unchanged_params": 293,
     "changed_outside_lm_projections": [],
-    "max_abs_delta": 0.00201416015625
+    "max_abs_delta": 0.002109527587890625
   },
   "serving": {
-    "wording": "native",
+    "wording": "served",
     "system_prompt": null,
+    "label_scheme": "upper",
     "served_model_name": "standard-one-8b",
     "engine": "SGLang 0.5.20",
-    "temperature_by_type": {
-      "choice": 0.85,
-      "noul": 0.85,
-      "score": 0.7
-    },
-    "default_temperature": 0.85,
-    "selection": "wording and temperatures chosen on non-JevBench data (evidence/prompt-wording-choice.json, evidence/calibration-per-type-served.json)",
+    "context_length": 32768,
+    "default_temperature": 1.65,
+    "selection": "the configuration used for the v2.2 measurements; no temperature was refit for v2.2",
     "alternative_wording": {
-      "wording": "served",
-      "default_temperature": 0.8,
+      "wording": "native",
+      "max_options": 26,
+      "default_temperature": 0.85,
       "temperature_by_type": {
-        "choice": 0.8,
-        "noul": 0.9,
-        "score": 0.95
-      }
+        "choice": 0.85,
+        "noul": 0.85,
+        "score": 0.7
+      },
+      "note": "temperatures fitted on v2"
     }
   }
 }

server/README.md

@@ -11,7 +11,7 @@ pip install -e './server[native-tokenizer]'
 CUDA_VISIBLE_DEVICES=0 SGLANG_VLM_CACHE_SIZE_MB=0 python -m sglang.launch_server \
   --model-path . --served-model-name standard-one-8b \
   --host 127.0.0.1 --port 30000 --tp-size 1 --model-impl sglang --dtype bfloat16 \
-  --context-length 8192 --max-running-requests 32 --mem-fraction-static 0.8 \
+  --context-length 32768 --max-running-requests 32 --mem-fraction-static 0.8 \
   --chunked-prefill-size -1 --disable-radix-cache --mm-preprocess-cache-size-mb 0 \
   --model-config-parser hf --load-format safetensors
 
@@ -20,13 +20,13 @@ jev-adapter --engine-url http://127.0.0.1:30000 --model standard-one-8b --alias
   --host 0.0.0.0 --port 30120 --max-concurrency 1 \
   --tokenizer-model mistralai/Ministral-3-8B-Instruct-2512-BF16 \
   --tokenizer-revision f6fae9795746f63c9be8344932f01275f3c63734 \
-  --prompt-wording native --native-system-prompt none --default-temperature 0.85 --temperature-by-type choice=0.85,noul=0.85,score=0.70
+  --prompt-wording served --label-scheme upper --default-temperature 1.65
 ```
 
-The adapter supports two prompt wordings; each has its own fitted temperatures (details on the model card):
+The adapter supports two prompt wordings (details on the model card):
 
-- `native` (recommended default): `--prompt-wording native --native-system-prompt none --default-temperature 0.85 --temperature-by-type choice=0.85,noul=0.85,score=0.70`
-- `served`: `--prompt-wording served --default-temperature 0.80 --temperature-by-type choice=0.80,noul=0.90,score=0.95`
+- `served` (the default, recommended; used for the v2.2 measurements): `--prompt-wording served --label-scheme upper --default-temperature 1.65`; up to 255 options per question
+- `native`: `--prompt-wording native --native-system-prompt none --default-temperature 0.85 --temperature-by-type choice=0.85,noul=0.85,score=0.70` (temperatures fitted on v2); at most 26 options per question
 
 `--temperature-by-type` sets one default temperature per answer type (`choice`, `noul`, `score`); a request's own
 `options.temperature` still wins. Let only this adapter talk to the engine port. The recommended values and the full
@@ -69,6 +69,8 @@ python3 -m venv .venv
 
 `--default-temperature T` (환경 변수 `JEV_DEFAULT_TEMPERATURE`)는 요청이 `options.temperature`를 생략했을 때만 적용되는 서버 기본 온도입니다. 요청이 온도를 명시하면 요청 값이 우선하고, `options.temperature_scaling: false`이면 기본값과 무관하게 스케일링하지 않습니다. 지정하지 않으면 기존과 같이 1.0입니다. 실제 적용된 온도는 응답의 `metadata.temperature`로 확인합니다.
 
+`--label-scheme {upper,served}` (환경 변수 `JEV_LABEL_SCHEME`)는 선택지가 26개를 넘는 질문의 답 라벨 순서입니다. 기본값 `upper`는 v2.2가 학습한 A–Z 다음 AA, AB, … 순서(한 토큰인 라벨만, 최대 255개)이고, `served`는 v2.2 이전의 A–Z, a–z, 0–9, AA, … 순서입니다. 26개 이하에서는 둘 다 A–Z입니다.
+
 `SGLANG_API_KEY`는 엔진에 보낼 키, `JEV_API_KEY`는 클라이언트가 어댑터에 보낼 키입니다. 설정했다면 각각 `Authorization: Bearer ...` 인증을 사용합니다. 키를 설정하지 않은 어댑터는 인증 없이 동작합니다.
 
 시작할 때 엔진 정보를 확인하고, 엔진 토크나이저로 라벨을 검증합니다. 엔진을 먼저 실행해야 합니다. 모델/토크나이저를 교체하면 어댑터도 재시작합니다.

server/jev_adapter/__main__.py

@@ -5,6 +5,8 @@ import logging
 import math
 import os
 
+from .labels import DEFAULT_LABEL_SCHEME, LABEL_SCHEME_ENV, LABEL_SCHEMES
+
 logger = logging.getLogger(__name__)
 
 
@@ -98,9 +100,25 @@ def main():
         "Ministral default is 531 tokens, about 80%% of a typical request). "
         "Env: JEV_NATIVE_SYSTEM_PROMPT.",
     )
+    parser.add_argument(
+        "--label-scheme",
+        choices=LABEL_SCHEMES,
+        default=os.environ.get(LABEL_SCHEME_ENV) or DEFAULT_LABEL_SCHEME,
+        help="Answer labels for questions with more than 26 options. 'upper' "
+        "(default): A-Z, then AA, AB, ... (uppercase only; labels that are not "
+        "single tokens are skipped). 'served': the original A-Z, a-z, 0-9, "
+        "then AA, ... order (pre-v2.2 serving). Both give A-Z to "
+        "questions with at most 26 options. Reported in /v1/models and in "
+        "response metadata. Env: JEV_LABEL_SCHEME.",
+    )
     # argparse runs the type converter on the string default too, so a bad
     # JEV_DEFAULT_TEMPERATURE fails at startup with the same message.
     args = parser.parse_args()
+    if args.label_scheme not in LABEL_SCHEMES:
+        parser.error(
+            f"JEV_LABEL_SCHEME must be one of {', '.join(LABEL_SCHEMES)}; "
+            f"got {args.label_scheme!r}"
+        )
     if args.timeout <= 0 or args.max_concurrency < 1:
         parser.error("timeout and max-concurrency must be positive")
     if bool(args.tokenizer_model) != bool(args.tokenizer_revision):
@@ -135,12 +153,13 @@ def main():
             "defines none); serving the native wording text without it."
         )
     logger.info(
-        "prompt_wording=%s native_system_prompt=%s (%s)",
+        "prompt_wording=%s native_system_prompt=%s (%s) label_scheme=%s",
         args.prompt_wording,
         args.native_system_prompt,
         "system message attached"
         if native_system_prompt
         else "no system message attached",
+        args.label_scheme,
     )
     backend = SGLangBackend(
         args.engine_url,
@@ -151,6 +170,7 @@ def main():
         native_tokenizer=native_tokenizer,
         prompt_wording=args.prompt_wording,
         native_system_prompt=native_system_prompt,
+        label_scheme=args.label_scheme,
     )
     app = create_app(
         backend,

server/jev_adapter/labels.py

@@ -0,0 +1,146 @@
+"""Answer-label schemes shared by serving, readout export, and training data.
+
+A scheme is an ordered list of candidate label strings. A model's labels are
+the candidates that its tokenizer encodes as one distinct, non-special token
+which decodes back to exactly the candidate, taken in candidate order, at most
+``MAX_LABELS``. A question with ``n`` options always uses the first ``n``.
+
+``upper`` (the default): ``A``..``Z``, then two-letter ``AA``, ``AB``, ...,
+``ZZ``, then three-letter ``AAA``..``ZZZ``; uppercase ASCII only, ordered by
+length and then alphabetically. Three-letter candidates are only consulted
+when the one- and two-letter single tokens number fewer than ``MAX_LABELS``.
+
+``served`` (the original order, kept to reproduce pre-v2.2 serving): ``A``..``Z``, ``a``..``z``,
+``0``..``9``, ``000``..``999``, ``AA``..``ZZ``, ``aa``..``zz``. No v2 training
+row had more than 26 options, so beyond Z neither order is what v2 learned.
+
+Both schemes give ``A``..``Z`` to questions with at most 26 options whenever
+the tokenizer has those 26 single-token letters.
+"""
+
+import itertools
+import os
+import re
+import string
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+LABEL_SCHEMES = ("served", "upper")
+DEFAULT_LABEL_SCHEME = "upper"
+LABEL_SCHEME_ENV = "JEV_LABEL_SCHEME"
+MAX_LABELS = 255
+UPPER_MAX_LENGTH = 3
+_UPPER_LABEL = re.compile(r"[A-Z]{1,3}")
+
+
+def validate_label_scheme(value: Any) -> str:
+    if value not in LABEL_SCHEMES:
+        raise ValueError(
+            f"label scheme must be one of {', '.join(LABEL_SCHEMES)}; got {value!r}"
+        )
+    return value
+
+
+def resolve_label_scheme(
+    value: str | None = None, environ: Mapping[str, str] | None = None
+) -> str:
+    """An explicit value, else ``JEV_LABEL_SCHEME``, else the default (upper)."""
+    if value is None or value == "":
+        environ = os.environ if environ is None else environ
+        value = environ.get(LABEL_SCHEME_ENV) or DEFAULT_LABEL_SCHEME
+    return validate_label_scheme(value)
+
+
+def _served_candidates() -> tuple[str, ...]:
+    letters = string.ascii_uppercase + string.ascii_lowercase + string.digits
+    return tuple(
+        list(letters)
+        + [f"{value:03d}" for value in range(1000)]
+        + [
+            first + second
+            for alphabet in (string.ascii_uppercase, string.ascii_lowercase)
+            for first in alphabet
+            for second in alphabet
+        ]
+    )
+
+
+def _upper_length(length: int) -> tuple[str, ...]:
+    return tuple(
+        "".join(chars)
+        for chars in itertools.product(string.ascii_uppercase, repeat=length)
+    )
+
+
+def candidate_tiers(scheme: str) -> tuple[tuple[str, ...], ...]:
+    """Candidates in order, grouped so a caller may stop after an early group.
+
+    A later group is consulted only while fewer than MAX_LABELS labels were
+    found; the concatenated order is the scheme's order either way.
+    """
+    validate_label_scheme(scheme)
+    if scheme == "served":
+        return (_served_candidates(),)
+    return (
+        _upper_length(1) + _upper_length(2),
+        _upper_length(3),
+    )
+
+
+def label_candidates(scheme: str) -> list[str]:
+    return [label for tier in candidate_tiers(scheme) for label in tier]
+
+
+def select_labels(
+    tokenizer: Any, scheme: str, *, limit: int = MAX_LABELS
+) -> tuple[list[str], list[int]]:
+    """The scheme's labels for a tokenizer with ``encode`` and ``decode``.
+
+    A candidate is kept when it encodes (without special tokens) to exactly
+    one token that is not special, not already taken, and decodes back to the
+    candidate. This is the rule every exporter, backend, and training-data
+    writer must share; it needs only the tokenizer files.
+    """
+    if type(limit) is not int or not 1 <= limit <= MAX_LABELS:
+        raise ValueError(f"limit must be an integer from 1 to {MAX_LABELS}")
+    special = set(getattr(tokenizer, "all_special_ids", ()) or ())
+    labels: list[str] = []
+    token_ids: list[int] = []
+    seen: set[int] = set()
+    for tier in candidate_tiers(scheme):
+        for label in tier:
+            ids = tokenizer.encode(label, add_special_tokens=False)
+            if not isinstance(ids, list) or len(ids) != 1 or type(ids[0]) is not int:
+                continue
+            token = ids[0]
+            if token < 0 or token in seen or token in special:
+                continue
+            if tokenizer.decode([token], skip_special_tokens=True) != label:
+                continue
+            labels.append(label)
+            token_ids.append(token)
+            seen.add(token)
+            if len(labels) == limit:
+                return labels, token_ids
+    return labels, token_ids
+
+
+def follows_scheme_order(scheme: str, labels: Sequence[str]) -> bool:
+    """Whether labels are distinct candidates of the scheme in scheme order.
+
+    A structural check that needs no tokenizer: it cannot tell whether a
+    skipped candidate was a single token, only that nothing is out of order.
+    """
+    validate_label_scheme(scheme)
+    if not labels or any(not isinstance(label, str) for label in labels):
+        return False
+    if scheme == "upper":
+        if any(_UPPER_LABEL.fullmatch(label) is None for label in labels):
+            return False
+        ranks = [(len(label), label) for label in labels]
+    else:
+        index = {label: position for position, label in enumerate(_served_candidates())}
+        if any(label not in index for label in labels):
+            return False
+        ranks = [index[label] for label in labels]
+    return all(before < after for before, after in itertools.pairwise(ranks))

server/jev_adapter/protocol.py

@@ -79,6 +79,9 @@ class NoulQuestion(_SystemOneModel):
     @field_validator("criteria")
     @classmethod
     def validate_boolean_criteria(cls, criteria):
+        # An empty map means "no descriptions", same as omitting the field.
+        if criteria == {}:
+            return None
         if criteria is not None and set(criteria) != {"true", "false"}:
             raise ValueError('noul criteria must contain exactly "true" and "false"')
         return criteria

server/jev_adapter/server.py

@@ -95,6 +95,11 @@ def create_app(
                     "id": backend.model,
                     "object": "model",
                     "owned_by": "inference-engine",
+                    **(
+                        {"label_scheme": backend.label_scheme}
+                        if getattr(backend, "label_scheme", None)
+                        else {}
+                    ),
                 },
             ],
         }

server/jev_adapter/service.py

@@ -166,6 +166,11 @@ class SystemOneService:
                     else {}
                 ),
                 "evaluations": len(jobs),
+                **(
+                    {"label_scheme": self.backend.label_scheme}
+                    if getattr(self.backend, "label_scheme", None)
+                    else {}
+                ),
                 "adapter_elapsed_ms": (time.perf_counter() - started) * 1000,
             },
         }

server/jev_adapter/sglang.py

@@ -7,27 +7,18 @@ No SGLang, CUDA, or model weights are imported into this process.
 
 import asyncio
 import math
-import string
 import uuid
 from typing import Any
 
 import httpx
 
 from .backend import AdapterError, ScoringResult
-
-
-def _label_candidates() -> list[str]:
-    letters = string.ascii_uppercase + string.ascii_lowercase + string.digits
-    return (
-        list(letters)
-        + [f"{value:03d}" for value in range(1000)]
-        + [
-            first + second
-            for alphabet in (string.ascii_uppercase, string.ascii_lowercase)
-            for first in alphabet
-            for second in alphabet
-        ]
-    )
+from .labels import (
+    DEFAULT_LABEL_SCHEME,
+    MAX_LABELS,
+    candidate_tiers,
+    validate_label_scheme,
+)
 
 
 _IMAGE_MODEL_TYPES = {
@@ -76,11 +67,14 @@ class SGLangBackend:
         native_tokenizer: Any | None = None,
         prompt_wording: str = "served",
         native_system_prompt: str | None = None,
+        label_scheme: str = DEFAULT_LABEL_SCHEME,
     ):
         if not math.isfinite(timeout) or timeout <= 0 or max_connections < 1:
             raise ValueError("timeout and max_connections must be positive")
         if prompt_wording not in ("served", "native"):
             raise ValueError('prompt_wording must be "served" or "native"')
+        # Which candidate order answer labels come from (jev_adapter.labels).
+        self.label_scheme = validate_label_scheme(label_scheme)
         url = httpx.URL(base_url)
         if (
             url.scheme not in ("http", "https")
@@ -217,61 +211,13 @@ class SGLangBackend:
                     if isinstance(arch, str)
                 )
             )
-            candidates = _label_candidates()
-            tokenized = await self._request(
-                "POST",
-                "/v1/tokenize",
-                {
-                    "model": self.model,
-                    "prompt": candidates,
-                    "add_special_tokens": False,
-                },
-            )
-            batches = tokenized.get("tokens")
-            if (
-                not isinstance(batches, list)
-                or len(batches) != len(candidates)
-                or not all(_token_list(ids) for ids in batches)
-            ):
-                raise _bad_response(
-                    "The inference engine returned malformed label tokenization."
-                )
-            singles = [
-                (label, ids[0])
-                for label, ids in zip(candidates, batches)
-                if len(ids) == 1
-            ]
-            if not singles:
-                raise AdapterError(
-                    "labels_unavailable",
-                    "The tokenizer has no usable single-token labels.",
-                )
-            decoded = await self._request(
-                "POST",
-                "/v1/detokenize",
-                {
-                    "model": self.model,
-                    "tokens": [[token] for _, token in singles],
-                    "skip_special_tokens": True,
-                },
-            )
-            texts = decoded.get("text")
-            if (
-                not isinstance(texts, list)
-                or len(texts) != len(singles)
-                or not all(isinstance(item, str) for item in texts)
-            ):
-                raise _bad_response(
-                    "The inference engine returned malformed label detokenization."
-                )
             valid: list[tuple[str, int]] = []
             seen: set[int] = set()
-            for (label, token), decoded_label in zip(singles, texts):
-                if label == decoded_label and token not in seen:
-                    valid.append((label, token))
-                    seen.add(token)
-                    if len(valid) == 255:
-                        break
+            # A later candidate group is tokenized only while labels are short.
+            for candidates in candidate_tiers(self.label_scheme):
+                if len(valid) == MAX_LABELS:
+                    break
+                await self._select_tier(list(candidates), valid, seen)
             if len(valid) < 2:
                 raise AdapterError(
                     "labels_unavailable",
@@ -280,6 +226,58 @@ class SGLangBackend:
             self._label_strings, self._label_ids = tuple(zip(*valid))
             self._ready = True
 
+    async def _select_tier(
+        self, candidates: list[str], valid: list[tuple[str, int]], seen: set[int]
+    ) -> None:
+        """Append this group's reversible single-token labels, in order."""
+        tokenized = await self._request(
+            "POST",
+            "/v1/tokenize",
+            {
+                "model": self.model,
+                "prompt": candidates,
+                "add_special_tokens": False,
+            },
+        )
+        batches = tokenized.get("tokens")
+        if (
+            not isinstance(batches, list)
+            or len(batches) != len(candidates)
+            or not all(_token_list(ids) for ids in batches)
+        ):
+            raise _bad_response(
+                "The inference engine returned malformed label tokenization."
+            )
+        singles = [
+            (label, ids[0]) for label, ids in zip(candidates, batches) if len(ids) == 1
+        ]
+        if not singles:
+            return
+        decoded = await self._request(
+            "POST",
+            "/v1/detokenize",
+            {
+                "model": self.model,
+                "tokens": [[token] for _, token in singles],
+                "skip_special_tokens": True,
+            },
+        )
+        texts = decoded.get("text")
+        if (
+            not isinstance(texts, list)
+            or len(texts) != len(singles)
+            or not all(isinstance(item, str) for item in texts)
+        ):
+            raise _bad_response(
+                "The inference engine returned malformed label detokenization."
+            )
+        for (label, token), decoded_label in zip(singles, texts):
+            if label == decoded_label and token not in seen:
+                valid.append((label, token))
+                seen.add(token)
+                if len(valid) == MAX_LABELS:
+                    return
+
     async def close(self) -> None:
         if self._owns_client:
             await self._client.aclose()

server/tests/conftest.py

@@ -0,0 +1,7 @@
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def _no_label_scheme_env(monkeypatch):
+    # The label scheme defaults from JEV_LABEL_SCHEME; tests set it explicitly.
+    monkeypatch.delenv("JEV_LABEL_SCHEME", raising=False)

server/tests/data/ministral3-label-probe.json

@@ -0,0 +1,1183 @@
+{
+ "schema": "jev-tokenizer-probe-v1",
+ "note": "Raw tokenizer behaviour on the one- and two-letter uppercase label candidates, recorded with AutoTokenizer at the pinned revision and cross-checked against tekken.json (mistral_common) and the release tokenizer.json. encode = encode(candidate, add_special_tokens=False); decode = decode([id], skip_special_tokens=True) for every single-token id.",
+ "tokenizer": {"id": "mistralai/Ministral-3-8B-Instruct-2512-BF16", "revision": "f6fae9795746f63c9be8344932f01275f3c63734", "class": "MistralCommonBackend", "tekken_json_sha256": "600bb27946565481ecf51ba8aee252e49b9a68507866080ac9c30185bb312843", "tokenizer_config_json_sha256": "f59f7294e4f26383d0ea93840fe21cf197784be0842a8301a0343e8c34ed0d6d", "release_tokenizer_json_sha256": "d5f6046775b112f0e2d456ee9dba450684ab964fe5c4e231599bdc6773028135"},
+ "special_id_ranges": [[0, 999]],
+ "expected_upper": {
+  "source": "upper-labels-ministral3.json",
+  "source_sha256": "27119a52ee9a0417809c3a50b5b07e77aa723d4a63266d1065ba8ca82589d512",
+  "labels": ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AK", "AL", "AM", "AN", "AO", "AP", "AR", "AS", "AT", "AU", "AV", "AX", "AY", "AZ", "BA", "BB", "BC", "BD", "BE", "BF", "BG", "BI", "BJ", "BL", "BM", "BN", "BO", "BP", "BR", "BS", "BT", "BU", "BV", "BW", "BY", "CA", "CB", "CC", "CD", "CE", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN", "CO", "CP", "CR", "CS", "CT", "CU", "CV", "CX", "CY", "DA", "DB", "DC", "DD", "DE", "DF", "DG", "DH", "DI", "DJ", "DK", "DL", "DM", "DN", "DO", "DP", "DR", "DS", "DT", "DU", "DX", "EA", "EB", "EC", "ED", "EE", "EF", "EG", "EK", "EL", "EM", "EN", "EO", "EP", "EQ", "ER", "ES", "ET", "EU", "EV", "EW", "EX", "FA", "FB", "FC", "FD", "FE", "FF", "FG", "FI", "FK", "FL", "FM", "FN", "FO", "FP", "FR", "FS", "FT", "FW", "FX", "GA", "GB", "GC", "GD", "GE", "GF", "GG", "GH", "GI", "GL", "GM", "GN", "GO", "GP", "GR", "GS", "GT", "GV", "GW", "HA", "HB", "HC", "HD", "HE", "HF", "HG", "HH", "HI", "HK", "HL", "HM", "HO", "HP", "HR", "HS", "HT", "HV", "IA", "IB", "IC", "ID", "IE", "IF", "IG", "II", "IK", "IL", "IM", "IN", "IO", "IP", "IR", "IS", "IT", "IU", "IV", "IX", "IZ", "JA", "JB", "JK", "JO", "JP", "JR", "JS", "KA", "KB", "KC", "KE", "KG", "KM", "KN", "KO", "KR", "KS", "KT", "LA", "LB", "LC", "LD", "LE", "LF", "LG", "LI", "LL", "LM", "LO", "LP", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MB", "MC", "MD", "ME", "MF", "MG", "MH"],
+  "token_ids": [1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 14229, 8062, 5193, 5516, 32484, 12763, 6970, 91939, 33613, 26039, 4286, 6758, 5010, 106550, 6292, 3905, 6003, 3313, 117778, 29970, 13339, 25698, 75317, 10574, 28235, 6535, 18704, 34817, 71042, 87478, 17782, 119492, 30631, 20195, 90805, 18412, 22133, 35846, 7814, 54206, 115497, 130196, 114957, 82317, 9467, 43379, 7619, 8584, 9158, 26910, 39176, 7247, 15466, 17131, 8534, 41183, 47271, 9335, 13943, 12540, 13754, 4061, 97829, 34456, 114741, 130282, 10878, 12223, 22561, 27789, 5088, 28562, 92842, 47909, 29951, 52972, 49329, 42559, 28081, 57310, 24151, 16108, 13705, 14249, 46565, 33674, 52885, 26759, 34112, 13275, 7051, 16748, 35971, 17238, 82787, 11213, 15187, 4456, 92580, 20573, 44943, 2794, 5548, 4321, 78963, 66703, 49942, 10164, 6507, 62311, 10858, 61930, 44675, 7762, 63511, 31638, 66480, 15869, 45746, 88826, 15740, 31994, 53744, 21313, 17310, 70351, 75215, 19454, 12737, 16497, 77858, 19527, 10624, 67199, 96633, 74536, 17899, 28533, 123165, 28649, 31714, 32874, 27735, 35985, 109488, 102348, 23303, 68291, 24093, 26205, 7626, 41999, 122632, 79438, 56611, 64447, 46862, 103147, 74873, 13719, 24498, 30316, 8395, 126227, 20501, 16433, 6048, 3084, 20851, 11098, 4351, 3022, 65015, 9387, 10667, 3174, 11364, 9918, 9474, 6673, 4778, 124666, 6217, 10445, 15152, 71794, 124356, 92274, 128992, 72267, 69496, 32452, 39711, 60305, 120387, 12623, 99414, 128745, 49744, 44338, 128762, 110718, 81092, 10265, 72458, 13515, 20008, 3561, 55938, 106747, 34732, 23947, 45623, 7618, 28547, 23356, 18369, 71905, 73275, 51489, 38180, 8900, 21291, 16126, 14534, 5180, 96790, 64937, 91805]
+ },
+ "encode": {
+  "A": [1065],
+  "B": [1066],
+  "C": [1067],
+  "D": [1068],
+  "E": [1069],
+  "F": [1070],
+  "G": [1071],
+  "H": [1072],
+  "I": [1073],
+  "J": [1074],
+  "K": [1075],
+  "L": [1076],
+  "M": [1077],
+  "N": [1078],
+  "O": [1079],
+  "P": [1080],
+  "Q": [1081],
+  "R": [1082],
+  "S": [1083],
+  "T": [1084],
+  "U": [1085],
+  "V": [1086],
+  "W": [1087],
+  "X": [1088],
+  "Y": [1089],
+  "Z": [1090],
+  "AA": [14229],
+  "AB": [8062],
+  "AC": [5193],
+  "AD": [5516],
+  "AE": [32484],
+  "AF": [12763],
+  "AG": [6970],
+  "AH": [91939],
+  "AI": [33613],
+  "AJ": [1065, 1074],
+  "AK": [26039],
+  "AL": [4286],
+  "AM": [6758],
+  "AN": [5010],
+  "AO": [106550],
+  "AP": [6292],
+  "AQ": [1065, 1081],
+  "AR": [3905],
+  "AS": [6003],
+  "AT": [3313],
+  "AU": [117778],
+  "AV": [29970],
+  "AW": [1065, 1087],
+  "AX": [13339],
+  "AY": [25698],
+  "AZ": [75317],
+  "BA": [10574],
+  "BB": [28235],
+  "BC": [6535],
+  "BD": [18704],
+  "BE": [34817],
+  "BF": [71042],
+  "BG": [87478],
+  "BH": [1066, 1072],
+  "BI": [17782],
+  "BJ": [119492],
+  "BK": [1066, 1075],
+  "BL": [30631],
+  "BM": [20195],
+  "BN": [90805],
+  "BO": [18412],
+  "BP": [22133],
+  "BQ": [1066, 1081],
+  "BR": [35846],
+  "BS": [7814],
+  "BT": [54206],
+  "BU": [115497],
+  "BV": [130196],
+  "BW": [114957],
+  "BX": [1066, 1088],
+  "BY": [82317],
+  "BZ": [1066, 1090],
+  "CA": [9467],
+  "CB": [43379],
+  "CC": [7619],
+  "CD": [8584],
+  "CE": [9158],
+  "CF": [26910],
+  "CG": [39176],
+  "CH": [7247],
+  "CI": [15466],
+  "CJ": [1067, 1074],
+  "CK": [17131],
+  "CL": [8534],
+  "CM": [41183],
+  "CN": [47271],
+  "CO": [9335],
+  "CP": [13943],
+  "CQ": [1067, 1081],
+  "CR": [12540],
+  "CS": [13754],
+  "CT": [4061],
+  "CU": [97829],
+  "CV": [34456],
+  "CW": [1067, 1087],
+  "CX": [114741],
+  "CY": [130282],
+  "CZ": [1067, 1090],
+  "DA": [10878],
+  "DB": [12223],
+  "DC": [22561],
+  "DD": [27789],
+  "DE": [5088],
+  "DF": [28562],
+  "DG": [92842],
+  "DH": [47909],
+  "DI": [29951],
+  "DJ": [52972],
+  "DK": [49329],
+  "DL": [42559],
+  "DM": [28081],
+  "DN": [57310],
+  "DO": [24151],
+  "DP": [16108],
+  "DQ": [1068, 1081],
+  "DR": [13705],
+  "DS": [14249],
+  "DT": [46565],
+  "DU": [33674],
+  "DV": [1068, 1086],
+  "DW": [1068, 1087],
+  "DX": [52885],
+  "DY": [1068, 1089],
+  "DZ": [1068, 1090],
+  "EA": [26759],
+  "EB": [34112],
+  "EC": [13275],
+  "ED": [7051],
+  "EE": [16748],
+  "EF": [35971],
+  "EG": [17238],
+  "EH": [1069, 1072],
+  "EI": [1069, 1073],
+  "EJ": [1069, 1074],
+  "EK": [82787],
+  "EL": [11213],
+  "EM": [15187],
+  "EN": [4456],
+  "EO": [92580],
+  "EP": [20573],
+  "EQ": [44943],
+  "ER": [2794],
+  "ES": [5548],
+  "ET": [4321],
+  "EU": [78963],
+  "EV": [66703],
+  "EW": [49942],
+  "EX": [10164],
+  "EY": [1069, 1089],
+  "EZ": [1069, 1090],
+  "FA": [6507],
+  "FB": [62311],
+  "FC": [10858],
+  "FD": [61930],
+  "FE": [44675],
+  "FF": [7762],
+  "FG": [63511],
+  "FH": [1070, 1072],
+  "FI": [31638],
+  "FJ": [1070, 1074],
+  "FK": [66480],
+  "FL": [15869],
+  "FM": [45746],
+  "FN": [88826],
+  "FO": [15740],
+  "FP": [31994],
+  "FQ": [1070, 1081],
+  "FR": [53744],
+  "FS": [21313],
+  "FT": [17310],
+  "FU": [1070, 1085],
+  "FV": [1070, 1086],
+  "FW": [70351],
+  "FX": [75215],
+  "FY": [1070, 1089],
+  "FZ": [1070, 1090],
+  "GA": [19454],
+  "GB": [12737],
+  "GC": [16497],
+  "GD": [77858],
+  "GE": [19527],
+  "GF": [10624],
+  "GG": [67199],
+  "GH": [96633],
+  "GI": [74536],
+  "GJ": [1071, 1074],
+  "GK": [1071, 1075],
+  "GL": [17899],
+  "GM": [28533],
+  "GN": [123165],
+  "GO": [28649],
+  "GP": [31714],
+  "GQ": [1071, 1081],
+  "GR": [32874],
+  "GS": [27735],
+  "GT": [35985],
+  "GU": [1071, 1085],
+  "GV": [109488],
+  "GW": [102348],
+  "GX": [1071, 1088],
+  "GY": [1071, 1089],
+  "GZ": [1071, 1090],
+  "HA": [23303],
+  "HB": [68291],
+  "HC": [24093],
+  "HD": [26205],
+  "HE": [7626],
+  "HF": [41999],
+  "HG": [122632],
+  "HH": [79438],
+  "HI": [56611],
+  "HJ": [1072, 1074],
+  "HK": [64447],
+  "HL": [46862],
+  "HM": [103147],
+  "HN": [1072, 1078],
+  "HO": [74873],
+  "HP": [13719],
+  "HQ": [1072, 1081],
+  "HR": [24498],
+  "HS": [30316],
+  "HT": [8395],
+  "HU": [1072, 1085],
+  "HV": [126227],
+  "HW": [1072, 1087],
+  "HX": [1072, 1088],
+  "HY": [1072, 1089],
+  "HZ": [1072, 1090],
+  "IA": [20501],
+  "IB": [16433],
+  "IC": [6048],
+  "ID": [3084],
+  "IE": [20851],
+  "IF": [11098],
+  "IG": [4351],
+  "IH": [1073, 1072],
+  "II": [3022],
+  "IJ": [1073, 1074],
+  "IK": [65015],
+  "IL": [9387],
+  "IM": [10667],
+  "IN": [3174],
+  "IO": [11364],
+  "IP": [9918],
+  "IQ": [1073, 1081],
+  "IR": [9474],
+  "IS": [6673],
+  "IT": [4778],
+  "IU": [124666],
+  "IV": [6217],
+  "IW": [1073, 1087],
+  "IX": [10445],
+  "IY": [1073, 1089],
+  "IZ": [15152],
+  "JA": [71794],
+  "JB": [124356],
+  "JC": [1074, 1067],
+  "JD": [1074, 1068],
+  "JE": [1074, 1069],
+  "JF": [1074, 1070],
+  "JG": [1074, 1071],
+  "JH": [1074, 1072],
+  "JI": [1074, 1073],
+  "JJ": [1074, 1074],
+  "JK": [92274],
+  "JL": [1074, 1076],
+  "JM": [1074, 1077],
+  "JN": [1074, 1078],
+  "JO": [128992],
+  "JP": [72267],
+  "JQ": [1074, 1081],
+  "JR": [69496],
+  "JS": [32452],
+  "JT": [1074, 1084],
+  "JU": [1074, 1085],
+  "JV": [1074, 1086],
+  "JW": [1074, 1087],
+  "JX": [1074, 1088],
+  "JY": [1074, 1089],
+  "JZ": [1074, 1090],
+  "KA": [39711],
+  "KB": [60305],
+  "KC": [120387],
+  "KD": [1075, 1068],
+  "KE": [12623],
+  "KF": [1075, 1070],
+  "KG": [99414],
+  "KH": [1075, 1072],
+  "KI": [1075, 1073],
+  "KJ": [1075, 1074],
+  "KK": [1075, 1075],
+  "KL": [1075, 1076],
+  "KM": [128745],
+  "KN": [49744],
+  "KO": [44338],
+  "KP": [1075, 1080],
+  "KQ": [1075, 1081],
+  "KR": [128762],
+  "KS": [110718],
+  "KT": [81092],
+  "KU": [1075, 1085],
+  "KV": [1075, 1086],
+  "KW": [1075, 1087],
+  "KX": [1075, 1088],
+  "KY": [1075, 1089],
+  "KZ": [1075, 1090],
+  "LA": [10265],
+  "LB": [72458],
+  "LC": [13515],
+  "LD": [20008],
+  "LE": [3561],
+  "LF": [55938],
+  "LG": [106747],
+  "LH": [1076, 1072],
+  "LI": [34732],
+  "LJ": [1076, 1074],
+  "LK": [1076, 1075],
+  "LL": [23947],
+  "LM": [45623],
+  "LN": [1076, 1078],
+  "LO": [7618],
+  "LP": [28547],
+  "LQ": [1076, 1081],
+  "LR": [23356],
+  "LS": [18369],
+  "LT": [71905],
+  "LU": [73275],
+  "LV": [51489],
+  "LW": [1076, 1087],
+  "LX": [1076, 1088],
+  "LY": [38180],
+  "LZ": [1076, 1090],
+  "MA": [8900],
+  "MB": [21291],
+  "MC": [16126],
+  "MD": [14534],
+  "ME": [5180],
+  "MF": [96790],
+  "MG": [64937],
+  "MH": [91805],
+  "MI": [13460],
+  "MJ": [1077, 1074],
+  "MK": [67375],
+  "ML": [6243],
+  "MM": [20451],
+  "MN": [113464],
+  "MO": [28497],
+  "MP": [7690],
+  "MQ": [94031],
+  "MR": [15755],
+  "MS": [7985],
+  "MT": [15901],
+  "MU": [1077, 1085],
+  "MV": [54258],
+  "MW": [93272],
+  "MX": [115032],
+  "MY": [61997],
+  "MZ": [1077, 1090],
+  "NA": [3251],
+  "NB": [46713],
+  "NC": [27822],
+  "ND": [6999],
+  "NE": [29156],
+  "NF": [17766],
+  "NG": [16705],
+  "NH": [19644],
+  "NI": [42859],
+  "NJ": [1078, 1074],
+  "NK": [41360],
+  "NL": [70818],
+  "NM": [99056],
+  "NN": [35756],
+  "NO": [16071],
+  "NP": [26640],
+  "NQ": [1078, 1081],
+  "NR": [36995],
+  "NS": [8772],
+  "NT": [15913],
+  "NU": [44113],
+  "NV": [63081],
+  "NW": [1078, 1087],
+  "NX": [1078, 1088],
+  "NY": [77192],
+  "NZ": [88653],
+  "OA": [89987],
+  "OB": [53045],
+  "OC": [11815],
+  "OD": [7460],
+  "OE": [55184],
+  "OF": [37979],
+  "OG": [48368],
+  "OH": [16724],
+  "OI": [1079, 1073],
+  "OJ": [1079, 1074],
+  "OK": [13257],
+  "OL": [8568],
+  "OM": [11135],
+  "ON": [2918],
+  "OO": [82414],
+  "OP": [14748],
+  "OQ": [1079, 1081],
+  "OR": [3749],
+  "OS": [6964],
+  "OT": [6918],
+  "OU": [32913],
+  "OV": [108230],
+  "OW": [12381],
+  "OX": [60261],
+  "OY": [1079, 1089],
+  "OZ": [1079, 1090],
+  "PA": [12118],
+  "PB": [76628],
+  "PC": [9793],
+  "PD": [9315],
+  "PE": [7134],
+  "PF": [74287],
+  "PG": [54406],
+  "PH": [45587],
+  "PI": [5119],
+  "PJ": [1080, 1074],
+  "PK": [47053],
+  "PL": [24520],
+  "PM": [25285],
+  "PN": [28666],
+  "PO": [7836],
+  "PP": [11388],
+  "PQ": [1080, 1081],
+  "PR": [17554],
+  "PS": [8148],
+  "PT": [11130],
+  "PU": [81208],
+  "PV": [61159],
+  "PW": [109996],
+  "PX": [1080, 1088],
+  "PY": [45242],
+  "PZ": [1080, 1090],
+  "QA": [1081, 1065],
+  "QB": [1081, 1066],
+  "QC": [1081, 1067],
+  "QD": [1081, 1068],
+  "QE": [1081, 1069],
+  "QF": [1081, 1070],
+  "QG": [1081, 1071],
+  "QH": [1081, 1072],
+  "QI": [1081, 1073],
+  "QJ": [1081, 1074],
+  "QK": [1081, 1075],
+  "QL": [7972],
+  "QM": [1081, 1077],
+  "QN": [1081, 1078],
+  "QO": [1081, 1079],
+  "QP": [1081, 1080],
+  "QQ": [1081, 1081],
+  "QR": [55582],
+  "QS": [1081, 1083],
+  "QT": [1081, 1084],
+  "QU": [27289],
+  "QV": [1081, 1086],
+  "QW": [1081, 1087],
+  "QX": [1081, 1088],
+  "QY": [1081, 1089],
+  "QZ": [1081, 1090],
+  "RA": [9295],
+  "RB": [84165],
+  "RC": [22805],
+  "RD": [50289],
+  "RE": [3609],
+  "RF": [43456],
+  "RG": [94542],
+  "RH": [82104],
+  "RI": [8707],
+  "RJ": [1082, 1074],
+  "RK": [105157],
+  "RL": [10397],
+  "RM": [72554],
+  "RN": [109334],
+  "RO": [4755],
+  "RP": [40773],
+  "RQ": [1082, 1081],
+  "RR": [60853],
+  "RS": [19693],
+  "RT": [19891],
+  "RU": [1082, 1085],
+  "RV": [101080],
+  "RW": [1082, 1087],
+  "RX": [130864],
+  "RY": [58675],
+  "RZ": [1082, 1090],
+  "SA": [11941],
+  "SB": [5038],
+  "SC": [7408],
+  "SD": [17173],
+  "SE": [3932],
+  "SF": [28036],
+  "SG": [29834],
+  "SH": [18731],
+  "SI": [27239],
+  "SJ": [1083, 1074],
+  "SK": [51753],
+  "SL": [27893],
+  "SM": [23162],
+  "SN": [54061],
+  "SO": [19124],
+  "SP": [8504],
+  "SQ": [1083, 1081],
+  "SR": [21967],
+  "SS": [4290],
+  "ST": [3074],
+  "SU": [50885],
+  "SV": [24592],
+  "SW": [74938],
+  "SX": [1083, 1088],
+  "SY": [101289],
+  "SZ": [1083, 1090],
+  "TA": [12887],
+  "TB": [64833],
+  "TC": [10504],
+  "TD": [30975],
+  "TE": [9265],
+  "TF": [34083],
+  "TG": [118593],
+  "TH": [12001],
+  "TI": [100838],
+  "TJ": [1084, 1074],
+  "TK": [105765],
+  "TL": [35570],
+  "TM": [40139],
+  "TN": [109975],
+  "TO": [9197],
+  "TP": [8426],
+  "TQ": [1084, 1081],
+  "TR": [13404],
+  "TS": [9983],
+  "TT": [26025],
+  "TU": [1084, 1085],
+  "TV": [11488],
+  "TW": [1084, 1087],
+  "TX": [100203],
+  "TY": [54462],
+  "TZ": [1084, 1090],
+  "UA": [69940],
+  "UB": [17982],
+  "UC": [24859],
+  "UD": [23855],
+  "UE": [8489],
+  "UF": [52359],
+  "UG": [17869],
+  "UH": [1085, 1072],
+  "UI": [8442],
+  "UJ": [1085, 1074],
+  "UK": [35960],
+  "UL": [4614],
+  "UM": [11458],
+  "UN": [8929],
+  "UO": [1085, 1079],
+  "UP": [15401],
+  "UQ": [1085, 1081],
+  "UR": [5553],
+  "US": [5507],
+  "UT": [5489],
+  "UU": [1085, 1085],
+  "UV": [34483],
+  "UW": [1085, 1087],
+  "UX": [82838],
+  "UY": [1085, 1089],
+  "UZ": [1085, 1090],
+  "VA": [15725],
+  "VB": [103461],
+  "VC": [20500],
+  "VD": [10566],
+  "VE": [16578],
+  "VF": [28198],
+  "VG": [122406],
+  "VH": [1086, 1072],
+  "VI": [31416],
+  "VJ": [1086, 1074],
+  "VK": [1086, 1075],
+  "VL": [1086, 1076],
+  "VM": [30569],
+  "VN": [98832],
+  "VO": [25313],
+  "VP": [22580],
+  "VQ": [1086, 1081],
+  "VR": [56994],
+  "VS": [73553],
+  "VT": [96527],
+  "VU": [1086, 1085],
+  "VV": [1086, 1086],
+  "VW": [1086, 1087],
+  "VX": [1086, 1088],
+  "VY": [1086, 1089],
+  "VZ": [1086, 1090],
+  "WA": [32111],
+  "WB": [126602],
+  "WC": [61778],
+  "WD": [51577],
+  "WE": [21147],
+  "WF": [81310],
+  "WG": [1087, 1071],
+  "WH": [25841],
+  "WI": [107939],
+  "WJ": [1087, 1074],
+  "WK": [79469],
+  "WL": [130049],
+  "WM": [52532],
+  "WN": [1087, 1078],
+  "WO": [69643],
+  "WP": [64557],
+  "WQ": [1087, 1081],
+  "WR": [44407],
+  "WS": [20266],
+  "WT": [38315],
+  "WU": [1087, 1085],
+  "WV": [1087, 1086],
+  "WW": [118278],
+  "WX": [1087, 1088],
+  "WY": [1087, 1089],
+  "WZ": [1087, 1090],
+  "XA": [1088, 1065],
+  "XB": [1088, 1066],
+  "XC": [1088, 1067],
+  "XD": [1088, 1068],
+  "XE": [1088, 1069],
+  "XF": [1088, 1070],
+  "XG": [1088, 1071],
+  "XH": [1088, 1072],
+  "XI": [107321],
+  "XJ": [1088, 1074],
+  "XK": [1088, 1075],
+  "XL": [113479],
+  "XM": [1088, 1077],
+  "XN": [1088, 1078],
+  "XO": [1088, 1079],
+  "XP": [1088, 1080],
+  "XQ": [1088, 1081],
+  "XR": [1088, 1082],
+  "XS": [1088, 1083],
+  "XT": [32225],
+  "XU": [1088, 1085],
+  "XV": [1088, 1086],
+  "XW": [1088, 1087],
+  "XX": [18860],
+  "XY": [50706],
+  "XZ": [1088, 1090],
+  "YA": [114400],
+  "YB": [1089, 1066],
+  "YC": [1089, 1067],
+  "YD": [1089, 1068],
+  "YE": [1089, 1069],
+  "YF": [1089, 1070],
+  "YG": [1089, 1071],
+  "YH": [1089, 1072],
+  "YI": [1089, 1073],
+  "YJ": [1089, 1074],
+  "YK": [1089, 1075],
+  "YL": [1089, 1076],
+  "YM": [1089, 1077],
+  "YN": [1089, 1078],
+  "YO": [45370],
+  "YP": [31130],
+  "YQ": [1089, 1081],
+  "YR": [1089, 1082],
+  "YS": [61300],
+  "YT": [1089, 1084],
+  "YU": [1089, 1085],
+  "YV": [1089, 1086],
+  "YW": [1089, 1087],
+  "YX": [1089, 1088],
+  "YY": [28131],
+  "YZ": [1089, 1090],
+  "ZA": [124622],
+  "ZB": [1090, 1066],
+  "ZC": [1090, 1067],
+  "ZD": [1090, 1068],
+  "ZE": [90133],
+  "ZF": [1090, 1070],
+  "ZG": [1090, 1071],
+  "ZH": [1090, 1072],
+  "ZI": [1090, 1073],
+  "ZJ": [1090, 1074],
+  "ZK": [1090, 1075],
+  "ZL": [1090, 1076],
+  "ZM": [1090, 1077],
+  "ZN": [1090, 1078],
+  "ZO": [1090, 1079],
+  "ZP": [1090, 1080],
+  "ZQ": [1090, 1081],
+  "ZR": [1090, 1082],
+  "ZS": [1090, 1083],
+  "ZT": [1090, 1084],
+  "ZU": [1090, 1085],
+  "ZV": [1090, 1086],
+  "ZW": [1090, 1087],
+  "ZX": [1090, 1088],
+  "ZY": [1090, 1089],
+  "ZZ": [105156]
+ },
+ "decode": {
+  "1065": "A",
+  "1066": "B",
+  "1067": "C",
+  "1068": "D",
+  "1069": "E",
+  "1070": "F",
+  "1071": "G",
+  "1072": "H",
+  "1073": "I",
+  "1074": "J",
+  "1075": "K",
+  "1076": "L",
+  "1077": "M",
+  "1078": "N",
+  "1079": "O",
+  "1080": "P",
+  "1081": "Q",
+  "1082": "R",
+  "1083": "S",
+  "1084": "T",
+  "1085": "U",
+  "1086": "V",
+  "1087": "W",
+  "1088": "X",
+  "1089": "Y",
+  "1090": "Z",
+  "2794": "ER",
+  "2918": "ON",
+  "3022": "II",
+  "3074": "ST",
+  "3084": "ID",
+  "3174": "IN",
+  "3251": "NA",
+  "3313": "AT",
+  "3561": "LE",
+  "3609": "RE",
+  "3749": "OR",
+  "3905": "AR",
+  "3932": "SE",
+  "4061": "CT",
+  "4286": "AL",
+  "4290": "SS",
+  "4321": "ET",
+  "4351": "IG",
+  "4456": "EN",
+  "4614": "UL",
+  "4755": "RO",
+  "4778": "IT",
+  "5010": "AN",
+  "5038": "SB",
+  "5088": "DE",
+  "5119": "PI",
+  "5180": "ME",
+  "5193": "AC",
+  "5489": "UT",
+  "5507": "US",
+  "5516": "AD",
+  "5548": "ES",
+  "5553": "UR",
+  "6003": "AS",
+  "6048": "IC",
+  "6217": "IV",
+  "6243": "ML",
+  "6292": "AP",
+  "6507": "FA",
+  "6535": "BC",
+  "6673": "IS",
+  "6758": "AM",
+  "6918": "OT",
+  "6964": "OS",
+  "6970": "AG",
+  "6999": "ND",
+  "7051": "ED",
+  "7134": "PE",
+  "7247": "CH",
+  "7408": "SC",
+  "7460": "OD",
+  "7618": "LO",
+  "7619": "CC",
+  "7626": "HE",
+  "7690": "MP",
+  "7762": "FF",
+  "7814": "BS",
+  "7836": "PO",
+  "7972": "QL",
+  "7985": "MS",
+  "8062": "AB",
+  "8148": "PS",
+  "8395": "HT",
+  "8426": "TP",
+  "8442": "UI",
+  "8489": "UE",
+  "8504": "SP",
+  "8534": "CL",
+  "8568": "OL",
+  "8584": "CD",
+  "8707": "RI",
+  "8772": "NS",
+  "8900": "MA",
+  "8929": "UN",
+  "9158": "CE",
+  "9197": "TO",
+  "9265": "TE",
+  "9295": "RA",
+  "9315": "PD",
+  "9335": "CO",
+  "9387": "IL",
+  "9467": "CA",
+  "9474": "IR",
+  "9793": "PC",
+  "9918": "IP",
+  "9983": "TS",
+  "10164": "EX",
+  "10265": "LA",
+  "10397": "RL",
+  "10445": "IX",
+  "10504": "TC",
+  "10566": "VD",
+  "10574": "BA",
+  "10624": "GF",
+  "10667": "IM",
+  "10858": "FC",
+  "10878": "DA",
+  "11098": "IF",
+  "11130": "PT",
+  "11135": "OM",
+  "11213": "EL",
+  "11364": "IO",
+  "11388": "PP",
+  "11458": "UM",
+  "11488": "TV",
+  "11815": "OC",
+  "11941": "SA",
+  "12001": "TH",
+  "12118": "PA",
+  "12223": "DB",
+  "12381": "OW",
+  "12540": "CR",
+  "12623": "KE",
+  "12737": "GB",
+  "12763": "AF",
+  "12887": "TA",
+  "13257": "OK",
+  "13275": "EC",
+  "13339": "AX",
+  "13404": "TR",
+  "13460": "MI",
+  "13515": "LC",
+  "13705": "DR",
+  "13719": "HP",
+  "13754": "CS",
+  "13943": "CP",
+  "14229": "AA",
+  "14249": "DS",
+  "14534": "MD",
+  "14748": "OP",
+  "15152": "IZ",
+  "15187": "EM",
+  "15401": "UP",
+  "15466": "CI",
+  "15725": "VA",
+  "15740": "FO",
+  "15755": "MR",
+  "15869": "FL",
+  "15901": "MT",
+  "15913": "NT",
+  "16071": "NO",
+  "16108": "DP",
+  "16126": "MC",
+  "16433": "IB",
+  "16497": "GC",
+  "16578": "VE",
+  "16705": "NG",
+  "16724": "OH",
+  "16748": "EE",
+  "17131": "CK",
+  "17173": "SD",
+  "17238": "EG",
+  "17310": "FT",
+  "17554": "PR",
+  "17766": "NF",
+  "17782": "BI",
+  "17869": "UG",
+  "17899": "GL",
+  "17982": "UB",
+  "18369": "LS",
+  "18412": "BO",
+  "18704": "BD",
+  "18731": "SH",
+  "18860": "XX",
+  "19124": "SO",
+  "19454": "GA",
+  "19527": "GE",
+  "19644": "NH",
+  "19693": "RS",
+  "19891": "RT",
+  "20008": "LD",
+  "20195": "BM",
+  "20266": "WS",
+  "20451": "MM",
+  "20500": "VC",
+  "20501": "IA",
+  "20573": "EP",
+  "20851": "IE",
+  "21147": "WE",
+  "21291": "MB",
+  "21313": "FS",
+  "21967": "SR",
+  "22133": "BP",
+  "22561": "DC",
+  "22580": "VP",
+  "22805": "RC",
+  "23162": "SM",
+  "23303": "HA",
+  "23356": "LR",
+  "23855": "UD",
+  "23947": "LL",
+  "24093": "HC",
+  "24151": "DO",
+  "24498": "HR",
+  "24520": "PL",
+  "24592": "SV",
+  "24859": "UC",
+  "25285": "PM",
+  "25313": "VO",
+  "25698": "AY",
+  "25841": "WH",
+  "26025": "TT",
+  "26039": "AK",
+  "26205": "HD",
+  "26640": "NP",
+  "26759": "EA",
+  "26910": "CF",
+  "27239": "SI",
+  "27289": "QU",
+  "27735": "GS",
+  "27789": "DD",
+  "27822": "NC",
+  "27893": "SL",
+  "28036": "SF",
+  "28081": "DM",
+  "28131": "YY",
+  "28198": "VF",
+  "28235": "BB",
+  "28497": "MO",
+  "28533": "GM",
+  "28547": "LP",
+  "28562": "DF",
+  "28649": "GO",
+  "28666": "PN",
+  "29156": "NE",
+  "29834": "SG",
+  "29951": "DI",
+  "29970": "AV",
+  "30316": "HS",
+  "30569": "VM",
+  "30631": "BL",
+  "30975": "TD",
+  "31130": "YP",
+  "31416": "VI",
+  "31638": "FI",
+  "31714": "GP",
+  "31994": "FP",
+  "32111": "WA",
+  "32225": "XT",
+  "32452": "JS",
+  "32484": "AE",
+  "32874": "GR",
+  "32913": "OU",
+  "33613": "AI",
+  "33674": "DU",
+  "34083": "TF",
+  "34112": "EB",
+  "34456": "CV",
+  "34483": "UV",
+  "34732": "LI",
+  "34817": "BE",
+  "35570": "TL",
+  "35756": "NN",
+  "35846": "BR",
+  "35960": "UK",
+  "35971": "EF",
+  "35985": "GT",
+  "36995": "NR",
+  "37979": "OF",
+  "38180": "LY",
+  "38315": "WT",
+  "39176": "CG",
+  "39711": "KA",
+  "40139": "TM",
+  "40773": "RP",
+  "41183": "CM",
+  "41360": "NK",
+  "41999": "HF",
+  "42559": "DL",
+  "42859": "NI",
+  "43379": "CB",
+  "43456": "RF",
+  "44113": "NU",
+  "44338": "KO",
+  "44407": "WR",
+  "44675": "FE",
+  "44943": "EQ",
+  "45242": "PY",
+  "45370": "YO",
+  "45587": "PH",
+  "45623": "LM",
+  "45746": "FM",
+  "46565": "DT",
+  "46713": "NB",
+  "46862": "HL",
+  "47053": "PK",
+  "47271": "CN",
+  "47909": "DH",
+  "48368": "OG",
+  "49329": "DK",
+  "49744": "KN",
+  "49942": "EW",
+  "50289": "RD",
+  "50706": "XY",
+  "50885": "SU",
+  "51489": "LV",
+  "51577": "WD",
+  "51753": "SK",
+  "52359": "UF",
+  "52532": "WM",
+  "52885": "DX",
+  "52972": "DJ",
+  "53045": "OB",
+  "53744": "FR",
+  "54061": "SN",
+  "54206": "BT",
+  "54258": "MV",
+  "54406": "PG",
+  "54462": "TY",
+  "55184": "OE",
+  "55582": "QR",
+  "55938": "LF",
+  "56611": "HI",
+  "56994": "VR",
+  "57310": "DN",
+  "58675": "RY",
+  "60261": "OX",
+  "60305": "KB",
+  "60853": "RR",
+  "61159": "PV",
+  "61300": "YS",
+  "61778": "WC",
+  "61930": "FD",
+  "61997": "MY",
+  "62311": "FB",
+  "63081": "NV",
+  "63511": "FG",
+  "64447": "HK",
+  "64557": "WP",
+  "64833": "TB",
+  "64937": "MG",
+  "65015": "IK",
+  "66480": "FK",
+  "66703": "EV",
+  "67199": "GG",
+  "67375": "MK",
+  "68291": "HB",
+  "69496": "JR",
+  "69643": "WO",
+  "69940": "UA",
+  "70351": "FW",
+  "70818": "NL",
+  "71042": "BF",
+  "71794": "JA",
+  "71905": "LT",
+  "72267": "JP",
+  "72458": "LB",
+  "72554": "RM",
+  "73275": "LU",
+  "73553": "VS",
+  "74287": "PF",
+  "74536": "GI",
+  "74873": "HO",
+  "74938": "SW",
+  "75215": "FX",
+  "75317": "AZ",
+  "76628": "PB",
+  "77192": "NY",
+  "77858": "GD",
+  "78963": "EU",
+  "79438": "HH",
+  "79469": "WK",
+  "81092": "KT",
+  "81208": "PU",
+  "81310": "WF",
+  "82104": "RH",
+  "82317": "BY",
+  "82414": "OO",
+  "82787": "EK",
+  "82838": "UX",
+  "84165": "RB",
+  "87478": "BG",
+  "88653": "NZ",
+  "88826": "FN",
+  "89987": "OA",
+  "90133": "ZE",
+  "90805": "BN",
+  "91805": "MH",
+  "91939": "AH",
+  "92274": "JK",
+  "92580": "EO",
+  "92842": "DG",
+  "93272": "MW",
+  "94031": "MQ",
+  "94542": "RG",
+  "96527": "VT",
+  "96633": "GH",
+  "96790": "MF",
+  "97829": "CU",
+  "98832": "VN",
+  "99056": "NM",
+  "99414": "KG",
+  "100203": "TX",
+  "100838": "TI",
+  "101080": "RV",
+  "101289": "SY",
+  "102348": "GW",
+  "103147": "HM",
+  "103461": "VB",
+  "105156": "ZZ",
+  "105157": "RK",
+  "105765": "TK",
+  "106550": "AO",
+  "106747": "LG",
+  "107321": "XI",
+  "107939": "WI",
+  "108230": "OV",
+  "109334": "RN",
+  "109488": "GV",
+  "109975": "TN",
+  "109996": "PW",
+  "110718": "KS",
+  "113464": "MN",
+  "113479": "XL",
+  "114400": "YA",
+  "114741": "CX",
+  "114957": "BW",
+  "115032": "MX",
+  "115497": "BU",
+  "117778": "AU",
+  "118278": "WW",
+  "118593": "TG",
+  "119492": "BJ",
+  "120387": "KC",
+  "122406": "VG",
+  "122632": "HG",
+  "123165": "GN",
+  "124356": "JB",
+  "124622": "ZA",
+  "124666": "IU",
+  "126227": "HV",
+  "126602": "WB",
+  "128745": "KM",
+  "128762": "KR",
+  "128992": "JO",
+  "130049": "WL",
+  "130196": "BV",
+  "130282": "CY",
+  "130864": "RX"
+ }
+}

server/tests/data/upper-labels-ministral3.json

@@ -0,0 +1,535 @@
+{
+ "schema": "jev-label-list-v1",
+ "label_scheme": "upper",
+ "tokenizer": {
+  "id": "mistralai/Ministral-3-8B-Instruct-2512-BF16",
+  "revision": "f6fae9795746f63c9be8344932f01275f3c63734",
+  "class": "MistralCommonBackend",
+  "tekken_json_sha256": "600bb27946565481ecf51ba8aee252e49b9a68507866080ac9c30185bb312843",
+  "tokenizer_config_json_sha256": "f59f7294e4f26383d0ea93840fe21cf197784be0842a8301a0343e8c34ed0d6d",
+  "release_tokenizer_json_sha256": "d5f6046775b112f0e2d456ee9dba450684ab964fe5c4e231599bdc6773028135"
+ },
+ "rule": "Candidates in order: A..Z, then AA..ZZ, then AAA..ZZZ (uppercase ASCII, by length then alphabetically). Keep a candidate when tokenizer.encode(label, add_special_tokens=False) is exactly one token id that is not a special id, not already used, and decode([id], skip_special_tokens=True) == label. Stop at 255. A question with n options (2 <= n <= 255) uses labels[:n] in display order.",
+ "single_token_counts": {
+  "one_letter": 26,
+  "two_letter": 439,
+  "three_letter": 425
+ },
+ "three_letter_used": false,
+ "answer_boundary_checked": "all 255 labels continue the native [/INST] chat prompt by exactly their token id",
+ "count": 255,
+ "labels": [
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F",
+  "G",
+  "H",
+  "I",
+  "J",
+  "K",
+  "L",
+  "M",
+  "N",
+  "O",
+  "P",
+  "Q",
+  "R",
+  "S",
+  "T",
+  "U",
+  "V",
+  "W",
+  "X",
+  "Y",
+  "Z",
+  "AA",
+  "AB",
+  "AC",
+  "AD",
+  "AE",
+  "AF",
+  "AG",
+  "AH",
+  "AI",
+  "AK",
+  "AL",
+  "AM",
+  "AN",
+  "AO",
+  "AP",
+  "AR",
+  "AS",
+  "AT",
+  "AU",
+  "AV",
+  "AX",
+  "AY",
+  "AZ",
+  "BA",
+  "BB",
+  "BC",
+  "BD",
+  "BE",
+  "BF",
+  "BG",
+  "BI",
+  "BJ",
+  "BL",
+  "BM",
+  "BN",
+  "BO",
+  "BP",
+  "BR",
+  "BS",
+  "BT",
+  "BU",
+  "BV",
+  "BW",
+  "BY",
+  "CA",
+  "CB",
+  "CC",
+  "CD",
+  "CE",
+  "CF",
+  "CG",
+  "CH",
+  "CI",
+  "CK",
+  "CL",
+  "CM",
+  "CN",
+  "CO",
+  "CP",
+  "CR",
+  "CS",
+  "CT",
+  "CU",
+  "CV",
+  "CX",
+  "CY",
+  "DA",
+  "DB",
+  "DC",
+  "DD",
+  "DE",
+  "DF",
+  "DG",
+  "DH",
+  "DI",
+  "DJ",
+  "DK",
+  "DL",
+  "DM",
+  "DN",
+  "DO",
+  "DP",
+  "DR",
+  "DS",
+  "DT",
+  "DU",
+  "DX",
+  "EA",
+  "EB",
+  "EC",
+  "ED",
+  "EE",
+  "EF",
+  "EG",
+  "EK",
+  "EL",
+  "EM",
+  "EN",
+  "EO",
+  "EP",
+  "EQ",
+  "ER",
+  "ES",
+  "ET",
+  "EU",
+  "EV",
+  "EW",
+  "EX",
+  "FA",
+  "FB",
+  "FC",
+  "FD",
+  "FE",
+  "FF",
+  "FG",
+  "FI",
+  "FK",
+  "FL",
+  "FM",
+  "FN",
+  "FO",
+  "FP",
+  "FR",
+  "FS",
+  "FT",
+  "FW",
+  "FX",
+  "GA",
+  "GB",
+  "GC",
+  "GD",
+  "GE",
+  "GF",
+  "GG",
+  "GH",
+  "GI",
+  "GL",
+  "GM",
+  "GN",
+  "GO",
+  "GP",
+  "GR",
+  "GS",
+  "GT",
+  "GV",
+  "GW",
+  "HA",
+  "HB",
+  "HC",
+  "HD",
+  "HE",
+  "HF",
+  "HG",
+  "HH",
+  "HI",
+  "HK",
+  "HL",
+  "HM",
+  "HO",
+  "HP",
+  "HR",
+  "HS",
+  "HT",
+  "HV",
+  "IA",
+  "IB",
+  "IC",
+  "ID",
+  "IE",
+  "IF",
+  "IG",
+  "II",
+  "IK",
+  "IL",
+  "IM",
+  "IN",
+  "IO",
+  "IP",
+  "IR",
+  "IS",
+  "IT",
+  "IU",
+  "IV",
+  "IX",
+  "IZ",
+  "JA",
+  "JB",
+  "JK",
+  "JO",
+  "JP",
+  "JR",
+  "JS",
+  "KA",
+  "KB",
+  "KC",
+  "KE",
+  "KG",
+  "KM",
+  "KN",
+  "KO",
+  "KR",
+  "KS",
+  "KT",
+  "LA",
+  "LB",
+  "LC",
+  "LD",
+  "LE",
+  "LF",
+  "LG",
+  "LI",
+  "LL",
+  "LM",
+  "LO",
+  "LP",
+  "LR",
+  "LS",
+  "LT",
+  "LU",
+  "LV",
+  "LY",
+  "MA",
+  "MB",
+  "MC",
+  "MD",
+  "ME",
+  "MF",
+  "MG",
+  "MH"
+ ],
+ "token_ids": [
+  1065,
+  1066,
+  1067,
+  1068,
+  1069,
+  1070,
+  1071,
+  1072,
+  1073,
+  1074,
+  1075,
+  1076,
+  1077,
+  1078,
+  1079,
+  1080,
+  1081,
+  1082,
+  1083,
+  1084,
+  1085,
+  1086,
+  1087,
+  1088,
+  1089,
+  1090,
+  14229,
+  8062,
+  5193,
+  5516,
+  32484,
+  12763,
+  6970,
+  91939,
+  33613,
+  26039,
+  4286,
+  6758,
+  5010,
+  106550,
+  6292,
+  3905,
+  6003,
+  3313,
+  117778,
+  29970,
+  13339,
+  25698,
+  75317,
+  10574,
+  28235,
+  6535,
+  18704,
+  34817,
+  71042,
+  87478,
+  17782,
+  119492,
+  30631,
+  20195,
+  90805,
+  18412,
+  22133,
+  35846,
+  7814,
+  54206,
+  115497,
+  130196,
+  114957,
+  82317,
+  9467,
+  43379,
+  7619,
+  8584,
+  9158,
+  26910,
+  39176,
+  7247,
+  15466,
+  17131,
+  8534,
+  41183,
+  47271,
+  9335,
+  13943,
+  12540,
+  13754,
+  4061,
+  97829,
+  34456,
+  114741,
+  130282,
+  10878,
+  12223,
+  22561,
+  27789,
+  5088,
+  28562,
+  92842,
+  47909,
+  29951,
+  52972,
+  49329,
+  42559,
+  28081,
+  57310,
+  24151,
+  16108,
+  13705,
+  14249,
+  46565,
+  33674,
+  52885,
+  26759,
+  34112,
+  13275,
+  7051,
+  16748,
+  35971,
+  17238,
+  82787,
+  11213,
+  15187,
+  4456,
+  92580,
+  20573,
+  44943,
+  2794,
+  5548,
+  4321,
+  78963,
+  66703,
+  49942,
+  10164,
+  6507,
+  62311,
+  10858,
+  61930,
+  44675,
+  7762,
+  63511,
+  31638,
+  66480,
+  15869,
+  45746,
+  88826,
+  15740,
+  31994,
+  53744,
+  21313,
+  17310,
+  70351,
+  75215,
+  19454,
+  12737,
+  16497,
+  77858,
+  19527,
+  10624,
+  67199,
+  96633,
+  74536,
+  17899,
+  28533,
+  123165,
+  28649,
+  31714,
+  32874,
+  27735,
+  35985,
+  109488,
+  102348,
+  23303,
+  68291,
+  24093,
+  26205,
+  7626,
+  41999,
+  122632,
+  79438,
+  56611,
+  64447,
+  46862,
+  103147,
+  74873,
+  13719,
+  24498,
+  30316,
+  8395,
+  126227,
+  20501,
+  16433,
+  6048,
+  3084,
+  20851,
+  11098,
+  4351,
+  3022,
+  65015,
+  9387,
+  10667,
+  3174,
+  11364,
+  9918,
+  9474,
+  6673,
+  4778,
+  124666,
+  6217,
+  10445,
+  15152,
+  71794,
+  124356,
+  92274,
+  128992,
+  72267,
+  69496,
+  32452,
+  39711,
+  60305,
+  120387,
+  12623,
+  99414,
+  128745,
+  49744,
+  44338,
+  128762,
+  110718,
+  81092,
+  10265,
+  72458,
+  13515,
+  20008,
+  3561,
+  55938,
+  106747,
+  34732,
+  23947,
+  45623,
+  7618,
+  28547,
+  23356,
+  18369,
+  71905,
+  73275,
+  51489,
+  38180,
+  8900,
+  21291,
+  16126,
+  14534,
+  5180,
+  96790,
+  64937,
+  91805
+ ]
+}

server/tests/test_labels.py

@@ -0,0 +1,406 @@
+"""Answer-label schemes: exact lists, the <=26 guarantee, and end-to-end mapping."""
+
+import hashlib
+import json
+import re
+import string
+from pathlib import Path
+
+import httpx
+import pytest
+
+from jev_adapter.labels import (
+    DEFAULT_LABEL_SCHEME,
+    MAX_LABELS,
+    follows_scheme_order,
+    label_candidates,
+    resolve_label_scheme,
+    select_labels,
+)
+from jev_adapter.server import create_app
+from jev_adapter.sglang import SGLangBackend
+
+GOLDEN_PATH = Path(__file__).parent / "data" / "upper-labels-ministral3.json"
+GOLDEN = json.loads(GOLDEN_PATH.read_text())
+UPPER = GOLDEN["labels"]
+COUNTS = (2, 26, 27, 77, 151, 255)
+
+
+class VocabularyTokenizer:
+    """Every character is one token; listed multi-letter strings are one token.
+
+    With the golden vocabulary this has exactly the pinned Ministral-3
+    single-token pattern for the upper labels (e.g. AJ and AQ are split).
+    """
+
+    all_special_ids = (0,)
+
+    def __init__(self, words):
+        self.word_ids = {word: 100_000 + index for index, word in enumerate(words)}
+        self.words = {token: word for word, token in self.word_ids.items()}
+
+    def encode(self, text, add_special_tokens=False):
+        ids, position = [], 0
+        while position < len(text):
+            for length in (3, 2):
+                piece = text[position : position + length]
+                if len(piece) == length and piece in self.word_ids:
+                    ids.append(self.word_ids[piece])
+                    position += length
+                    break
+            else:
+                ids.append(ord(text[position]) + 1000)
+                position += 1
+        return ids
+
+    def decode(self, ids, skip_special_tokens=True):
+        return "".join(
+            self.words[token] if token in self.words else chr(token - 1000)
+            for token in ids
+        )
+
+
+def ministral_like():
+    return VocabularyTokenizer([label for label in UPPER if len(label) > 1])
+
+
+def test_default_and_resolution():
+    assert DEFAULT_LABEL_SCHEME == "upper"
+    assert resolve_label_scheme(environ={}) == "upper"
+    assert resolve_label_scheme(environ={"JEV_LABEL_SCHEME": "served"}) == "served"
+    assert resolve_label_scheme("upper", {"JEV_LABEL_SCHEME": "served"}) == "upper"
+    assert resolve_label_scheme("", {"JEV_LABEL_SCHEME": ""}) == "upper"
+    for bad in ("lower", "UPPER", 3):
+        with pytest.raises(ValueError, match="label scheme"):
+            resolve_label_scheme(bad, {})
+    with pytest.raises(ValueError, match="label scheme"):
+        resolve_label_scheme(None, {"JEV_LABEL_SCHEME": "lower"})
+
+
+def test_candidate_orders():
+    upper = label_candidates("upper")
+    assert upper[:28] == [*string.ascii_uppercase, "AA", "AB"]
+    assert upper[26 + 675] == "ZZ" and upper[26 + 676] == "AAA"
+    assert upper[-1] == "ZZZ" and len(upper) == 26 + 26**2 + 26**3
+    assert all(re.fullmatch(r"[A-Z]{1,3}", label) for label in upper)
+    served = label_candidates("served")
+    # The served order is unchanged from before the scheme option existed.
+    assert served[:62] == list(
+        string.ascii_uppercase + string.ascii_lowercase + string.digits
+    )
+    assert served[62:64] == ["000", "001"] and served[1062:1064] == ["AA", "AB"]
+    assert served[-1] == "zz" and len(served) == 62 + 1000 + 2 * 26**2
+
+
+@pytest.mark.parametrize("count", COUNTS)
+def test_upper_lists_for_each_option_count(count):
+    labels, token_ids = select_labels(ministral_like(), "upper", limit=count)
+    assert labels == UPPER[:count]
+    assert len(set(labels)) == len(set(token_ids)) == count
+    assert all(re.fullmatch(r"[A-Z]{1,2}", label) for label in labels)
+    assert labels[: min(count, 26)] == list(string.ascii_uppercase[:count])
+    if count > 26:
+        assert labels[26:29] == ["AA", "AB", "AC"][: count - 26]
+        # AJ, AQ and AW are not single Ministral-3 tokens, so they are skipped.
+        assert not {"AJ", "AQ", "AW"} & set(labels)
+
+
+def test_exact_boundary_labels():
+    labels, _ = select_labels(ministral_like(), "upper")
+    assert len(labels) == MAX_LABELS
+    assert labels[26] == "AA"
+    assert labels[76] == "CG"  # the 77th label: the last of BANKING77's options
+    assert labels[150] == "FT"  # the 151st: the last of CLINC150 with oos
+    assert labels[254] == "MH"
+
+
+@pytest.mark.parametrize("count", range(2, 27))
+def test_at_most_26_options_keep_a_to_z_in_both_schemes(count):
+    tokenizer = ministral_like()
+    upper = select_labels(tokenizer, "upper", limit=count)
+    served = select_labels(tokenizer, "served", limit=count)
+    assert upper == served
+    assert upper[0] == list(string.ascii_uppercase[:count])
+
+
+def test_served_scheme_still_uses_lowercase_after_z():
+    labels, _ = select_labels(ministral_like(), "served")
+    assert labels[26:30] == ["a", "b", "c", "d"]
+    assert labels[52:62] == list(string.digits)
+    assert labels[62] == "AA"
+
+
+@pytest.mark.parametrize("count", COUNTS)
+def test_label_index_round_trip(count):
+    labels, token_ids = select_labels(ministral_like(), "upper", limit=count)
+    index = {label: position for position, label in enumerate(labels)}
+    token_index = {token: position for position, token in enumerate(token_ids)}
+    assert len(index) == len(token_index) == count
+    for position, (label, token) in enumerate(zip(labels, token_ids)):
+        assert index[label] == token_index[token] == position
+        assert labels[index[label]] == label
+    # Every label is also a prefix-free answer at the list level: a longer label
+    # is one token, never the token of a shorter label followed by another.
+    tokenizer = ministral_like()
+    assert all(
+        tokenizer.encode(label) == [token] for label, token in zip(labels, token_ids)
+    )
+
+
+def test_three_letter_continuation_when_two_letters_run_out():
+    # Only AA..AJ are two-letter tokens; the list continues with AAA, AAB, ...
+    two = [f"A{letter}" for letter in "ABCDEFGHIJ"]
+    three = ["AAA", "AAB", "ABA", "ZZZ"]
+    tokenizer = VocabularyTokenizer(two + three)
+    labels, _ = select_labels(tokenizer, "upper")
+    assert labels == list(string.ascii_uppercase) + two + three
+
+
+def test_special_duplicate_and_lossy_tokens_are_skipped():
+    class Tricky(VocabularyTokenizer):
+        all_special_ids = (ord("B") + 1000,)
+
+        def decode(self, ids, skip_special_tokens=True):
+            text = super().decode(ids, skip_special_tokens)
+            return "ab" if text == "AB" else text
+
+        def encode(self, text, add_special_tokens=False):
+            return [ord("C") + 1000] if text == "AC" else super().encode(text)
+
+    labels, _ = select_labels(Tricky(["AA", "AB", "AC", "AD"]), "upper")
+    assert labels[:3] == ["A", "C", "D"] and "B" not in labels
+    assert labels[25:] == ["AA", "AD"]
+
+
+def test_scheme_order_check():
+    assert follows_scheme_order("upper", ["A", "B", "AA", "AB", "MH", "AAA"])
+    assert not follows_scheme_order("upper", ["A", "a"])
+    assert not follows_scheme_order("upper", ["B", "A"])
+    assert not follows_scheme_order("upper", ["AA", "Z"])
+    assert follows_scheme_order("served", ["A", "Z", "a", "0", "AA", "aa"])
+    assert not follows_scheme_order("served", ["a", "A"])
+    assert not follows_scheme_order("served", ["A", "AAA"])
+
+
+def test_pinned_ministral3_tokenizer_matches_the_golden_list():
+    transformers = pytest.importorskip("transformers")
+    tokenizer_info = GOLDEN["tokenizer"]
+    try:
+        tokenizer = transformers.AutoTokenizer.from_pretrained(
+            tokenizer_info["id"],
+            revision=tokenizer_info["revision"],
+            local_files_only=True,
+        )
+    except Exception:  # noqa: BLE001 - absent from this machine's HF cache
+        pytest.skip("pinned Ministral-3 tokenizer is not cached locally")
+    labels, token_ids = select_labels(tokenizer, "upper")
+    assert labels == GOLDEN["labels"]
+    assert token_ids == GOLDEN["token_ids"]
+    # The recorded probe below is what this tokenizer really does.
+    for candidate, ids in PROBE["encode"].items():
+        assert tokenizer.encode(candidate, add_special_tokens=False) == ids
+    for token, text in PROBE["decode"].items():
+        assert tokenizer.decode([int(token)], skip_special_tokens=True) == text
+    assert set(tokenizer.all_special_ids) <= ProbeTokenizer().all_special_ids
+    from jev_adapter.native_tokenizer import NativeTokenizer
+
+    # Every label continues the native chat prompt by exactly its token.
+    NativeTokenizer(tokenizer).prepare("Choose.", tuple(labels), tuple(token_ids), None)
+
+
+# Raw encode/decode results of the pinned Ministral-3 tokenizer for every one-
+# and two-letter uppercase candidate, recorded on the GPU host with
+# AutoTokenizer and cross-checked against tekken.json (mistral_common) and the
+# release tokenizer.json. Unlike ministral_like(), which is built from the
+# golden list, this table is tokenizer data only, so the tests below check the
+# selection rule against the real tokenizer on every CI run.
+PROBE_PATH = Path(__file__).parent / "data" / "ministral3-label-probe.json"
+PROBE = json.loads(PROBE_PATH.read_text())
+
+
+class ProbeTokenizer:
+    """Replays the recorded tokenizer; a string outside the table is an error."""
+
+    def __init__(self):
+        self.all_special_ids = {
+            token
+            for first, last in PROBE["special_id_ranges"]
+            for token in range(first, last + 1)
+        }
+
+    def encode(self, text, add_special_tokens=False):
+        assert add_special_tokens is False
+        return list(PROBE["encode"][text])
+
+    def decode(self, ids, skip_special_tokens=True):
+        assert skip_special_tokens is True
+        return "".join(PROBE["decode"][str(token)] for token in ids)
+
+
+def test_probe_records_the_golden_lists_tokenizer():
+    assert PROBE["schema"] == "jev-tokenizer-probe-v1"
+    assert PROBE["tokenizer"] == GOLDEN["tokenizer"]
+    expected = PROBE["expected_upper"]
+    assert expected["labels"] == GOLDEN["labels"]
+    assert expected["token_ids"] == GOLDEN["token_ids"]
+    assert expected["source_sha256"] == hashlib.sha256(
+        GOLDEN_PATH.read_bytes()
+    ).hexdigest()
+    candidates = [*string.ascii_uppercase] + [
+        first + second
+        for first in string.ascii_uppercase
+        for second in string.ascii_uppercase
+    ]
+    assert list(PROBE["encode"]) == candidates
+    singles = [label for label, ids in PROBE["encode"].items() if len(ids) == 1]
+    counts = GOLDEN["single_token_counts"]
+    assert sum(len(label) == 1 for label in singles) == counts["one_letter"] == 26
+    assert sum(len(label) == 2 for label in singles) == counts["two_letter"] == 439
+
+
+def test_rule_on_the_recorded_ministral3_tokenizer_gives_the_golden_list():
+    # Three-letter candidates are absent from the table, so consulting one
+    # would raise: 255 labels must come from one and two letters.
+    labels, token_ids = select_labels(ProbeTokenizer(), "upper")
+    assert labels == GOLDEN["labels"]
+    assert token_ids == GOLDEN["token_ids"]
+    for count in COUNTS:
+        assert select_labels(ProbeTokenizer(), "upper", limit=count) == (
+            GOLDEN["labels"][:count],
+            GOLDEN["token_ids"][:count],
+        )
+
+
+@pytest.mark.asyncio
+async def test_http_backend_picks_the_golden_list_from_the_recorded_tokenizer():
+    engine = LabelEngine(ProbeTokenizer(), "A")
+    async with httpx.AsyncClient(transport=httpx.MockTransport(engine)) as upstream:
+        backend = SGLangBackend(
+            "http://engine", "standard-one", client=upstream, label_scheme="upper"
+        )
+        await backend.start()
+        try:
+            for count in COUNTS:
+                assert backend.labels(count) == (
+                    tuple(GOLDEN["labels"][:count]),
+                    tuple(GOLDEN["token_ids"][:count]),
+                )
+        finally:
+            await backend.close()
+
+
+class LabelEngine:
+    """A remote engine whose tokenizer has two-letter tokens and prefers one label."""
+
+    def __init__(self, tokenizer, preferred):
+        self.tokenizer = tokenizer
+        self.preferred = preferred
+        self.prompts = []
+
+    def __call__(self, request):
+        body = json.loads(request.content) if request.content else None
+        path = request.url.path
+        if path == "/model_info":
+            return httpx.Response(
+                200,
+                json={
+                    "served_model_name": "standard-one",
+                    "model_path": "org/standard-one",
+                    "is_generation": True,
+                },
+            )
+        if path == "/server_info":
+            return httpx.Response(200, json={"speculative_algorithm": None})
+        encode = self.tokenizer.encode
+        if path == "/v1/tokenize":
+            if "messages" in body:
+                content = body["messages"][-1]["content"]
+                self.prompts.append(content)
+                return httpx.Response(
+                    200, json={"tokens": encode(f"<u>{content}</u><a>")}
+                )
+            return httpx.Response(
+                200, json={"tokens": [encode(text) for text in body["prompt"]]}
+            )
+        if path == "/v1/detokenize":
+            tokens = body["tokens"]
+            decode = self.tokenizer.decode
+            text = (
+                [decode(ids) for ids in tokens]
+                if isinstance(tokens[0], list)
+                else decode(tokens)
+            )
+            return httpx.Response(200, json={"text": text})
+        if path == "/generate":
+            preferred = encode(self.preferred)[0]
+            entries = [
+                [-0.1 if token == preferred else -9.0, token, None]
+                for token in body["token_ids_logprob"]
+            ]
+            return httpx.Response(
+                200,
+                json={
+                    "meta_info": {
+                        "completion_tokens": 0,
+                        "prompt_tokens": len(body["input_ids"]),
+                        "cached_tokens": 0,
+                        "output_token_ids_logprobs": [entries],
+                    }
+                },
+            )
+        raise AssertionError(path)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "scheme,count,preferred,expected_option",
+    [
+        ("upper", 77, "CG", 76),
+        ("upper", 77, "AA", 26),
+        ("upper", 151, "FT", 150),
+        ("upper", 26, "Z", 25),
+        ("served", 77, "a", 26),
+        ("served", 26, "Z", 25),
+    ],
+)
+async def test_label_maps_to_its_option_through_the_http_stack(
+    scheme, count, preferred, expected_option
+):
+    engine = LabelEngine(ministral_like(), preferred)
+    async with httpx.AsyncClient(transport=httpx.MockTransport(engine)) as upstream:
+        backend = SGLangBackend(
+            "http://engine", "standard-one", client=upstream, label_scheme=scheme
+        )
+        app = create_app(backend)
+        async with (
+            app.router.lifespan_context(app),
+            httpx.AsyncClient(
+                transport=httpx.ASGITransport(app), base_url="http://adapter"
+            ) as client,
+        ):
+            models = (await client.get("/v1/models")).json()
+            assert models["data"][0]["label_scheme"] == scheme
+            options = {f"intent-{index}": None for index in range(count)}
+            response = await client.post(
+                "/v1/systemone",
+                json={
+                    "model": "standard-one",
+                    "state": "I lost my card.",
+                    "questions": {
+                        "intent": {
+                            "type": "choice",
+                            "instructions": "Which intent?",
+                            "criteria": options,
+                        }
+                    },
+                },
+            )
+    assert response.status_code == 200, response.text
+    result = response.json()
+    assert result["metadata"]["label_scheme"] == scheme
+    assert result["answers"]["intent"]["choice"] == f"intent-{expected_option}"
+    lines = engine.prompts[-1].split("Options:\n")[1].splitlines()
+    labels = [line.split(":", 1)[0] for line in lines]
+    expected, _ = select_labels(ministral_like(), scheme, limit=count)
+    assert labels == expected
+    assert lines[expected_option] == f"{preferred}: intent-{expected_option}"

server/tests/test_main.py

@@ -44,6 +44,7 @@ def run_main(monkeypatch, argv, env=None):
         "JEV_PROMPT_WORDING",
         "JEV_DEFAULT_TEMPERATURE",
         "JEV_NATIVE_SYSTEM_PROMPT",
+        "JEV_LABEL_SCHEME",
     ):
         monkeypatch.delenv(key, raising=False)
     for key, value in (env or {}).items():
@@ -366,3 +367,34 @@ def test_native_system_prompt_startup_log_line(monkeypatch, capture, caplog):
     message = info_records[0].getMessage()
     assert "prompt_wording=native" in message
     assert "native_system_prompt=none" in message
+    assert "label_scheme=upper" in message
+
+
+def test_label_scheme_defaults_to_upper(monkeypatch, capture):
+    run_main(monkeypatch, ["--model", "decision-model"])
+    assert capture.backend_kwargs["label_scheme"] == "upper"
+
+
+def test_label_scheme_flag_and_env_var(monkeypatch, capture):
+    run_main(monkeypatch, ["--model", "m"], env={"JEV_LABEL_SCHEME": "served"})
+    assert capture.backend_kwargs["label_scheme"] == "served"
+    run_main(
+        monkeypatch,
+        ["--model", "m", "--label-scheme", "upper"],
+        env={"JEV_LABEL_SCHEME": "served"},
+    )
+    assert capture.backend_kwargs["label_scheme"] == "upper"
+
+
+@pytest.mark.parametrize(
+    "argv,env",
+    [
+        (["--label-scheme", "lower"], {}),
+        ([], {"JEV_LABEL_SCHEME": "lower"}),
+    ],
+)
+def test_invalid_label_scheme_rejected(monkeypatch, capture, argv, env):
+    with pytest.raises(SystemExit):
+        run_main(monkeypatch, ["--model", "m", *argv], env=env)
+    assert capture.backend_kwargs is None
+

server/tests/test_protocol.py

@@ -115,6 +115,22 @@ class TestSystemOneValidation(unittest.TestCase):
             with self.subTest(question=question), self.assertRaises(ValidationError):
                 request_for(question)
 
+    def test_empty_noul_criteria_mean_no_descriptions(self):
+        # {} is the same as omitting criteria (the released server's fix).
+        empty = request_for({"type": "noul", "instructions": "Urgent?", "criteria": {}})
+        omitted = request_for({"type": "noul", "instructions": "Urgent?"})
+        self.assertIsNone(empty.questions["routing"].criteria)
+        plan = plan_question(empty.questions["routing"])
+        self.assertEqual(plan, plan_question(omitted.questions["routing"]))
+        self.assertEqual(plan.descriptions, (None, None))
+        self.assertTrue(build_prompt("s", plan, ["A", "B"]).endswith("A: yes\nB: no"))
+        # Only an empty map is relaxed; a partial or foreign map still fails.
+        for criteria in ({"true": None}, {"yes": None, "no": None}):
+            with self.subTest(criteria=criteria), self.assertRaises(ValidationError):
+                request_for(
+                    {"type": "noul", "instructions": "Urgent?", "criteria": criteria}
+                )
+
     def test_required_fields_and_request_limits(self):
         for updates in (
             {"model": " "},