plm-core 0.1.0__py3-none-any.whl

plm/__main__.py

@@ -0,0 +1,148 @@
+"""Command line: paste a task, get an answer plus a report of what ran.
+
+    .venv/bin/python -m plm "A 9 V supply feeds a divider of 10 kilohm over 4.7 kilohm. Output voltage in volts?"
+    .venv/bin/python -m plm 'Write a function `is_leap(year: int) -> bool` ...'    # software pack
+    .venv/bin/python -m plm < task.txt      # multi-line tasks, e.g. with assert/>>> example lines
+    .venv/bin/python -m plm                 # interactive: one task per line
+    .venv/bin/python -m plm --pack software --level intensive --show-work "..."
+    .venv/bin/python -m plm --thorough "$(cat task.txt)"   # software: add model-written tests (~4x compute)
+    .venv/bin/python -m plm --sql-db shop.sqlite "Which customers ordered twice?"   # sql pack, checked on the data
+    .venv/bin/python -m plm serve           # OpenAI-compatible server, see plm/server.py
+    .venv/bin/python -m plm packs list      # installed packs; also install / remove / doctor, see plm/manage.py
+
+The pack is picked from the task text unless --pack is given. Every run is
+appended to runs.jsonl in plm.paths.log_dir() (./logs in a checkout; override with PLM_LOG).
+"""
+
+import argparse
+import json
+import os
+import sys
+import urllib.error
+from pathlib import Path
+
+from plm.paths import log_dir
+from plm.report import answer_text, final_step, short
+
+LOG = Path(os.environ.get("PLM_LOG") or log_dir() / "runs.jsonl")
+
+
+def how(step):
+    if step.get("strategy"):
+        return {"tool": "calculator", "units": "units calc", "bare": "direct"}[step["strategy"]]
+    return "code" if "code" in step else "chat"
+
+
+def report(result, show_work):
+    print("\n" + answer_text(result))
+    print(f"\npack    {result['pack']}")
+    print(f"level   {result['level']}  ({result['reason']})")
+    chosen = final_step(result)
+    for i, s in enumerate(result["steps"], 1):
+        status = "ok" if not s["issues"] else "flagged: " + "; ".join(s["issues"])
+        if s["issues"] and i < len(result["steps"]):
+            status += " -> escalated"
+        if s is chosen and i < len(result["steps"]):
+            status += f"  [answer used: {result.get('chosen_note') or 'passed the examples and the most generated tests'}]"
+        if not result["checked"] and not s["issues"]:
+            status = "unchecked"
+        print(f"step {i}  {short(s['model']):<22} {how(s):<10} {s['tokens']:>5} tok {s['seconds']:>6.1f} s   {status}")
+        if show_work:
+            work = s.get("program") or s.get("code") or s["model_text"]
+            print("        " + work.strip().replace("\n", "\n        "))
+    writer = result.get("test_writer")
+    if writer:
+        print(f"tests   {short(writer['model']):<22} {'test writer':<10} {writer['tokens']:>5} tok {writer['seconds']:>6.1f} s"
+              f"   {len(writer['tests'])} tests")
+        if show_work:
+            print("        " + "\n        ".join(writer["tests"]))
+    calls = len(result["steps"]) + bool(writer)
+    print(f"total   {result['tokens']} tokens, {result['seconds']:.1f} s, {calls} model call{'s' if calls > 1 else ''}")
+    if result["pack"] == "general":
+        print(f"note    {result['unchecked_reason']}")
+
+
+def run_one(task, args):
+    from plm.packs import PACKS, detect
+
+    if not task.strip():
+        # An empty prompt still gets a confident answer from the models, so never send one.
+        sys.exit("plm: empty task (if piping a file, check that stdin actually reaches plm)")
+    pack = args.pack if args.pack != "auto" else "sql" if args.sql_db else detect(task)
+    extra = {}
+    if args.sql_db:
+        if pack == "sql":
+            extra["db"] = args.sql_db
+        else:
+            print(f"plm: --sql-db only applies to the sql pack; ignoring it for {pack}", file=sys.stderr)
+    if args.thorough:
+        if pack == "software":
+            extra["thorough"] = True
+        else:
+            print("plm: --thorough only applies to the software pack; ignoring it", file=sys.stderr)
+    try:
+        result = PACKS[pack].solve(task, level=args.level, timeout=args.timeout, **extra)
+    except urllib.error.HTTPError as e:
+        detail = e.read().decode(errors="replace")[:200]
+        sys.exit(f"Ollama error {e.code}: {detail}\nModels in use: {PACKS[pack].models} "
+                 "(set PLM_SMALL_MODEL / PLM_LARGE_MODEL / PLM_CODER_MODEL)")
+    except urllib.error.URLError as e:
+        sys.exit(f"Can't reach Ollama ({e.reason}). Is it running? Address comes from OLLAMA_HOST.")
+    except ValueError as e:  # a --sql-db / PLM_SQL_DB file that can't be opened
+        sys.exit(f"plm: {e}")
+    LOG.parent.mkdir(parents=True, exist_ok=True)
+    with LOG.open("a") as f:
+        f.write(json.dumps(result) + "\n")
+    if args.json:
+        print(json.dumps(result, indent=2))
+    else:
+        report(result, args.show_work)
+
+
+def main():
+    if sys.argv[1:2] == ["packs"]:
+        # before importing plm.packs, which refuses to start with a broken pack installed
+        from plm.manage import main as packs
+        return packs(sys.argv[2:])
+    try:  # a broken pack is a one-line message (it names `plm packs remove`), not a traceback
+        if sys.argv[1:2] == ["serve"]:
+            from plm.server import main as serve
+        else:
+            from plm.packs import PACKS
+    except RuntimeError as e:
+        sys.exit(f"plm: {e}")
+    if sys.argv[1:2] == ["serve"]:
+        return serve(sys.argv[2:])
+
+    ap = argparse.ArgumentParser(prog="plm", description="Adaptive multi-model orchestrator "
+                                 "('plm serve' for the server, 'plm packs' to manage packs)")
+    ap.add_argument("task", nargs="*", help="the task; omit for interactive mode")
+    ap.add_argument("--pack", choices=["auto", *PACKS], default="auto", help="domain pack (default: detect from the task)")
+    ap.add_argument("--level", choices=["calm", "alert", "intensive"], help="force an adrenaline level instead of classifying")
+    ap.add_argument("--thorough", action="store_true",
+                    help="software: also check code against tests a second model writes (~4x compute)")
+    ap.add_argument("--sql-db", metavar="FILE", help="sql: a SQLite database to read the schema from and check the query "
+                    "on, read-only (implies --pack sql; the server reads PLM_SQL_DB)")
+    ap.add_argument("--show-work", action="store_true", help="print each model's program or reasoning")
+    ap.add_argument("--json", action="store_true", help="print the full result as JSON")
+    ap.add_argument("--timeout", type=int, default=600, help="seconds per model call")
+    args = ap.parse_args()
+
+    if args.task:
+        run_one(" ".join(args.task), args)
+    elif not sys.stdin.isatty():
+        run_one(sys.stdin.read().strip(), args)
+    else:
+        print("plm: one task per line, empty line to quit")
+        while True:
+            try:
+                task = input("\ntask> ").strip()
+            except EOFError:
+                break
+            if not task:
+                break
+            run_one(task, args)
+
+
+if __name__ == "__main__":
+    main()

