| """Lightweight System One request compilation and typed response formatting.""" |
|
|
| import json |
| import math |
| from collections.abc import Mapping, Sequence |
|
|
| from .metrics import choice_confidence, score_confidence |
|
|
|
|
| def _render(value) -> str: |
| return value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, sort_keys=True, allow_nan=False) |
|
|
|
|
| def _description(value, *, optional=False): |
| if value is None and optional: |
| return None |
| if not isinstance(value, (str, dict, list)): |
| raise ValueError("instructions and descriptions must be text, an object, or an array") |
| |
| json.dumps(value, allow_nan=False) |
| return _render(value) |
|
|
|
|
| def compile_request(state, questions: Mapping) -> list[dict]: |
| """Compile a shared state and typed questions into isolated model records. |
| |
| Records contain no target. `answer_keys` and `legend` are software-only |
| metadata; `candidate_prompts` never passes them or question IDs to a model. |
| Choice candidate names and descriptions are both visible. Score candidate |
| positions are not visible; code maps positions back to numeric levels. |
| """ |
| if not isinstance(state, (str, dict, list)): |
| raise ValueError("state must be text, a JSON object, or an array") |
| state_copy = json.loads(json.dumps(state, ensure_ascii=False, allow_nan=False)) |
| if not isinstance(questions, Mapping) or not questions: |
| raise ValueError("questions must be a nonempty mapping") |
| records = [] |
| for question_id, definition in questions.items(): |
| if not isinstance(question_id, str) or not isinstance(definition, Mapping): |
| raise ValueError("question IDs must be strings and definitions must be mappings") |
| kind = definition.get("type") |
| if kind not in ("choice", "score", "noul"): |
| raise ValueError("question type must be choice, score, or noul") |
| question = _description(definition.get("instructions")) |
| criteria = definition.get("criteria") |
| record = {"id": question_id, "state": state_copy, "kind": kind, "question": question} |
| if kind == "choice": |
| if not isinstance(criteria, Mapping) or not 1 <= len(criteria) <= 255: |
| raise ValueError("Choice requires between 1 and 255 candidates") |
| if any(not isinstance(key, str) for key in criteria): |
| raise ValueError("Choice candidate names must be strings") |
| descriptions = [_description(value, optional=True) for value in criteria.values()] |
| record["answer_keys"] = list(criteria) |
| record["options"] = [ |
| name if description is None else f"{name}: {description}" |
| for name, description in zip(criteria, descriptions) |
| ] |
| elif kind == "score": |
| if not isinstance(criteria, list) or not 2 <= len(criteria) <= 10: |
| raise ValueError("Score requires an array of 2 to 10 descriptive levels") |
| record["options"] = [_description(level) for level in criteria] |
| record["answer_keys"] = [str(index) for index in range(len(criteria))] |
| record["legend"] = dict(zip(record["answer_keys"], json.loads(json.dumps(criteria)))) |
| else: |
| if criteria is not None: |
| if not isinstance(criteria, Mapping) or set(criteria) != {"true", "false"}: |
| raise ValueError("Noul criteria must contain true and false descriptions") |
| true = _description(criteria["true"]) |
| false = _description(criteria["false"]) |
| record["question"] += f"\nYes means: {true}\nNo means: {false}" |
| record["options"] = ["no", "yes"] |
| record["answer_keys"] = ["false", "true"] |
| records.append(record) |
| return records |
|
|
|
|
| def candidate_prompts(record: dict) -> list[str]: |
| """Render independent candidates using only declared model input fields.""" |
| prefix = f"Context:\n{_render(record['state'])}\n\nQuestion: {_render(record['question'])}\n" |
| if record["kind"] == "noul": |
| return [prefix + "Is the answer to this question yes? Answer Yes or No."] |
| |
| return [prefix + f"Proposed answer: {_render(option)}\nIs this proposed answer correct? Answer Yes or No." |
| for option in record["options"]] |
|
|
|
|
| def format_response(records: Sequence[dict], probabilities: Sequence[Sequence[float]]) -> dict: |
| """Return typed answers; invalid model probabilities fail validation. |
| |
| Callers apply any calibration temperature before this function. Probabilities |
| must already be normalized (within 1e-6 numerical tolerance). This function |
| never generates or parses model-produced text. |
| """ |
| if len(records) != len(probabilities) or not records: |
| raise ValueError("records and probability rows must have equal nonzero length") |
| answers = {} |
| for record, values in zip(records, probabilities): |
| question_id, kind = record["id"], record["kind"] |
| if question_id in answers: |
| raise ValueError("duplicate question ID in response records") |
| keys = record["answer_keys"] |
| if len(values) != len(keys): |
| raise ValueError("probability count must match the declared answer space") |
| probs = [float(value) for value in values] |
| if any(not math.isfinite(value) or not 0 <= value <= 1 for value in probs): |
| raise ValueError("probabilities must be finite and in [0, 1]") |
| total = sum(probs) |
| if not math.isclose(total, 1.0, rel_tol=1e-6, abs_tol=1e-6): |
| raise ValueError("probabilities must sum to one") |
| probs = [value / total for value in probs] |
| if kind == "noul": |
| if keys != ["false", "true"]: |
| raise ValueError("Noul probabilities must be ordered false, true") |
| answer = {"type": kind, "noul": probs[1]} |
| elif kind == "choice": |
| selected = max(range(len(probs)), key=probs.__getitem__) |
| answer = {"type": kind, "choice": keys[selected], "probabilities": dict(zip(keys, probs)), |
| "confidence": choice_confidence(probs)} |
| elif kind == "score": |
| answer = {"type": kind, "score": sum(index * value for index, value in enumerate(probs)), |
| "probabilities": dict(zip(keys, probs)), "confidence": score_confidence(probs), |
| "legend": record["legend"]} |
| else: |
| raise ValueError("unknown record kind") |
| answers[question_id] = answer |
| return {"answers": answers} |
|
|
