Add serving code

SHA256SUMS

@@ -34,7 +34,7 @@ f9913e0d49fc053df656058d13af2523b6263f9396efad7a6fa06e7a121e1acf  release-manife
 eef2a88a000d2ec294379755770c147327cb79d3d7278c711899bd36797d7a02  server/.gitignore
 1495e1e757ef4d0925a2350563cf5754bb23c51701a8ec4fb3c5cdcbedae6747  server/LICENSE
 0f1f023b916d38d7c12af3a71e09f5e82b819a7e156e4992118bb160ee63ede1  server/NOTICE
-56c89049984cec6fa66a5bea6b905c63aa46fbd627ba12bbfabac1a6b466d321  server/README.md
+8db88b70be27a581c975b872abc0ba7eaafa092cc38db4debd3970bc83fb013a  server/README.md
 88e4dea8cc92f467a03bdd45a5fb968e402517116b09e24edcea85bb15f121e5  server/benchmarks/DECISION_BENCHMARK_SELECTION.md
 7fea6b9dc44e34ce448f1d80a9f2d273b76ab9b0ac1859c032fa4faa4f458501  server/benchmarks/METRIC_VALIDATION.md
 bb88f12ef294680e389147d781bf1f8680ea0a5ca9ed554730d8ea29f1c25eb9  server/benchmarks/PUBLIC_DATASETS.md
@@ -56,7 +56,7 @@ fee797d1a2ff128a5d61dd436e8252d63bc726b8ce4ba72641a1ffd9196135a6  server/benchma
 2544280dd3e669985bf57dfc61c2212bcf16d27230a79cea76f9f4e822476429  server/examples/request.json
 7a14fe0f5bf73aca7a4930423c310c0a3b1f9b546d07abc8d3fd5d9f38c9a5d7  server/examples/smoke.py
 e589f268969c87f82ddd2c81c0432c6335c08a9f9f2537ce68ddd5708f1e6f9e  server/jev_adapter/__init__.py
-c79719983fcf12ad2baa020acb1be00e3b1e4d4b66e7dcaa0a8022f140975f6a  server/jev_adapter/__main__.py
+bf3d7a38ac294b23bf0d1a6b32a66fffb5054affc7d8958a821d9aea4f3ef807  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
@@ -67,9 +67,9 @@ a66e6ec289b4c32f79ac990261650870be6b923e47753b9c89ff9e58fe2f982f  server/jev_ada
 0fef99cd01164c5548de530c9ab93255e2a95d17757c12e8e3d23016afd1a03c  server/jev_adapter/benchmarks/run.py
 86e113a3ee9d15d9be93ba5e964d5f5d51171619e7856cc7dde812c6c90f4a37  server/jev_adapter/native_tokenizer.py
 ad7dee34b9c15e83ce66b3b8b07266e0b8ce81da7c8ba692a8293dbf078d0e44  server/jev_adapter/protocol.py
-3eb21e967cbc8dd7dec2481553fce6974be66276d196eb791f0292bc95c2c8f0  server/jev_adapter/server.py
-bd5e5a13fb264c1e528132c3d33bb2b85c31bc45bb0d025d8151ea47216dbff4  server/jev_adapter/service.py
-8b025570f9678aae6717c817a94e807c21a2c0fe1eb82708a611d3f67be8c3e9  server/jev_adapter/sglang.py
+bf9c1588e8069ef2c341151c24f08b29f41d9bc57cb16f1866467467b50d8edc  server/jev_adapter/server.py
+332068ebc21f19b6eee6c6d8fd24e6821a4fbd5def6251f5a94beae613419a0a  server/jev_adapter/service.py
+2e45894cfb8fa204c7278ade4a123cda356de894ddf6fbb60b66e93dfea576c6  server/jev_adapter/sglang.py
 159eb400efb830c762a36f81e51ba79888570284ffa70326301adfeee50b5bd3  server/pyproject.toml
 f5bf6e9b916ff0d24a2551b4f9f24ed353e7343f5be343b141d38c4c04bd1101  server/tests/test_benchmark_data.py
 c197a90d57c7516eb615f7f0626f4c3e95b2fd0773d74e8f32601251804fca66  server/tests/test_benchmark_matrix.py