plm/general/__init__.py

@@ -0,0 +1 @@
+"""General pack: anything no other pack claims, answered by the large model, unchecked."""

plm/general/controller.py

@@ -0,0 +1,64 @@
+"""General pack: anything no other pack claims goes to the large model, unchecked.
+
+There is no check for open-ended answers, so nothing is escalated and nothing is
+routed down to a smaller model: without a check, a cheaper model's mistakes
+would go unnoticed. The whole conversation is passed through (packs only see
+the last user message), with the caller's sampling options.
+
+Model name can be overridden with PLM_LARGE_MODEL.
+"""
+
+import os
+import time
+
+from plm.ollama import chat, chat_stream
+
+MODELS = {"large": os.environ.get("PLM_LARGE_MODEL", "qwen3:8b")}
+NUM_PREDICT = 2048  # default reply budget when the caller sets none
+LEVELS = {lvl: {"num_predict": NUM_PREDICT, "chain": ["large"]} for lvl in ("calm", "alert", "intensive")}
+UNCHECKED = "no pack covers this task, so the answer wasn't checked"
+
+
+def _messages(task, messages):
+    return messages or [{"role": "user", "content": task}]
+
+
+def _result(task, level, step, start):
+    return {
+        "pack": "general",
+        "task": task,
+        "level": level or "alert",
+        "reason": "no pack matched; sent to the large model",
+        "answer": {"text": step["model_text"]},
+        "checked": False,
+        "unchecked_reason": UNCHECKED,
+        "trusted": False,
+        "steps": [step],
+        "tokens": step["tokens"],
+        "seconds": time.time() - start,
+    }
+
+
+def _step(model, r):
+    return {"model": model, "tokens": r["eval_tokens"], "prompt_tokens": r["prompt_tokens"],
+            "model_text": r["response"], "capped": r["done_reason"] == "length", "issues": [],
+            "seconds": r["wall_s"]}
+
+
+def solve(task, level=None, timeout=600, messages=None, options=None, max_tokens=None):
+    """Answer with the large model. Returns the same result shape as every pack."""
+    start = time.time()
+    model = MODELS["large"]
+    r = chat(model, _messages(task, messages), max_tokens or NUM_PREDICT, timeout, options)
+    return _result(task, level, _step(model, r), start)
+
+
+def solve_stream(task, level=None, timeout=600, messages=None, options=None, max_tokens=None):
+    """Like solve(), but yields ("delta", text) as the reply streams, then ("result", result)."""
+    start = time.time()
+    model = MODELS["large"]
+    for kind, value in chat_stream(model, _messages(task, messages), max_tokens or NUM_PREDICT, timeout, options):
+        if kind == "delta":
+            yield "delta", value
+        else:
+            yield "result", _result(task, level, _step(model, value), start)

