Upload folder using huggingface_hub

oev/__init__.py

@@ -4,4 +4,4 @@ State + typed questions in, calibrated probability distributions out,
 one forward pass.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"

oev/infer.py

@@ -8,6 +8,36 @@ from oev.evaluate import load_model
 from oev.tokenizer_hf import HFTokenPacker
 
 
+def normalize_question(name, q):
+    """Accept either question schema and return an OEV-schema copy.
+
+    Native schema: choice uses a bare "options" list, score uses "levels".
+    Jev / TypeSafe schema: choice and noul carry "criteria" as a map of
+    option name -> description, score carries "criteria" as a list of level
+    labels. Descriptions are ignored (OEV was trained on bare options); the
+    option names become the options. Native keys win when both are present.
+    """
+    q = dict(q)
+    criteria = q.get("criteria")
+    if q.get("type") == "choice" and "options" not in q:
+        if isinstance(criteria, dict) and criteria:
+            q["options"] = [str(option) for option in criteria]
+        else:
+            raise ValueError(
+                f"question {name!r} (choice) needs an 'options' list "
+                "or a 'criteria' map of option name -> description"
+            )
+    elif q.get("type") == "score" and "levels" not in q:
+        if isinstance(criteria, list) and criteria:
+            q["levels"] = list(criteria)
+        else:
+            raise ValueError(
+                f"question {name!r} (score) needs a 'levels' list "
+                "or a 'criteria' list of level labels"
+            )
+    return q
+
+
 class OEV:
     def __init__(self, checkpoint="checkpoints/oev-tiny.pt", device="cpu", temperature=1.0):
         self.model = load_model(checkpoint, device)
@@ -21,6 +51,7 @@ class OEV:
             self.packer = HFTokenPacker(self.model.cfg["backbone"])
 
     def _question(self, name, q):
+        q = normalize_question(name, q)
         pq = {"name": name, "type": q["type"], "instructions": q.get("instructions", q["type"])}
         if q["type"] == "choice":
             pq["options"] = list(q["options"])
@@ -48,7 +79,8 @@ class OEV:
 
     def decide(self, state, questions, temperature=None):
         out = {}
-        for name, q in questions.items():
+        for name, raw_question in questions.items():
+            q = normalize_question(name, raw_question)
             pq = self._question(name, q)
             probs = self._probs(state, pq, temperature=temperature)
             best = max(range(len(probs)), key=probs.__getitem__)

oev/serve.py

@@ -15,10 +15,13 @@ Usage:
     }'
 
     # Jev-compatible schema (drop-in for existing TypeSafe clients):
+    # questions accept the same "criteria" shape laya and Kev serve.
     curl -X POST localhost:8000/v1/systemone -H "Content-Type: application/json" -d '{
       "model": "oev",
       "state": "We were charged twice for the same order.",
       "questions": {
+        "department": {"type": "choice", "instructions": "Which department?",
+                       "criteria": {"billing": "payments and refunds", "technical": "bugs and outages"}},
         "refund_requested": {"type": "noul", "instructions": "Does the user request a refund?"}
       }
     }'
@@ -91,11 +94,33 @@ def _jevify(answers: dict) -> dict:
     return out
 
 
+def _validate_jev_questions(questions: dict) -> str | None:
+    """Return an error message for questions that do not match the Jev schema."""
+    for name, question in questions.items():
+        if not isinstance(question, dict):
+            return f"question {name} must be an object"
+        qtype = question.get("type")
+        if qtype not in {"choice", "noul", "score"}:
+            return f"question {name} has unsupported type"
+        if qtype in {"choice", "noul"}:
+            criteria = question.get("criteria")
+            if criteria is not None and (not isinstance(criteria, dict) or not criteria):
+                return f"question {name} ({qtype}) criteria must be a non-empty object"
+        else:
+            criteria = question.get("criteria")
+            if not isinstance(criteria, list) or not criteria:
+                return f"question {name} (score) needs a non-empty criteria list of level labels"
+    return None
+
+
 @app.post("/v1/systemone")
 def systemone(req: SystemOneRequest):
     """Jev-compatible endpoint: existing TypeSafe clients work by changing baseUrl."""
     if agent is None:
         raise HTTPException(status_code=503, detail="no checkpoint loaded - run oev-serve --checkpoint ...")
+    error = _validate_jev_questions(req.questions)
+    if error:
+        raise HTTPException(status_code=422, detail=error)
     answers = agent.decide(req.state, req.questions)
     return {
         "model": req.model,