@@ -80,8 +80,8 @@ c492b41c07050d9b76c6c9d7d21bbfcdac6ec137346cf995df3f624cb1e345c8  server/tests/t
 ade6b76bacf23ae244d9790312f297a36557d6cd8075b81ce36e928359b742da  server/tests/test_main.py
 83084f098020374a4abfa3d4402e74e357d45170ca840843e58dba13162e9986  server/tests/test_native_tokenizer.py
 0114da8966dafa951308ed58563053918b2b2f7b3393dd483c7183e3374b444d  server/tests/test_protocol.py
-200c35bf53fd869132a69cb8adfd32a1f8e7235d0a7194b19675e46ac39c936b  server/tests/test_service.py
-50af7340ac40f3179403b3c53779f673c4ff1be888a015c2f8852731b5f69f0b  server/tests/test_sglang.py
+617f08c82448932cf13320166c4df66a1a85b5056a354aa8e9f748ce9b6f57d3  server/tests/test_service.py
+340e91fb9a6c870990187386da8d165fafcbcb5f08559056fd9da4e4e78b681f  server/tests/test_sglang.py
 0a5c981e8c5c6f8886ee007a6d4543a0be6b221cb9ca32a8709384a4c6fc8cbb  special_tokens_map.json
 600bb27946565481ecf51ba8aee252e49b9a68507866080ac9c30185bb312843  tekken.json
 d5f6046775b112f0e2d456ee9dba450684ab964fe5c4e231599bdc6773028135  tokenizer.json

server/README.md