plm/general/manifest.py

@@ -0,0 +1,8 @@
+"""The general pack's manifest: what the router needs to know about it."""
+
+from plm.general import controller
+from plm.pack import Pack
+
+# Built into the core and always present: claims nothing, answers whatever no other pack claims.
+PACK = Pack(name="general", version="0.1.0", claims=lambda text: 0, priority=0, solve=controller.solve,
+            levels=controller.LEVELS, models=controller.MODELS, solve_stream=controller.solve_stream)

plm/latex.py

@@ -0,0 +1,50 @@
+"""LaTeX quantities to plain text, so routing, levels and unit checks read them as they read plain text.
+
+Textbooks and benchmarks (SciBench) write "$8.4 \\mathrm{~km}$" and "$\\mathrm{~m} / \\mathrm{s}^2$";
+the claim rules and unit words expect "8.4 km" and "m/s^2". Only what the router and checks read
+is converted: the model still gets the original text. Text with no "$" and no backslash is
+returned unchanged, so no decision on plain text can move (LATEX_RULE in evals/test_detect.py).
+"""
+
+import re
+
+SYMBOLS = {"\\mu": "µ", "\\Omega": "Ω", "\\omega": "omega", "\\theta": "theta", "\\rho": "rho", "\\times": "×",
+           "\\cdot": "*", "\\circ": "°", "\\%": "%", "\\Delta": "Delta", "\\pi": "pi", "\\lambda": "lambda"}
+WRAPPERS = re.compile(r"\\(?:mathrm|text|mathbf|textrm|operatorname|mbox)\s*\{([^{}]*)\}")
+
+
+def plain(text):
+    """The text with LaTeX markup turned into the plain spelling the router and checks read."""
+    if "$" not in text and "\\" not in text:
+        return text
+    t = text
+    for _ in range(3):  # nested wrappers: \mathrm{\mu C}
+        t = WRAPPERS.sub(r"\1", t)
+    t = re.sub(r"\^\s*\{?\s*\\circ\s*\}?", "°", t)       # 20^{\circ} -> 20°
+    for k, v in SYMBOLS.items():
+        t = t.replace(k, v)
+    t = re.sub(r"\^\{([^{}]*)\}", r"^\1", t)               # s^{-1} -> s^-1
+    t = re.sub(r"_\{([^{}]*)\}", r"_\1", t)
+    t = t.replace("$", " ").replace("~", " ").replace("{", "").replace("}", "")
+    t = re.sub(r"\\[,;:! ]", " ", t)                       # LaTeX spacing commands
+    t = re.sub(r"\\([A-Za-z]+)", r"\1", t)                  # any other command: its name
+    t = re.sub(r"\s*/\s*", "/", t)                         # m / s -> m/s
+    t = re.sub(r"(\d)\s+°", r"\1°", t)                     # 20 ° C -> 20°C
+    t = re.sub(r"°\s+([CFK])\b", r"°\1", t)
+    t = re.sub(r"(µ)\s+([A-Za-z])", r"\1\2", t)            # µ C -> µC
+    return re.sub(r"[ \t]+", " ", t).strip()
+
+
+if __name__ == "__main__":  # self-test
+    cases = {
+        "$8.4 \\mathrm{~km}$ at $70 \\mathrm{~km} / \\mathrm{h}$": "8.4 km at 70 km/h",
+        "$g=9.8 \\mathrm{~m} / \\mathrm{s}^2$": "g=9.8 m/s^2",
+        "$20^{\\circ} \\mathrm{C}$": "20°C",
+        "$q_1=3.0 \\mu \\mathrm{C}$": "q_1=3.0 µC",
+        "$R = 220 \\Omega$": "R = 220 Ω",
+        "plain 3 m/s text": "plain 3 m/s text",
+    }
+    bad = {k: (plain(k), v) for k, v in cases.items() if plain(k) != v}
+    for k, (got, want) in bad.items():
+        print(f"FAIL {k!r}: {got!r}, want {want!r}")
+    print(f"latex self-test: {len(cases) - len(bad)}/{len(cases)} passed")

plm/manage.py

@@ -0,0 +1,220 @@
+"""`plm packs`: list, install, remove and check domain packs.
+
+    plm packs list [--json]              installed packs, versions, and whether their models are pulled
+    plm packs install <name> [--source S]
+    plm packs remove <name>
+    plm packs doctor                     every pack loads, and every model it needs is pulled and loads
+
+Packs aren't on PyPI yet. `install` takes plm-<name> from --source (a directory
+holding plm-<name>/, the pack's own directory, or any pip requirement such as a
+git URL), else from PLM_PACKS_SOURCE, else from the packages/ directory of the
+checkout this core runs from. A directory is installed editable, so the code
+stays where it is. Installing uses uv when it's on PATH, else pip, always into
+the environment of the Python running plm. A pack is code that runs on this
+machine: install only packs you trust.
+
+These commands load packs one by one, so a pack that fails to load (which stops
+the router) can still be listed and removed.
+"""
+
+import argparse
+import json
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import urllib.error
+from pathlib import Path
+
+import plm
+from plm import ollama
+from plm.general.manifest import PACK as GENERAL
+from plm.pack import Pack, discover
+
+
+def installed():
+    """One row per pack: name, version, distribution, models, and the error if it failed to load."""
+    rows = [{"name": GENERAL.name, "version": GENERAL.version, "dist": "plm-core (built in)",
+             "models": dict(GENERAL.models), "error": None}]
+    for ep, pack in discover():
+        dist = ep.dist.name if ep.dist else "?"
+        if isinstance(pack, Pack):
+            rows.append({"name": pack.name, "version": pack.version, "dist": dist, "models": dict(pack.models),
+                         "error": None})
+        else:
+            rows.append({"name": ep.name, "version": "?", "dist": dist, "models": {}, "error": repr(pack)})
+    return rows
+
+
+def pulled_models():
+    """Full names of the models Ollama has, or None if Ollama can't be reached."""
+    try:
+        return ollama.pulled()
+    except (urllib.error.URLError, OSError):
+        return None
+
+
+def _is_pulled(model, pulled):
+    return None if pulled is None else ollama.full_name(model) in pulled
+
+
+def _installer(verb):
+    uv = shutil.which("uv")
+    if uv:
+        return [uv, "pip", verb, "--python", sys.executable]
+    if subprocess.run([sys.executable, "-m", "pip", "--version"], capture_output=True).returncode != 0:
+        sys.exit("plm packs: neither uv nor pip is available to install with")
+    return [sys.executable, "-m", "pip", verb] + (["-y"] if verb == "uninstall" else [])
+
+
+REPO = "https://github.com/ro-rbl/plm-orchestrator"
+
+
+def _run(cmd):
+    print("$", shlex.join(cmd), flush=True)
+    return subprocess.run(cmd).returncode
+
+
+def _source(name, source):
+    """pip arguments that install plm-<name> from --source, PLM_PACKS_SOURCE, this checkout, or the GitHub repo."""
+    dist = f"plm-{name}"
+    source = source or os.environ.get("PLM_PACKS_SOURCE")
+    if source is None:
+        checkout = Path(plm.__file__).resolve().parents[3]  # packages/plm-core/src/plm -> packages
+        if (checkout / dist / "pyproject.toml").exists():
+            return ["-e", str(checkout / dist)]
+        if not (checkout / "plm-core" / "pyproject.toml").exists():
+            # an installed plm (uv tool install, pip) has no checkout around it: the project's repo
+            return [f"{dist} @ git+{REPO}#subdirectory=packages/{dist}"]
+        sys.exit(f"plm packs: no source for {dist}, and packs aren't on PyPI yet. Pass --source: a directory "
+                 f"holding {dist}/, or a pip requirement such as "
+                 f"'{dist} @ git+https://<repo>#subdirectory=packages/{dist}'")
+    path = Path(source).expanduser()
+    if (path / dist / "pyproject.toml").exists():
+        return ["-e", str(path / dist)]
+    if (path / "pyproject.toml").exists():
+        return ["-e", str(path)]
+    if path.exists():
+        sys.exit(f"plm packs: {path} has neither {dist}/pyproject.toml nor pyproject.toml")
+    return [source]
+
+
+def _pull(model):
+    last = None
+    try:
+        for msg in ollama.pull(model):
+            if msg.get("status") != last:  # progress repeats a status with new byte counts
+                last = msg.get("status")
+                print(f"  {model}: {last}", flush=True)
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(json.loads(e.read() or b"{}").get("error", str(e))) from e
+
+
+def cmd_list(args):
+    rows, pulled = installed(), pulled_models()
+    if args.json:
+        for r in rows:
+            r["models"] = {tier: {"model": m, "pulled": _is_pulled(m, pulled)} for tier, m in r["models"].items()}
+        print(json.dumps(rows, indent=2))
+        return 0
+    for r in rows:
+        print(f"{r['name']:12} {r['version']:8} {r['dist']}")
+        if r["error"]:
+            print(f"  FAILED TO LOAD: {r['error']}")
+        for tier, m in r["models"].items():
+            state = {True: "pulled", False: "MISSING", None: "unknown (Ollama unreachable)"}[_is_pulled(m, pulled)]
+            print(f"  {tier:6} {m}  {state}")
+    return 0
+
+
+def cmd_install(args):
+    if args.name == GENERAL.name:
+        sys.exit("plm packs: the general pack is built into the core")
+    if _run(_installer("install") + _source(args.name, args.source)) != 0:
+        sys.exit("plm packs: install failed")
+    # A fresh process sees the newly installed pack (and its env-overridden models).
+    out = subprocess.run([sys.executable, "-m", "plm", "packs", "list", "--json"], capture_output=True, text=True)
+    if out.returncode != 0:
+        sys.exit(f"plm packs: installed, but listing packs failed:\n{out.stderr}")
+    row = next((r for r in json.loads(out.stdout) if r["name"] == args.name), None)
+    if row is None:
+        sys.exit(f"plm packs: installed plm-{args.name}, but it registers no pack named {args.name!r}")
+    if row["error"]:
+        sys.exit(f"plm packs: installed, but the pack fails to load: {row['error']}; "
+                 f"remove it with `plm packs remove {args.name}`")
+    missing = [v["model"] for v in row["models"].values() if v["pulled"] is not True]
+    if any(v["pulled"] is None for v in row["models"].values()):
+        sys.exit(f"plm packs: installed {args.name}, but Ollama can't be reached to check its models; "
+                 "start Ollama, then run `plm packs doctor`")
+    for model in dict.fromkeys(missing):
+        print(f"pulling {model}", flush=True)
+        try:
+            _pull(model)
+        except (RuntimeError, urllib.error.URLError, OSError) as e:
+            sys.exit(f"plm packs: installed {args.name}, but pulling {model} failed: {e}")
+    print(f"installed {args.name} {row['version']}; models: {', '.join(row['models'][t]['model'] for t in row['models'])}")
+    return 0
+
+
+def cmd_remove(args):
+    if args.name == GENERAL.name:
+        sys.exit("plm packs: the general pack is built into the core and can't be removed")
+    row = next((r for r in installed() if r["name"] == args.name), None)
+    if row is None:
+        sys.exit(f"plm packs: no pack named {args.name!r} is installed")
+    if _run(_installer("uninstall") + [row["dist"]]) != 0:
+        sys.exit("plm packs: uninstall failed")
+    if row["models"]:
+        print(f"removed {args.name}; its models stay in Ollama, other packs may use them: "
+              f"{', '.join(dict.fromkeys(row['models'].values()))}")
+    return 0
+
+
+def cmd_doctor(args):
+    rows, pulled = installed(), pulled_models()
+    problems = 0
+    names = [r["name"] for r in rows]
+    for name in {n for n in names if names.count(n) > 1}:
+        print(f"FAIL  two installed packs are named {name!r}")
+        problems += 1
+    for r in rows:
+        if r["error"]:
+            print(f"FAIL  {r['name']}: fails to load: {r['error']}")
+            problems += 1
+            continue
+        for model in dict.fromkeys(r["models"].values()):
+            state = _is_pulled(model, pulled)
+            if state is None:
+                print(f"FAIL  {r['name']}: {model}: Ollama can't be reached")
+            elif not state:
+                print(f"FAIL  {r['name']}: {model} is not pulled (`ollama pull {model}`)")
+            else:
+                try:
+                    ollama.load(model)
+                    print(f"ok    {r['name']}: {model} loads")
+                    continue
+                except (RuntimeError, urllib.error.URLError, OSError) as e:
+                    print(f"FAIL  {r['name']}: {model} doesn't load: {e}")
+            problems += 1
+    print("all packs healthy" if not problems else f"{problems} problem(s)")
+    return 1 if problems else 0
+
+
+def main(argv):
+    ap = argparse.ArgumentParser(prog="plm packs", description="List, install, remove and check domain packs")
+    sub = ap.add_subparsers(dest="command", required=True)
+    p = sub.add_parser("list", help="installed packs and whether their models are pulled")
+    p.add_argument("--json", action="store_true")
+    p.set_defaults(run=cmd_list)
+    p = sub.add_parser("install", help="install a pack, then pull the models it needs")
+    p.add_argument("name")
+    p.add_argument("--source", help="a directory holding plm-<name>/, the pack's directory, or a pip requirement")
+    p.set_defaults(run=cmd_install)
+    p = sub.add_parser("remove", help="uninstall a pack (its models stay in Ollama)")
+    p.add_argument("name")
+    p.set_defaults(run=cmd_remove)
+    p = sub.add_parser("doctor", help="check every pack loads and every model it needs loads")
+    p.set_defaults(run=cmd_doctor)
+    args = ap.parse_args(argv)
+    sys.exit(args.run(args))