@@ -1,3 +1,33 @@
+## Serving Standard One 3B with this code
+
+This directory is `jev-adapter` (Apache-2.0, see `LICENSE` and `NOTICE`): a small HTTP server that turns the SGLang engine into a
+`POST /v1/systemone` decision endpoint. Install it into its own virtual environment and start it in front of a stock SGLang 0.5.20
+engine that serves this repository:
+
+```bash
+pip install -e './server[native-tokenizer]'
+
+# terminal 1: engine
+CUDA_VISIBLE_DEVICES=0 SGLANG_VLM_CACHE_SIZE_MB=0 python -m sglang.launch_server \
+  --model-path . --served-model-name standard-one-3b \
+  --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 \
+  --chunked-prefill-size -1 --disable-radix-cache --mm-preprocess-cache-size-mb 0 \
+  --model-config-parser hf --load-format safetensors
+
+# terminal 2: adapter (no system prompt; temperatures: see the model card)
+jev-adapter --engine-url http://127.0.0.1:30000 --model standard-one-3b --alias jev-latest \
+  --host 0.0.0.0 --port 30120 --max-concurrency 1 \
+  --tokenizer-model mistralai/Ministral-3-3B-Instruct-2512-BF16 \
+  --tokenizer-revision b6d637bef2393152b3da2b2fde72eecdee30557e \
+  --prompt-wording native --native-system-prompt none \
+  --default-temperature <T> --temperature-by-type choice=<T>,noul=<T>,score=<T>
+```
+
+`--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
+request format are in the model card (`../README.md`).
+
 # Jev adapter
 
 기본 추론 엔진을 별도 프로세스로 실행하고, 그 앞에서 `POST /v1/systemone` 응답을 만드는 독립 Python 서비스입니다. 모델 학습, 엔진 fork, SGLang Python 패키지, CUDA, 모델 가중치가 어댑터에 필요하지 않습니다. 현재 구현한 백엔드는 **SGLang HTTP API**입니다.
@@ -76,7 +106,7 @@ ablation에서 이 문구 차이만으로 jevbench-hard 정확도가 약 +6점
 Ministral처럼 서빙 토크나이저가 `mistral-common` 백엔드로 해석되는 경우
 (`native_tokenizer.py` 문서 참고) 이 백엔드는 기본 시스템 프롬프트를 자동으로
 주입하지 않기 때문입니다 — 직접 추출한 텍스트가 없으면 시스템 메시지 없이 문구만
-`native`로 서빙합니다(시작 시 경고 로그). `/opt/.../SYSTEM_PROMPT.txt` 같은 정적
+`native`로 서빙합니다(시작 시 경고 로그). `SYSTEM_PROMPT.txt` 같은 정적
 문서 파일은 실제 chat template이 렌더링하는 기본 텍스트와 다를 수 있어(확인된 사례:
 문장 하나가 중복/누락) 신뢰하지 않고, 항상 `apply_chat_template`을 직접 렌더링해서
 추출합니다.

server/jev_adapter/__main__.py

@@ -19,6 +19,20 @@ def positive_temperature(text: str) -> float:
     return value
 
 
+def temperature_map(text: str) -> dict[str, float]:
+    """argparse type for --temperature-by-type: 'choice=1.6,noul=1.2,score=1.8'."""
+    result = {}
+    for part in filter(None, (item.strip() for item in text.split(","))):
+        key, sep, value = part.partition("=")
+        key = key.strip()
+        if not sep or key not in ("choice", "noul", "score") or key in result:
+            raise argparse.ArgumentTypeError(
+                f"expected type=T pairs for choice, noul, score; got {part!r}"
+            )
+        result[key] = positive_temperature(value.strip())
+    return result
+
+
 def main():
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--engine-url", default="http://127.0.0.1:30000")
@@ -40,6 +54,14 @@ def main():
         "(label logits are divided by T before softmax; an explicit request "
         "value wins). Env: JEV_DEFAULT_TEMPERATURE. Default 1.0.",
     )
+    parser.add_argument(
+        "--temperature-by-type",
+        type=temperature_map,
+        default=os.environ.get("JEV_TEMPERATURE_BY_TYPE", ""),
+        help="Per-answer-type defaults used instead of --default-temperature when "
+        "a request omits options.temperature, e.g. 'choice=1.6,noul=1.2,score=1.8'. "
+        "Types not listed use --default-temperature. Env: JEV_TEMPERATURE_BY_TYPE.",
+    )
     parser.add_argument(
         "--prompt-wording",
         choices=("served", "native"),
@@ -136,6 +158,7 @@ def main():
         max_concurrency=args.max_concurrency,
         alias=args.alias,
         default_temperature=args.default_temperature,
+        temperature_by_type=args.temperature_by_type,
         prompt_wording=args.prompt_wording,
     )
     uvicorn.run(app, host=args.host, port=args.port)

server/jev_adapter/server.py

@@ -23,6 +23,7 @@ def create_app(
     max_concurrency: int = 32,
     alias: str = "jev-latest",
     default_temperature: float = 1.0,
+    temperature_by_type: dict[str, float] | None = None,
     prompt_wording: str = "served",
 ) -> FastAPI:
     service = SystemOneService(
@@ -30,6 +31,7 @@ def create_app(
         max_concurrency=max_concurrency,
         alias=alias,
         default_temperature=default_temperature,
+        temperature_by_type=temperature_by_type,
         prompt_wording=prompt_wording,
     )
 

server/jev_adapter/service.py

@@ -3,6 +3,7 @@
 import asyncio
 import math
 import time
+from collections.abc import Mapping
 from numbers import Real
 
 from .backend import AdapterError, ScoringBackend
@@ -15,6 +16,28 @@ from .protocol import (
 )
 
 
+QUESTION_TYPES = ("choice", "noul", "score")
+
+
+def validate_temperature_by_type(values: Mapping[str, float] | None) -> dict[str, float]:
+    """Check a {answer type: temperature} map; returns a plain dict (empty if None)."""
+    if values is None:
+        return {}
+    result = {}
+    for key, value in values.items():
+        if key not in QUESTION_TYPES:
+            raise ValueError(f"unknown answer type for temperature_by_type: {key!r}")
+        if (
+            isinstance(value, bool)
+            or not isinstance(value, Real)
+            or not math.isfinite(value)
+            or value <= 0
+        ):
+            raise ValueError("temperature_by_type values must be finite and greater than zero")
+        result[key] = float(value)
+    return result
+
+
 class SystemOneService:
     def __init__(
         self,
@@ -23,6 +46,7 @@ class SystemOneService:
         max_concurrency: int = 32,
         alias: str = "jev-latest",
         default_temperature: float = 1.0,
+        temperature_by_type: Mapping[str, float] | None = None,
         prompt_wording: str = "served",
     ):
         if max_concurrency < 1:
@@ -41,6 +65,10 @@ class SystemOneService:
         # request value always wins, and temperature_scaling=false still
         # disables scaling. Without this setting the request default (1.0) holds.
         self.default_temperature = float(default_temperature)
+        # Optional per-answer-type defaults (choice / noul / score); a type not
+        # listed falls back to default_temperature. Also applied only when the
+        # request omits options.temperature.
+        self.temperature_by_type = validate_temperature_by_type(temperature_by_type)
         # Server-wide, not per-request: which text build_prompt() renders.
         # "native" additionally requires the backend's labels to be canonical
         # A-Z (build_prompt raises otherwise) and relies on the backend to
@@ -55,6 +83,18 @@ class SystemOneService:
             return options
         return options.model_copy(update={"temperature": self.default_temperature})
 
+    def question_options(self, request: SystemOneRequest, options, question_type: str):
+        """Options for one question: the per-type default when the request left
+        temperature unset and a default exists for this answer type."""
+        if (
+            "temperature" in request.options.model_fields_set
+            or question_type not in self.temperature_by_type
+        ):
+            return options
+        return options.model_copy(
+            update={"temperature": self.temperature_by_type[question_type]}
+        )
+
     async def score(self, request: SystemOneRequest) -> dict:
         if request.model not in {self.backend.model, self.alias}:
             raise AdapterError(
@@ -107,7 +147,9 @@ class SystemOneService:
         return {
             "model": self.backend.model,
             "answers": {
-                key: reduce_probabilities(plan, *grouped[key], options)
+                key: reduce_probabilities(
+                    plan, *grouped[key], self.question_options(request, options, plan.type)
+                )
                 for key, plan in plans.items()
             },
             "usage": {"input_tokens": input_tokens, "output_tokens": 0},
@@ -116,6 +158,13 @@ class SystemOneService:
                 "temperature": (
                     options.temperature if options.temperature_scaling else 1.0
                 ),
+                **(
+                    {"temperature_by_type": dict(self.temperature_by_type)}
+                    if self.temperature_by_type
+                    and "temperature" not in request.options.model_fields_set
+                    and options.temperature_scaling
+                    else {}
+                ),
                 "evaluations": len(jobs),
                 "adapter_elapsed_ms": (time.perf_counter() - started) * 1000,
             },

server/jev_adapter/sglang.py

@@ -31,6 +31,7 @@ def _label_candidates() -> list[str]:
 
 
 _IMAGE_MODEL_TYPES = {
+    "mage_vl",
     "qwen2_vl",
     "qwen2_5_vl",
     "qwen3_vl",
@@ -41,6 +42,7 @@ _IMAGE_MODEL_TYPES = {
     "pixtral",
 }
 _IMAGE_ARCHITECTURES = {
+    "MageVLForConditionalGeneration",
     "Qwen2VLForConditionalGeneration",
     "Qwen2_5_VLForConditionalGeneration",
     "Qwen3VLForConditionalGeneration",
@@ -335,7 +337,7 @@ class SGLangBackend:
         if images and not self._image_format_supported:
             raise AdapterError(
                 "image_model_not_supported",
-                "Image scoring currently supports Qwen VL/Qwen3.5 and Mistral3/Pixtral chat formats.",
+                "Image scoring currently supports Mage-VL, Qwen VL/Qwen3.5, and Mistral3/Pixtral chat formats.",
                 "images",
             )
         if self._native_tokenizer is not None:

server/tests/test_service.py

@@ -4,7 +4,7 @@ import unittest
 
 from fastapi.testclient import TestClient
 
-from jev_adapter.__main__ import positive_temperature
+from jev_adapter.__main__ import positive_temperature, temperature_map
 from jev_adapter.backend import AdapterError, ScoringResult
 from jev_adapter.protocol import SystemOneRequest, probabilities_from_logprobs
 from jev_adapter.server import create_app
@@ -203,6 +203,50 @@ class TestDefaultTemperature(unittest.IsolatedAsyncioTestCase):
             2.0,
         )
 
+    async def test_temperature_by_type_applies_per_answer_type(self):
+        result = await self.score(
+            payload(), default_temperature=2.4, temperature_by_type={"score": 3.0, "noul": 1.5}
+        )
+        urgency = list(result["answers"]["urgency"]["probabilities"].values())
+        for actual, wanted in zip(urgency, probabilities_from_logprobs(self.vector, 3.0)):
+            self.assertAlmostEqual(actual, wanted)
+        route = list(result["answers"]["route"]["probabilities"].values())
+        for actual, wanted in zip(route, probabilities_from_logprobs(self.vector[:2], 2.4)):
+            self.assertAlmostEqual(actual, wanted)
+        self.assertEqual(result["metadata"]["temperature"], 2.4)
+        self.assertEqual(result["metadata"]["temperature_by_type"], {"score": 3.0, "noul": 1.5})
+
+    async def test_explicit_request_temperature_wins_over_temperature_by_type(self):
+        body = {**payload(), "options": {"temperature": 1.0}}
+        result = await self.score(body, temperature_by_type={"score": 3.0})
+        urgency = list(result["answers"]["urgency"]["probabilities"].values())
+        for actual, wanted in zip(urgency, probabilities_from_logprobs(self.vector, 1.0)):
+            self.assertAlmostEqual(actual, wanted)
+        self.assertNotIn("temperature_by_type", result["metadata"])
+
+    async def test_disabled_scaling_ignores_temperature_by_type(self):
+        body = {**payload(), "options": {"temperature_scaling": False}}
+        result = await self.score(body, temperature_by_type={"score": 3.0})
+        urgency = list(result["answers"]["urgency"]["probabilities"].values())
+        for actual, wanted in zip(urgency, probabilities_from_logprobs(self.vector, 1.0)):
+            self.assertAlmostEqual(actual, wanted)
+        self.assertNotIn("temperature_by_type", result["metadata"])
+
+    def test_invalid_temperature_by_type_rejected_at_construction(self):
+        for value in ({"judge": 1.2}, {"score": 0}, {"score": float("nan")}, {"noul": True}):
+            with self.assertRaises(ValueError):
+                SystemOneService(FakeBackend(), temperature_by_type=value)
+        self.assertEqual(SystemOneService(FakeBackend()).temperature_by_type, {})
+
+    def test_cli_temperature_map_type(self):
+        self.assertEqual(temperature_map("choice=1.6, noul=1.2,score=1.8"), {"choice": 1.6, "noul": 1.2, "score": 1.8})
+        self.assertEqual(temperature_map(""), {})
+        import argparse
+
+        for text in ("choice", "judge=1.2", "choice=0", "choice=1.2,choice=1.3", "noul=abc"):
+            with self.assertRaises(argparse.ArgumentTypeError):
+                temperature_map(text)
+
     def test_cli_default_temperature_type(self):
         self.assertEqual(positive_temperature("2.4"), 2.4)
         self.assertEqual(positive_temperature("1"), 1.0)

server/tests/test_sglang.py

@@ -232,6 +232,36 @@ async def test_images_remain_in_native_request_with_template_and_prefix():
         await client.aclose()
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "model_type,architectures",
+    [
+        ("mage_vl", []),
+        ("unknown", ["MageVLForConditionalGeneration"]),
+    ],
+)
+async def test_mage_vl_image_capability_and_message_format(model_type, architectures):
+    engine = Engine()
+    engine.info.update(model_type=model_type, architectures=architectures)
+    backend, engine, client = await make_backend(engine)
+    try:
+        image = "data:image/png;base64,YQ=="
+        labels, tokens = backend.labels(2)
+        await backend.evaluate("describe", [image], labels, tokens, None)
+        assert engine.calls[-4][1]["messages"] == [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image_url", "image_url": {"url": image}},
+                    {"type": "text", "text": "describe"},
+                ],
+            }
+        ]
+        assert engine.calls[-1][1]["image_data"] == [image]
+    finally:
+        await client.aclose()
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     "field,value,code",