plm/numeric/__init__.py

@@ -0,0 +1,2 @@
+"""Shared machinery for packs whose answers are a number with a unit: the answer
+format and parser, the calculator tool, the unit/sanity checks and the controller."""

plm/numeric/answers.py

@@ -0,0 +1,78 @@
+"""The "ANSWER: <number> <unit>" contract: the prompt that asks for it and the parser that reads it.
+
+Shared by the grader (evals/grade.py), the numeric controller (plm/numeric/controller.py) and
+its answer checks (plm/numeric/checks.py), so all of them read model output the same way.
+"""
+
+import re
+
+import pint
+
+# v1 showed "ANSWER: <number> <unit>" and small models copied "<unit>" literally.
+PROMPT_VERSION = 2
+ANSWER_FORMAT = (
+    "Solve the problem. Show brief working. Your last line must be the final answer "
+    "as a number followed by its unit, written like this example:\n"
+    "ANSWER: 3.3 kN\n"
+    "Use the unit the question asks for. For unitless answers, give only the number."
+)
+
+ureg = pint.UnitRegistry()
+
+# Units pint can't (or shouldn't) convert; matched by alias instead.
+LITERAL_UNITS = {
+    "": {"", "unitless", "dimensionless"},
+    "dB": {"db", "decibel", "decibels"},
+    "USD": {"usd", "$", "dollar", "dollars", "us dollars"},
+    "count": {"", "count", "cell", "cells"},
+}
+
+ANSWER_RE = re.compile(r"ANSWER\s*:\s*(.+)", re.IGNORECASE)
+SUPERSCRIPT_DIGITS = "⁰¹²³⁴⁵⁶⁷⁸⁹"
+SUPERSCRIPT_SIGNS = "⁻⁺"
+SUPERSCRIPTS = str.maketrans(SUPERSCRIPT_DIGITS + SUPERSCRIPT_SIGNS, "0123456789-+")
+NUMBER_RE = re.compile(r"[-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?", re.IGNORECASE)
+
+
+def normalize(text):
+    text = text.strip().replace("\u2212", "-").replace("\u2013", "-")
+    # LaTeX and Markdown from the models: \text{V}, \, , 10^{-19}, **3 A**
+    text = re.sub(r"\\(?:text|mathrm|mathit|rm)\s*\{([^}]*)\}", r"\1", text)
+    text = re.sub(r"\\[,;:! ]", " ", text)
+    text = text.replace("\\times", "×").replace("\\cdot", "*").replace("\\Omega", "ohm").replace("\\mu", "u")
+    text = re.sub(r"\^\{([^}]*)\}", r"^\1", text)
+    text = re.sub(f"10([{SUPERSCRIPT_SIGNS}]?[{SUPERSCRIPT_DIGITS}]+)",
+                  lambda m: "10^" + m.group(1).translate(SUPERSCRIPTS), text)  # 10⁻¹⁹
+    text = re.sub(r"\\[()\[\]]|[{}`]|\*\*", " ", text)
+    text = text.replace("$", " $ ")
+    # 1.6 × 10^-19  /  1.6x10^-19  /  1.6 * 10^-19  ->  1.6e-19
+    text = re.sub(r"\s*(?:×|x|\*)\s*10\s*\^\s*\(?\s*([-+]?\d+)\s*\)?", r"e\1", text)
+    text = re.sub(r"(?<=\d),(?=\d{3}\b)", "", text)  # 14,722 -> 14722
+    return text
+
+
+def normalize_unit(unit):
+    unit = unit.strip().rstrip(".;,").strip()
+    unit = unit.replace("Ω", "ohm").replace("Ω", "ohm")
+    unit = unit.replace("µ", "u").replace("μ", "u").replace("·", "*")
+    unit = re.sub(r"\bohms\b", "ohm", unit, flags=re.IGNORECASE)
+    unit = re.sub(r"\s*\(?\brms\b\)?", "", unit, flags=re.IGNORECASE).strip().strip("*").strip()
+    unit = re.sub(r"(?<=[A-Za-z])-(?=[A-Za-z])", "*", unit)  # ohm-meter, kilowatt-hours
+    if re.fullmatch(r"deg[CcFf]", unit):  # pint's Celsius and Fahrenheit, which the next rule would break
+        return "deg" + unit[3].upper()
+    if re.fullmatch(r"[A-Za-z]{4,}", unit):  # spelled-out words only; keep mS vs MS
+        unit = unit.lower()
+    return unit
+
+
+def parse_answer(response):
+    matches = ANSWER_RE.findall(response or "")
+    if not matches:
+        return None
+    # "**ANSWER:** ANSWER: 56.9 W" -> keep what follows the last label on the line
+    text = normalize(re.split(r"ANSWER\s*:", matches[-1], flags=re.IGNORECASE)[-1])
+    num = NUMBER_RE.search(text)
+    if not num:
+        return None
+    unit = text[: num.start()] + text[num.end():]  # "$152.53" puts the unit first
+    return float(num.group()), normalize_unit(unit)