Mirror laya-onnx source tree + model card

.gitignore

@@ -0,0 +1,16 @@
+.venv/
+.upstream/
+.cache/
+models/
+onnx/
+*.safetensors
+*.onnx
+*.onnx.data
+__pycache__/
+.pytest_cache/
+.ruff_cache/
+*.egg-info/
+build/
+dist/
+.DS_Store
+.env

AGENTS.md

@@ -0,0 +1,10 @@
+# laya-onnx — notes for coding agents
+
+Python ≥ 3.11. ONNX Runtime backend for Laya typed System-1 decisions.
+
+- Install: `pip install -e ".[demo]"` (`openvino`, `ultrafast`, `export`).
+- CLI: `laya-onnx predict|convert|optimize`, `laya-onnx-snake`, `laya-onnx-ultrafast`.
+- Deterministic: `load(..., deterministic=True)` or `--deterministic` (threads=1, pad off, `predict_argmax`, heuristic TYPE_TEXT).
+- Snake: https://raw.githack.com/Geoking2104/laya-onnx/main/examples/snake.html
+- Ultrafast: `docs/ULTRAFAST.md`, `--fixture examples/ultrafast_page.json`.
+- Do not commit `.venv` or `*.onnx`.

GROK.md

@@ -0,0 +1,10 @@
+# Grok snapshot
+
+This tree is the Grok-maintained ONNX Runtime port of Laya (KayrosLab / Geoking2104).
+
+- Runtime: `laya_onnx/agent.py` (`InferenceSession`, cpu / openvino / cuda)
+- Export: `laya_onnx/convert.py` (torch → ONNX opset 17)
+- Demo: https://raw.githack.com/Geoking2104/laya-onnx/main/examples/snake.html
+- Onboard: `ONBOARD.md`
+
+Do not commit `.venv` or Hub weights.

LICENSE

@@ -0,0 +1,15 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

NOTICE

@@ -0,0 +1,9 @@
+laya-onnx
+Copyright 2026 Geoffroy de La Tournelle / KayrosLab and contributors
+
+Derived from:
+- Laya (Apache-2.0) https://github.com/NandhaKishorM/laya
+- laya-mlx (Apache-2.0) https://github.com/mizorewww/laya-mlx
+
+Model weights: Convai Innovations, Apache-2.0, downloaded separately.
+Default ONNX bundle: https://huggingface.co/receptron/laya-onnx

ONBOARD.md

@@ -0,0 +1,35 @@
+# Onboard your AI agent to run laya-onnx
+
+Paste this file (or the one-liner in the README) into Claude Code, Codex, Cursor, Copilot, or any coding agent. The agent must follow every step. Safe to re-run.
+
+## Goal
+
+Install `laya-onnx` in the current workspace so the human can call `laya-onnx predict` and `laya-onnx-snake` on CPU (Intel i7 / 16 GB class). Do not download multi-GB weights unless the human asks.
+
+## Steps
+
+1. Confirm Python ≥ 3.11 (`python3 --version`). If missing, tell the human how to install it and stop.
+2. If this directory is not already the repo:
+   ```bash
+   git clone https://github.com/Geoking2104/laya-onnx.git
+   cd laya-onnx
+   ```
+3. Create a venv and install extras:
+   ```bash
+   python3 -m venv .venv
+   source .venv/bin/activate
+   pip install -U pip
+   pip install -e ".[demo,dev]"
+   ```
+   On Intel CPU also: `pip install -e ".[openvino]"` (ignore failure if wheels are missing).
+   Only if the human asked to export graphs: `pip install -e ".[export]"`.
+4. Verify:
+   ```bash
+   laya-onnx --help
+   PYTHONPATH=. python -c "from laya_onnx import load; print('import ok')"
+   ```
+5. Write `AGENTS.md` at the repo root if it does not exist. Point at README, `examples/`, `laya-onnx predict`, `optimize --precision int8`, and `examples/snake.html`.
+6. Optional MCP: this repo does **not** ship a hosted MCP server yet. Do not invent RunPod keys. If the human wants GPU later: `npx skills add runpod/runpod-plugins-official`.
+7. Report back Python version, install path, working commands, and that weights live on Hugging Face (`receptron/laya-onnx`).
+
+Do not commit `.venv`, ONNX weights, or API keys.

README.md

@@ -0,0 +1,134 @@
+---
+license: apache-2.0
+library_name: onnxruntime
+pipeline_tag: text-classification
+base_model: convaiinnovations/laya
+tags:
+  - onnx
+  - onnxruntime
+  - decision-model
+  - typed-decisions
+  - calibration
+  - cpu
+  - intel
+  - laya
+---
+
+# laya-onnx
+
+ONNX Runtime for [Laya](https://huggingface.co/convaiinnovations/laya) — typed
+System-1 decisions, no generated tokens. PC sibling of
+[laya-coreml](https://github.com/mizorewww/laya-coreml); same `choice` / `score` /
+`noul` contract.
+
+- **Source code:** <https://github.com/Geoking2104/laya-onnx>
+- **Weights (not hosted in this repo, ≈1.6 GB fp32):** <https://huggingface.co/receptron/laya-onnx>
+- **Benchmark · calibration · checksums:** <https://huggingface.co/datasets/gdelatournelle/laya-onnx-bench>
+
+This Hub repository mirrors the project's source tree (runtime, CLI, Snake demo,
+benchmarks, tests, docs). Model weights are **not** included here.
+
+## Model description
+
+| | |
+| --- | --- |
+| Task | Typed decision — `choice`, `score`, `noul` |
+| Output | per-question label/score + probability; no generated tokens (`output_tokens: 0`) |
+| Backbone | Laya (ModernBERT-style encoder + RL decision head) |
+| Runtime | ONNX Runtime — CPU, Intel OpenVINO, CUDA |
+| Weights | `receptron/laya-onnx` (~1.6 GB, fp32) |
+| Precision | fp32; `laya-onnx optimize --precision int8` on Intel CPU |
+| License | Apache-2.0 (following Laya) |
+
+`laya-onnx` answers **typed questions** about a state and returns probabilities —
+it never writes text. `predict()` batches every question for a state into one
+call and decides by argmax; `predict_argmax()` ignores the calibrated temperature
+for a reproducible path.
+
+## Install
+
+```bash
+git clone https://github.com/Geoking2104/laya-onnx && cd laya-onnx
+python3 -m venv .venv && source .venv/bin/activate   # Windows: .venv\Scripts\activate
+pip install -U pip && pip install -e ".[demo,dev]"
+pip install -e ".[openvino]"   # Intel CPU
+pip install -e ".[ultrafast]"  # optional: Playwright DOM loop
+```
+
+Model weights are not in git. The first `load("receptron/laya-onnx")` (or CLI
+run) fetches them from the Hub.
+
+## Usage
+
+```python
+from laya_onnx import load
+
+agent = load("receptron/laya-onnx", providers="cpu")
+print(agent.predict(
+    "The customer requests a refund of a duplicate payment.",
+    {"refund": {"type": "noul", "instructions": "Does the customer request a refund?"}},
+))
+```
+
+Deterministic path (single thread, no padding, temperature ignored):
+
+```python
+agent = load("receptron/laya-onnx", providers="cpu", deterministic=True)
+print(agent.predict_argmax(state, questions))
+```
+
+## CLI
+
+```bash
+laya-onnx predict  --state "..." --questions q.json --model ./onnx
+laya-onnx convert  --model convaiinnovations/laya --output onnx --precision fp32
+laya-onnx optimize ./onnx --precision int8           # Intel CPU
+laya-onnx verify   --model ./onnx                     # SHA-256 check vs bundled manifest
+laya-onnx-ultrafast --dry-run --fixture examples/ultrafast_page.json --goal "..."
+laya-onnx-snake --model ./onnx                        # terminal Snake
+```
+
+## Published benchmark
+
+CPU run (Windows 11, Intel i7-1255U, `onnxruntime`), bundle `receptron/laya-onnx`
+@ `68f27dfe`:
+
+| question type | n | accuracy | MAE | ECE |
+| --- | ---: | ---: | ---: | ---: |
+| choice | 4 | 1.00 | – | 0.456 |
+| noul | 4 | 1.00 | – | 0.129 |
+| score | 2 | 0.50 | 0.530 | 0.112 |
+| **overall** | **10** | **0.90** | – | **0.256** |
+
+Latency per `predict()` call: mean 2808 ms / p50 1760 ms / p95 7418 ms. Small
+self-check set (`benchmarks/eval/decisions.jsonl`), **not** a leaderboard — see
+the [bench dataset](https://huggingface.co/datasets/gdelatournelle/laya-onnx-bench)
+for the method and caveats.
+
+## Calibration
+
+Confidence is calibrated with per-question-type temperatures (plus per
+option-count buckets); `load()` warns and clamps any temperature outside the
+accepted range. Calibration is reported as ECE in the benchmark above.
+
+## Verify a download
+
+```bash
+laya-onnx verify --model ~/.cache/huggingface/hub/laya-onnx-bundles/receptron--laya-onnx
+```
+
+Hashes every bundle file against the SHA-256 manifest shipped in
+`laya_onnx/checksums/`.
+
+## Repository map
+
+- `laya_onnx/` — runtime (`agent`, `hub`, `inputs`, `tokenizer`, `convert`, `optimize`, `eval`, `verify`, `cli`)
+- `laya_onnx/snake/` · `laya_onnx/ultrafast/` — demos (terminal Snake; Playwright DOM loop)
+- `benchmarks/` — `evaluate.py`, `pc_benchmark.py`, `eval/decisions.jsonl`, published `results.*`
+- `docs/` — `DETERMINISTIC.md`, `ULTRAFAST.md`
+- `examples/` — quickstart, sample state/questions, `snake.html` browser mock
+
+## Attribution
+
+Apache-2.0. Derived from Laya (Apache-2.0) and laya-mlx. Ultrafast loop design
+from Browser Use. See `LICENSE` and `NOTICE`.

benchmarks/eval/decisions.jsonl

@@ -0,0 +1,8 @@
+{"id": "dept-refund", "state": "Customer email: 'You charged me twice for invoice #4411. Please refund the duplicate payment today or we will cancel our plan.'", "questions": {"department": {"type": "choice", "instructions": "Which department should handle this email?", "criteria": {"billing": "invoices, payments, refunds", "technical": "bugs, outages, system errors", "sales": "pricing, new contracts", "other": "everything else"}}, "refund": {"type": "noul", "instructions": "Does the customer ask for money back?"}}, "gold": {"department": "billing", "refund": true}}
+{"id": "dept-bug", "state": "Support ticket: 'The desktop app crashes every time I open a shared document since the 3.2 update.'", "questions": {"department": {"type": "choice", "instructions": "Which department should handle this ticket?", "criteria": {"billing": "invoices, payments, refunds", "technical": "bugs, outages, system errors", "sales": "pricing, new contracts", "other": "everything else"}}, "system_error": {"type": "noul", "instructions": "Is the user reporting a software bug or system error?"}}, "gold": {"department": "technical", "system_error": true}}
+{"id": "dept-sales", "state": "Prospect email: 'Could you send pricing for 200 Enterprise seats and a quote for an annual contract?'", "questions": {"department": {"type": "choice", "instructions": "Which department should handle this email?", "criteria": {"billing": "invoices, payments, refunds", "technical": "bugs, outages, system errors", "sales": "pricing, new contracts", "other": "everything else"}}}, "gold": {"department": "sales"}}
+{"id": "dept-other", "state": "User email: 'How do I change the display name shown on my profile?'", "questions": {"department": {"type": "choice", "instructions": "Which department should handle this email?", "criteria": {"billing": "invoices, payments, refunds", "technical": "bugs, outages, system errors", "sales": "pricing, new contracts", "other": "everything else"}}}, "gold": {"department": "other"}}
+{"id": "urgency-critical", "state": "Production alert: 'Payment processing is down in production. Every checkout fails and customers are blocked right now.'", "questions": {"urgency": {"type": "score", "instructions": "How urgent is this request?", "criteria": ["not urgent", "soon", "critical deadline or blocking issue"]}}, "gold": {"urgency": 2}}
+{"id": "urgency-low", "state": "Feature request: 'Sometime next quarter it would be nice to have a dark mode option.'", "questions": {"urgency": {"type": "score", "instructions": "How urgent is this request?", "criteria": ["not urgent", "soon", "critical deadline or blocking issue"]}}, "gold": {"urgency": 0}}
+{"id": "refund-false", "state": "Customer email: 'Please update the billing address on our account to 12 Rue de Rivoli, Paris.'", "questions": {"refund": {"type": "noul", "instructions": "Does the customer ask for money back?"}}, "gold": {"refund": false}}
+{"id": "outage-true", "state": "Ticket: 'After the latest release the CSV export button returns HTTP 500 for every user.'", "questions": {"system_error": {"type": "noul", "instructions": "Is the user reporting a software bug or system error?"}}, "gold": {"system_error": true}}

benchmarks/evaluate.py

@@ -0,0 +1,56 @@
+"""Run the labeled decision eval and print a Markdown/JSON summary.
+
+Usage:
+    python benchmarks/evaluate.py <model_dir_or_hub_id> [--json benchmarks/results.json]
+
+``<model>`` is a local ONNX bundle or an already-cached Hub id. Runs on CPU by
+default; pass ``--deterministic`` for the reproducible path.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from laya_onnx import load
+from laya_onnx.eval import format_markdown, load_items, run_eval
+
+HERE = Path(__file__).resolve().parent
+DEFAULT_EVAL = HERE / "eval" / "decisions.jsonl"
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(prog="benchmarks/evaluate.py", description=__doc__)
+    parser.add_argument("model", help="Local ONNX bundle or an already-cached Hub id")
+    parser.add_argument("--eval", type=Path, default=DEFAULT_EVAL, help="JSONL eval set")
+    parser.add_argument("--providers", default="cpu")
+    parser.add_argument("--threads", type=int)
+    parser.add_argument("--deterministic", action="store_true")
+    parser.add_argument("--json", type=Path, help="Write the raw results JSON here")
+    args = parser.parse_args(argv)
+
+    items = load_items(args.eval)
+    agent = load(
+        args.model,
+        providers=args.providers,
+        threads=args.threads,
+        deterministic=args.deterministic,
+    )
+    results = run_eval(agent, items)
+    results["model"] = {
+        "id": str(args.model),
+        "providers": args.providers,
+        "threads": args.threads,
+        "deterministic": bool(args.deterministic),
+    }
+    if args.json:
+        args.json.parent.mkdir(parents=True, exist_ok=True)
+        args.json.write_text(json.dumps(results, indent=2) + "\n", encoding="utf-8")
+        print(f"wrote {args.json}")
+    print(format_markdown(results))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

benchmarks/pc_benchmark.py

@@ -0,0 +1,37 @@
+"""P50/P95 for one short multilingual decision on this PC.
+
+Usage: python benchmarks/pc_benchmark.py <model_dir> [--calls 2000]
+"""
+
+import argparse
+import json
+import statistics
+import time
+
+from laya_onnx import load
+
+parser = argparse.ArgumentParser()
+parser.add_argument("model")
+parser.add_argument("--calls", type=int, default=2000)
+parser.add_argument("--providers", default="cpu")
+args = parser.parse_args()
+agent = load(args.model, providers=args.providers)
+questions = {"refund": {"type": "noul", "instructions": "Does the customer request a refund?"}}
+agent.predict("Warmup state.", questions)  # compile/warm
+samples = []
+for _ in range(args.calls):
+    t0 = time.perf_counter()
+    agent.predict("The customer asks for a refund of a duplicate payment.", questions)
+    samples.append((time.perf_counter() - t0) * 1000)
+samples.sort()
+print(
+    json.dumps(
+        {
+            "n": len(samples),
+            "p50_ms": samples[len(samples) // 2],
+            "p95_ms": samples[int(len(samples) * 0.95)],
+            "mean_ms": statistics.fmean(samples),
+        },
+        indent=2,
+    )
+)

benchmarks/results.json

@@ -0,0 +1,38 @@
+{
+  "by_type": {
+    "choice": {
+      "n": 4,
+      "accuracy": 1.0,
+      "ece": 0.4559
+    },
+    "noul": {
+      "n": 4,
+      "accuracy": 1.0,
+      "ece": 0.1288
+    },
+    "score": {
+      "n": 2,
+      "accuracy": 0.5,
+      "ece": 0.1122,
+      "mae": 0.5302
+    }
+  },
+  "overall": {
+    "items": 8,
+    "questions": 10,
+    "answers_scored": 10,
+    "accuracy": 0.9,
+    "ece": 0.2563,
+    "latency_ms": {
+      "mean": 2807.998,
+      "p50": 1759.94,
+      "p95": 7417.614
+    }
+  },
+  "model": {
+    "id": "C:\\Users\\geoff\\.cache\\huggingface\\hub\\laya-onnx-bundles\\receptron--laya-onnx",
+    "providers": "cpu",
+    "threads": null,
+    "deterministic": false
+  }
+}

benchmarks/results.md

@@ -0,0 +1,77 @@
+# Benchmarks
+
+Reproducible decision benchmarks for `laya-onnx`. Everything here runs offline
+once weights are cached; nothing is a leaderboard — these are self-checks you
+can rerun on your own machine.
+
+## Decision eval (accuracy + calibration)
+
+```bash
+# local bundle
+python benchmarks/evaluate.py ./onnx --json benchmarks/results.json
+# or an already-cached Hub bundle
+python benchmarks/evaluate.py receptron/laya-onnx
+```
+
+The eval set (`benchmarks/eval/decisions.jsonl`) is a small labeled self-check:
+**8 states / 10 questions** across the three typed forms (`choice`, `score`,
+`noul`). Confidence values are the model's own; calibration is reported as
+expected calibration error (ECE, 10 bins, lower is better).
+
+### Published result
+
+Environment: Windows 11, 12th Gen Intel Core i7-1255U (12 threads, 15.8 GB RAM),
+`onnxruntime` CPU, bundle `receptron/laya-onnx` @ `68f27dfe`.
+
+| question type | n | accuracy | MAE | ECE |
+| --- | ---: | ---: | ---: | ---: |
+| choice | 4 | 1.00 | – | 0.456 |
+| noul | 4 | 1.00 | – | 0.129 |
+| score | 2 | 0.50 | 0.530 | 0.112 |
+| **overall** | **10** | **0.90** | – | **0.256** |
+
+Latency per `predict()` call: mean **2808 ms** / p50 **1760 ms** / p95 **7418 ms**.
+
+Reading:
+- All four `choice` and all four `noul` decisions were correct; one of the two
+  `score` items missed (MAE 0.53).
+- Calibration is **not** tight at this sample size. The `choice` bucket is
+  *under*-confident (correct, but ~0.55 confidence), which is recorded rather
+  than hidden. The checkpoint also ships one calibration temperature outside the
+  accepted range; `load()` warns and clamps it (expected, not an error).
+- With 10 questions the confidence intervals are wide — treat this as a smoke
+  result, not a measurement of model quality.
+
+Raw output: [`benchmarks/results.json`](results.json).
+
+## Latency
+
+```bash
+python benchmarks/pc_benchmark.py ./onnx --calls 2000
+```
+
+P50/P95 for one short multilingual decision on this machine (no eval set
+needed). See the note above for a measured sample.
+
+## Verify a download
+
+Every published bundle ships a SHA-256 manifest under `laya_onnx/checksums/`.
+Check a local copy:
+
+```bash
+laya-onnx verify --model ~/.cache/huggingface/hub/laya-onnx-bundles/receptron--laya-onnx
+```
+
+`receptron/laya-onnx` @ `68f27dfe` — sizes and SHA-256:
+
+| file | bytes | sha256 |
+| --- | ---: | --- |
+| `laya.onnx` | 3,807,291 | `a874eb25…66dba1e` |
+| `laya.onnx.data` | 1,685,258,240 | `48774636…3242aba` |
+| `laya_config.json` | 369 | `5049005d…69bb561` |
+| `tokenizer/tokenizer.json` | 3,583,228 | `6c8aaa9a…3c08d30` |
+| `tokenizer/tokenizer_config.json` | 308 | `50044de6…320dd12` |
+
+The two weight files match the SHA-256 published by Hugging Face for their LFS
+objects; full digests are in
+[`laya_onnx/checksums/receptron-laya-onnx.json`](../laya_onnx/checksums/receptron-laya-onnx.json).

docs/DETERMINISTIC.md

@@ -0,0 +1,6 @@
+# Deterministic inference
+
+- `load(..., deterministic=True)` → ORT `intra_op_num_threads=1`, no pad-to-16, CPU arena off.
+- `Agent.predict_argmax(state, questions)` → ignore temperature; `choice`/`score`/`noul` from `argmax(logits)`.
+- `laya-onnx-ultrafast --deterministic` → `predict_argmax` + `_heuristic_text` (never the OpenAI helper).
+- Still not bit-identical across ORT versions. Pin `onnxruntime` and the ONNX graph.

docs/ULTRAFAST.md

@@ -0,0 +1,12 @@
+# laya-onnx ultrafast
+
+Port of jev-ultrafast / laya-ultrafast onto local ONNX Laya.
+
+`--dry-run` never opens Chrome. `--deterministic` uses `predict_argmax`, ORT threads=1, and heuristic TYPE_TEXT (no TEXT_MODEL).
+
+```bash
+laya-onnx-ultrafast --deterministic --dry-run --fixture examples/ultrafast_page.json \
+  --goal "Find one-way flights from Zurich to London on 20 September 2026."
+```
+
+Ops: CLICK TYPE_TEXT SELECT SCROLL_DOWN SCROLL_UP WAIT DONE BLOCKED

examples/questions.json

@@ -0,0 +1,21 @@
+{
+  "department": {
+    "type": "choice",
+    "instructions": "Which department should handle this email?",
+    "criteria": {
+      "billing": "invoices, payments, refunds",
+      "technical": "bugs, outages, system errors",
+      "sales": "pricing, new contracts",
+      "other": "everything else"
+    }
+  },
+  "urgency": {
+    "type": "score",
+    "instructions": "How urgent is this request?",
+    "criteria": ["not urgent", "soon", "critical deadline or blocking issue"]
+  },
+  "refund": {
+    "type": "noul",
+    "instructions": "Does the customer ask for money back?"
+  }
+}

examples/quickstart.py

@@ -0,0 +1,14 @@
+"""Run with: python examples/quickstart.py"""
+
+import json
+from pathlib import Path
+
+import laya_onnx as laya
+
+root = Path(__file__).parent
+agent = laya.load("receptron/laya-onnx", providers="cpu")
+result = agent.predict(
+    json.loads((root / "state.json").read_text()),
+    json.loads((root / "questions.json").read_text()),
+)
+print(json.dumps(result, indent=2, ensure_ascii=False))

examples/snake.html

@@ -0,0 +1,79 @@
+<!DOCTYPE html>
+<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width,initial-scale=1"/>
+<title>laya-onnx Snake</title>
+<style>
+html,body{margin:0;background:#070b12;color:#e2e8f0;font-family:system-ui,sans-serif}
+.wrap{max-width:980px;margin:0 auto;padding:20px}.kicker{color:#34d399;font-size:11px;letter-spacing:.18em;text-transform:uppercase}
+h1{margin:6px 0 14px;font-size:26px}.grid{display:grid;grid-template-columns:1fr 260px;gap:16px}
+@media(max-width:840px){.grid{grid-template-columns:1fr}}
+canvas#c{display:block;width:100%;max-width:720px;background:#020617;border:2px solid #34d399;border-radius:12px}
+.panel{background:#0f172a;border:1px solid #1e293b;border-radius:12px;padding:14px}
+.panel h2{margin:0 0 10px;font-size:13px;letter-spacing:.08em;text-transform:uppercase;color:#94a3b8}
+.stat{display:flex;justify-content:space-between;font-size:13px;padding:5px 0;border-bottom:1px solid #1e293b}
+.stat b{color:#6ee7b7;font-variant-numeric:tabular-nums}
+.keys{display:none;margin-top:12px}.keys.on{display:block}
+.k{display:inline-block;min-width:22px;padding:3px 7px;margin:2px;border-radius:6px;background:#1e293b;border:1px solid #334155;font-size:12px;text-align:center}
+.row{display:flex;gap:8px;flex-wrap:wrap;align-items:center;margin-top:12px}
+button,select{padding:8px 12px;border:0;border-radius:8px;background:#334155;color:#fff}
+#play{background:#34d399;color:#052e16;font-weight:700}#spark{width:100%;height:56px;background:#020617;border-radius:8px;margin-top:8px}
+.hint{color:#94a3b8;font-size:12px;margin-top:8px;line-height:1.45}
+</style></head><body>
+<div class="wrap"><div class="kicker">laya-onnx</div><h1>Snake bench</h1>
+<div class="grid"><div>
+<canvas id="c" width="720" height="480">Canvas required</canvas>
+<div class="row"><button id="play">Pause</button><button id="reset">Reset</button>
+<select id="mode"><option value="laya">Laya mock</option><option value="cycle">Hamilton cycle</option><option value="human">Keyboard</option></select>
+<label class="hint">FPS <input id="fps" type="range" min="3" max="16" value="8"/></label></div>
+<div id="keys" class="keys panel"><h2>Keyboard</h2>
+<div><span class="k">↑</span><span class="k">W</span> up</div>
+<div><span class="k">←</span><span class="k">A</span> left <span class="k">↓</span><span class="k">S</span> down <span class="k">→</span><span class="k">D</span> right</div>
+<div><span class="k">space</span> pause <span class="k">R</span> reset</div>
+<p class="hint">Choose Keyboard, then use the keys above. Reversing into the neck is illegal.</p></div>
+</div>
+<div class="panel"><h2>Performance</h2>
+<div class="stat">Score <b id="sc">0</b></div>
+<div class="stat">Best <b id="best">0</b></div>
+<div class="stat">Length <b id="ln">6</b></div>
+<div class="stat">Steps <b id="st">0</b></div>
+<div class="stat">Eats <b id="eat">0</b></div>
+<div class="stat">Deaths <b id="dead">0</b></div>
+<div class="stat">Elapsed <b id="el">0.0s</b></div>
+<div class="stat">Steps / s <b id="sps">0.0</b></div>
+<div class="stat">Last move <b id="mv">-</b></div>
+<canvas id="spark" width="232" height="56"></canvas>
+<p class="hint">Sparkline = length over the last 80 steps. Mock policy, no ONNX.</p>
+</div></div></div>
+<script>
+(function(){
+var W=24,H=16,CAP=W*H,CW=720,CH=480,CW0=CW/W,CH0=CH/H;
+var canvas=document.getElementById("c"),ctx=canvas.getContext("2d");
+var spark=document.getElementById("spark"),sctx=spark.getContext("2d");
+var DIRS={UP:[0,-1],DOWN:[0,1],LEFT:[-1,0],RIGHT:[1,0]},NAMES=["UP","DOWN","LEFT","RIGHT"];
+function ham(w,h){if(h%2)return ham(h,w).map(function(p){return[p[1],p[0]]});var p=[[0,0]],y,x;for(y=0;y<h;y++){if(y%2===0)for(x=1;x<w;x++)p.push([x,y]);else for(x=w-1;x>0;x--)p.push([x,y]);}for(y=h-1;y>0;y--)p.push([0,y]);return p;}
+var cycle=ham(W,H),idx={};for(var i=0;i<cycle.length;i++)idx[cycle[i][0]+","+cycle[i][1]]=i;
+function rng(s){return function(){var t=(s+=0x6d2b79f5);t=Math.imul(t^t>>>15,t|1);t^=t+Math.imul(t^t>>>7,t|61);return((t^t>>>14)>>>0)/4294967296;};}
+function Game(){this.rand=rng(7);var start=idx[Math.floor(W/2)+","+Math.floor(H/2)];this.body=[];for(var i=0;i<6;i++)this.body.push(cycle[(start-i+CAP)%CAP]);this.score=0;this.alive=true;this.food=this.spawn();}
+Game.prototype.spawn=function(){var occ={},i,empty=[];for(i=0;i<this.body.length;i++)occ[this.body[i][0]+","+this.body[i][1]]=1;for(i=0;i<cycle.length;i++)if(!occ[cycle[i][0]+","+cycle[i][1]])empty.push(cycle[i]);return empty.length?empty[Math.floor(this.rand()*empty.length)]:null;};
+Game.prototype.target=function(d){var v=DIRS[d];return[this.body[0][0]+v[0],this.body[0][1]+v[1]];};
+Game.prototype.legal=function(d){var t=this.target(d),x=t[0],y=t[1],i;if(x<0||y<0||x>=W||y>=H)return"wall";if(this.body[1]&&this.body[1][0]===x&&this.body[1][1]===y)return"reverse";var occ={};for(i=0;i<this.body.length;i++)occ[this.body[i][0]+","+this.body[i][1]]=1;var eats=this.food&&this.food[0]===x&&this.food[1]===y;if(!eats){var tl=this.body[this.body.length-1];delete occ[tl[0]+","+tl[1]];}return occ[x+","+y]?"body":"legal";};
+Game.prototype.step=function(d){if(!this.alive)return"dead";var why=this.legal(d);if(why!=="legal"){this.alive=false;return why;}var n=this.target(d);var eats=this.food&&n[0]===this.food[0]&&n[1]===this.food[1];this.body.unshift(n);if(eats){this.score++;this.food=this.spawn();}else this.body.pop();return eats?"eat":"ok";};
+function cycleDir(g){var i=idx[g.body[0][0]+","+g.body[0][1]],n=cycle[(i+1)%CAP];var dx=n[0]-g.body[0][0],dy=n[1]-g.body[0][1];if(dx===1)return"RIGHT";if(dx===-1)return"LEFT";if(dy===1)return"DOWN";return"UP";}
+function mock(g){var best=null,bd=99,i;for(i=0;i<4;i++){var d=NAMES[i];if(g.legal(d)!=="legal")continue;var t=g.target(d),dist=g.food?Math.abs(t[0]-g.food[0])+Math.abs(t[1]-g.food[1]):99;if(dist<bd){bd=dist;best=d;}}return best||cycleDir(g);}
+function paint(){ctx.fillStyle="#020617";ctx.fillRect(0,0,CW,CH);ctx.strokeStyle="#1e293b";var x,y;for(x=0;x<=W;x++){ctx.beginPath();ctx.moveTo(x*CW0,0);ctx.lineTo(x*CW0,CH);ctx.stroke();}for(y=0;y<=H;y++){ctx.beginPath();ctx.moveTo(0,y*CH0);ctx.lineTo(CW,y*CH0);ctx.stroke();}if(game.food){ctx.fillStyle="#fbbf24";ctx.fillRect(game.food[0]*CW0+3,game.food[1]*CH0+3,CW0-6,CH0-6);}for(var i=game.body.length-1;i>=0;i--){var c=game.body[i];ctx.fillStyle=i===0?"#6ee7b7":"#059669";ctx.fillRect(c[0]*CW0+2,c[1]*CH0+2,CW0-4,CH0-4);}}
+function sparkline(){sctx.fillStyle="#020617";sctx.fillRect(0,0,232,56);if(hist.length<2)return;var max=1,i;for(i=0;i<hist.length;i++)if(hist[i]>max)max=hist[i];sctx.strokeStyle="#34d399";sctx.beginPath();for(i=0;i<hist.length;i++){var px=i*(232/Math.max(hist.length-1,1));var py=52-(hist[i]/max)*48;if(i===0)sctx.moveTo(px,py);else sctx.lineTo(px,py);}sctx.stroke();}
+var game=new Game(),running=false,humanDir="RIGHT",timer=null;
+var steps=0,eats=0,deaths=0,best=0,t0=performance.now(),hist=[];
+function dash(dir,r){document.getElementById("sc").textContent=game.score;if(game.score>best)best=game.score;document.getElementById("best").textContent=best;document.getElementById("ln").textContent=game.body.length;document.getElementById("st").textContent=steps;document.getElementById("eat").textContent=eats;document.getElementById("dead").textContent=deaths;var sec=(performance.now()-t0)/1000;document.getElementById("el").textContent=sec.toFixed(1)+"s";document.getElementById("sps").textContent=sec>0?(steps/sec).toFixed(1):"0.0";document.getElementById("mv").textContent=(dir||"-")+" / "+(r||"-");}
+function tick(){var mode=document.getElementById("mode").value;var dir=cycleDir(game);if(mode==="laya")dir=mock(game);if(mode==="human")dir=humanDir;var r=game.step(dir);steps++;if(r==="eat")eats++;if(!game.alive)deaths++;hist.push(game.body.length);if(hist.length>80)hist.shift();paint();sparkline();dash(dir,r);if(!game.alive){stop();setTimeout(function(){game=new Game();humanDir="RIGHT";paint();dash("reset","new");if(document.getElementById("mode").value!=="human")start();},700);}}
+function start(){if(running)return;running=true;document.getElementById("play").textContent="Pause";timer=setInterval(tick,1000/Number(document.getElementById("fps").value));}
+function stop(){running=false;document.getElementById("play").textContent="Play";clearInterval(timer);}
+function reset(){stop();game=new Game();humanDir="RIGHT";steps=0;eats=0;deaths=0;t0=performance.now();hist=[];paint();sparkline();dash("reset","ok");start();}
+function syncKeys(){document.getElementById("keys").className="keys panel"+(document.getElementById("mode").value==="human"?" on":"");}
+document.getElementById("play").onclick=function(){running?stop():start();};
+document.getElementById("reset").onclick=reset;
+document.getElementById("mode").onchange=syncKeys;
+document.getElementById("fps").onchange=function(){if(running){stop();start();}};
+window.addEventListener("keydown",function(e){var map={ArrowUp:"UP",ArrowDown:"DOWN",ArrowLeft:"LEFT",ArrowRight:"RIGHT",w:"UP",s:"DOWN",a:"LEFT",d:"RIGHT",W:"UP",S:"DOWN",A:"LEFT",D:"RIGHT"};if(map[e.key]){humanDir=map[e.key];if(document.getElementById("mode").value!=="human"){document.getElementById("mode").value="human";syncKeys();}e.preventDefault();}if(e.key===" "){running?stop():start();e.preventDefault();}if(e.key==="r"||e.key==="R")reset();});
+syncKeys();paint();sparkline();dash("-","ready");start();
+})();
+</script></body></html>

examples/state.json

@@ -0,0 +1,5 @@
+{
+  "from": "user@example.com",
+  "subject": "Duplicate charge on invoice #4411",
+  "body": "We were billed twice for March. Please refund the duplicate today or we will cancel our plan."
+}

examples/ultrafast_goal.py

@@ -0,0 +1,14 @@
+"""Offline fixture walk — no Chrome, no Hub weights if you pass a stub agent."""
+
+from laya_onnx.ultrafast import UltrafastAgent
+
+GOAL = "Find one-way flights from Zurich to London on 20 September 2026."
+
+if __name__ == "__main__":
+    with UltrafastAgent(
+        "https://www.google.com/travel/flights?hl=en",
+        GOAL,
+        fixture="examples/ultrafast_page.json",
+    ) as agent:
+        for step in agent.run(max_steps=8):
+            print(step["op"], step.get("target"), step["status"])

examples/ultrafast_page.json

@@ -0,0 +1,13 @@
+{
+  "url": "https://www.google.com/travel/flights?hl=en",
+  "title": "Google Flights",
+  "text": "Flights One way Zurich London Sat, Sep 20",
+  "elements": [
+    {"index": 0, "role": "button", "name": "Round trip", "value": "", "tag": "button", "editable": false},
+    {"index": 1, "role": "button", "name": "One way", "value": "", "tag": "button", "editable": false},
+    {"index": 2, "role": "textbox", "name": "Where from?", "value": "", "tag": "input", "editable": true},
+    {"index": 3, "role": "textbox", "name": "Where to?", "value": "", "tag": "input", "editable": true},
+    {"index": 4, "role": "textbox", "name": "Departure", "value": "", "tag": "input", "editable": true},
+    {"index": 5, "role": "button", "name": "Search", "value": "", "tag": "button", "editable": false}
+  ]
+}

laya_onnx/__init__.py

@@ -0,0 +1,10 @@
+"""Laya typed decisions on ONNX Runtime (CPU / OpenVINO / CUDA)."""
+
+from .agent import Agent, RLAgent, load
+
+__version__ = "0.1.0"
+__all__ = [
+    "Agent",
+    "RLAgent",
+    "load",
+]

laya_onnx/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

laya_onnx/agent.py

@@ -0,0 +1,280 @@
+"""ONNX Runtime inference; prompt and result formats follow upstream Laya."""
+
+from __future__ import annotations
+
+import json
+import math
+import warnings
+from pathlib import Path
+
+import numpy as np
+
+from .common import (
+    QTYPES,
+    TEMP_MAX,
+    TEMP_MIN,
+    build_sequence,
+    clamp_temperature,
+    confidence_from_probs,
+    render_options,
+    temp_bucket,
+)
+from .hub import find_config, find_graph, resolve_bundle
+from .inputs import collate_items
+from .tokenizer import Tokenizer
+
+
+def _providers(name: str) -> list[str]:
+    if name == "openvino":
+        return ["OpenVINOExecutionProvider", "CPUExecutionProvider"]
+    if name == "cuda":
+        return ["CUDAExecutionProvider", "CPUExecutionProvider"]
+    return ["CPUExecutionProvider"]
+
+
+def _session_dtypes(session) -> dict[str, np.dtype]:
+    mapping = {}
+    for inp in session.get_inputs():
+        raw = (inp.type or "").lower()
+        if "int32" in raw:
+            mapping[inp.name] = np.int32
+        elif "int64" in raw:
+            mapping[inp.name] = np.int64
+        elif "bool" in raw:
+            mapping[inp.name] = np.bool_
+        elif "float16" in raw:
+            mapping[inp.name] = np.float16
+        else:
+            mapping[inp.name] = None
+    return mapping
+
+
+class Agent:
+    def __init__(
+        self,
+        model_id_or_path="receptron/laya-onnx",
+        providers="cpu",
+        token=None,
+        subfolder=None,
+        *,
+        revision=None,
+        batch_size=16,
+        threads=None,
+        pad_to_multiple=16,
+        deterministic=False,
+    ):
+        if deterministic:
+            threads = 1
+            pad_to_multiple = None
+        if providers not in ("cpu", "openvino", "cuda"):
+            raise ValueError("providers must be 'cpu', 'openvino', or 'cuda'")
+        if not isinstance(batch_size, int) or isinstance(batch_size, bool) or batch_size < 1:
+            raise ValueError("batch_size must be a positive integer")
+        if pad_to_multiple is not None and (
+            not isinstance(pad_to_multiple, int)
+            or isinstance(pad_to_multiple, bool)
+            or pad_to_multiple < 1
+        ):
+            raise ValueError("pad_to_multiple must be a positive integer or None")
+        self.providers = providers
+        self.batch_size = batch_size
+        self.deterministic = bool(deterministic)
+        self.pad_to_multiple = pad_to_multiple
+        self.model_id = str(model_id_or_path)
+        self.revision = revision
+        self.model_dir = resolve_bundle(
+            model_id_or_path, token=token, subfolder=subfolder, revision=revision
+        )
+        cfg_path = find_config(self.model_dir)
+        raw = json.loads(cfg_path.read_text())
+        self.cfg = raw
+        max_len = int(raw.get("max_len", 512))
+        head_max_len = int(raw.get("head_max_len", 192))
+        if not 4 < head_max_len < max_len:
+            raise ValueError("Expected 4 < head_max_len < max_len")
+        self.temperature_raw = raw.get("temperature", [1.0, 1.0, 1.0])
+        self.temperature_by_options_raw = raw.get("temperature_by_options", {})
+        if len(self.temperature_raw) != 3 or any(
+            not math.isfinite(float(t)) or float(t) <= 0
+            for t in [*self.temperature_raw, *self.temperature_by_options_raw.values()]
+        ):
+            raise ValueError("Calibration temperatures must be finite and positive")
+        self.temperature = [clamp_temperature(t) for t in self.temperature_raw]
+        self.temperature_by_options = {
+            k: clamp_temperature(v) for k, v in self.temperature_by_options_raw.items()
+        }
+        rejected = [
+            "%s=%.4g" % (k, float(v))
+            for k, v in self.temperature_by_options_raw.items()
+            if clamp_temperature(v) != float(v)
+        ]
+        rejected += [
+            "temperature[%d]=%.4g" % (i, float(t))
+            for i, t in enumerate(self.temperature_raw)
+            if clamp_temperature(t) != float(t)
+        ]
+        if rejected:
+            warnings.warn(
+                "laya-onnx: this checkpoint ships temperatures outside [%g, %g] which would "
+                "distort confidence; clamping %s." % (TEMP_MIN, TEMP_MAX, ", ".join(rejected)),
+                RuntimeWarning,
+                stacklevel=2,
+            )
+        self.tok = Tokenizer(self.model_dir / "tokenizer")
+
+        import os
+
+        import onnxruntime as ort
+
+        sess_opts = ort.SessionOptions()
+        sess_opts.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        sess_opts.enable_mem_pattern = True
+        sess_opts.enable_cpu_mem_arena = not self.deterministic
+        sess_opts.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+        workers = int(threads) if threads else min(8, os.cpu_count() or 4)
+        sess_opts.intra_op_num_threads = workers
+        sess_opts.inter_op_num_threads = 1
+        sess_opts.add_session_config_entry("session.intra_op.allow_spinning", "0")
+        self.session = ort.InferenceSession(
+            str(find_graph(self.model_dir)),
+            sess_options=sess_opts,
+            providers=_providers(providers),
+        )
+        self._dtypes = _session_dtypes(self.session)
+
+    @staticmethod
+    def _to_internal(qdef):
+        if not isinstance(qdef, dict):
+            raise ValueError("Each question must be a dictionary")
+        kind = qdef.get("type")
+        if kind not in QTYPES:
+            raise ValueError(f"Unknown question type {kind!r}; expected choice, score, or noul")
+        if "instructions" not in qdef:
+            raise ValueError("Question is missing instructions")
+        criteria = qdef.get("criteria")
+        if kind == "choice":
+            if isinstance(criteria, list):
+                if not all(isinstance(c, str) for c in criteria):
+                    raise ValueError("Choice labels must be strings")
+                if len(set(criteria)) != len(criteria):
+                    raise ValueError("Choice labels must be unique")
+                criteria = dict.fromkeys(criteria)
+            if not isinstance(criteria, dict) or not criteria:
+                raise ValueError("Choice criteria must be a nonempty dictionary or list")
+            if not all(isinstance(k, str) for k in criteria):
+                raise ValueError("Choice labels must be strings")
+        elif kind == "score":
+            if not isinstance(criteria, list) or not criteria:
+                raise ValueError("Score criteria must be a nonempty list")
+        elif criteria is not None and not isinstance(criteria, dict):
+            raise ValueError("Noul criteria must be a dictionary with false/true descriptions")
+        instructions = qdef["instructions"]
+        if not isinstance(instructions, str):
+            instructions = json.dumps(instructions)
+        return {"t": kind, "ins": instructions, "crit": criteria}
+
+    def prepare(self, state, questions):
+        if not isinstance(questions, dict):
+            raise ValueError("questions must be a dictionary keyed by question id")
+        items, internal = [], []
+        for qid, definition in questions.items():
+            q = self._to_internal(definition)
+            ids, markers = build_sequence(
+                self.tok, state, q, self.cfg.get("max_len", 512), self.cfg.get("head_max_len", 192)
+            )
+            if len(markers) != len(render_options(q)):
+                raise ValueError(f"Question {qid!r} has too many options for the token budget")
+            items.append({"ids": ids, "markers": markers, "qtype": QTYPES[q["t"]]})
+            internal.append(q)
+        return items, internal
+
+    def _cast(self, batch: dict) -> dict:
+        feeds = {}
+        for name, array in batch.items():
+            target = self._dtypes.get(name)
+            if target is not None and array.dtype != target:
+                array = array.astype(target, copy=False)
+            feeds[name] = array
+        return feeds
+
+    def forward(self, batch):
+        feeds = self._cast(batch)
+        names = [o.name for o in self.session.get_outputs()]
+        outputs = self.session.run(names, feeds)
+        return tuple(np.asarray(o) for o in outputs)
+
+    def system_one(self, state, questions, *, argmax=False):
+        items, internal = self.prepare(state, questions)
+        answers = {}
+        question_ids = list(questions)
+        id_dt = self._dtypes.get("input_ids") or np.int64
+        mk_dt = self._dtypes.get("marker_pos") or np.int64
+        for start in range(0, len(items), self.batch_size):
+            chunk = items[start : start + self.batch_size]
+            batch = collate_items(
+                chunk,
+                self.tok.pad_token_id,
+                pad_to_multiple=self.pad_to_multiple,
+                max_length=self.cfg.get("max_len", 512),
+                ids_dtype=id_dt,
+                marker_dtype=mk_dt,
+            )
+            logits, act = self.forward(batch)
+            if not np.isfinite(logits).all() or not np.isfinite(act).all():
+                raise FloatingPointError("Non-finite model outputs")
+            if act.ndim == 2 and act.shape[-1] > 1 and abs(float(act[0].sum()) - 1.0) > 1e-3:
+                act = np.exp(act - act.max(axis=-1, keepdims=True))
+                act /= act.sum(axis=-1, keepdims=True)
+            for row, item in enumerate(chunk):
+                qid, q = question_ids[start + row], internal[start + row]
+                k, qt = len(item["markers"]), item["qtype"]
+                scale = (
+                    1.0
+                    if argmax
+                    else self.temperature_by_options.get(temp_bucket(qt, k), self.temperature[qt])
+                )
+                z = logits[row, :k] / scale
+                p = np.exp(z - z.max())
+                p /= p.sum()
+                act_p = float(act[row, 0]) if act.ndim == 2 else float(act[row])
+                answer = {
+                    "type": q["t"],
+                    "confidence": round(confidence_from_probs(p, k), 4),
+                    "action": {"act_probability": round(act_p, 4)},
+                }
+                if q["t"] == "choice":
+                    labels = list(q["crit"])
+                    answer.update(
+                        choice=labels[int(p.argmax())],
+                        probabilities={label: round(float(v), 4) for label, v in zip(labels, p)},
+                    )
+                elif q["t"] == "score":
+                    answer.update(
+                        score=round(float((np.arange(k) * p).sum()), 4),
+                        legend={str(i): value for i, value in enumerate(q["crit"])},
+                        probabilities={str(i): round(float(v), 4) for i, v in enumerate(p)},
+                    )
+                else:
+                    answer.update(
+                        noul=round(float(p[1]), 4),
+                        confidence=round(max(float(p[1]), 1.0 - float(p[1])), 4),
+                    )
+                answers[qid] = answer
+        return {
+            "model": "laya-onnx",
+            "answers": answers,
+            "usage": {"input_tokens": sum(len(item["ids"]) for item in items), "output_tokens": 0},
+        }
+
+    predict = system_one
+
+    def predict_argmax(self, state, questions):
+        """Deterministic path: ignore calibrated temperature (see docs/DETERMINISTIC.md)."""
+        return self.system_one(state, questions, argmax=True)
+
+
+RLAgent = Agent
+
+
+def load(model_id_or_path="receptron/laya-onnx", providers="cpu", token=None, subfolder=None, deterministic=False, **kwargs):
+    return Agent(model_id_or_path, providers=providers, token=token, subfolder=subfolder, deterministic=deterministic, **kwargs)

laya_onnx/checksums/receptron-laya-onnx.json

@@ -0,0 +1,28 @@
+{
+  "repo": "receptron/laya-onnx",
+  "revision": "68f27dfe5a27a54fb2b1fefc432f43f972e90868",
+  "source": "https://huggingface.co/receptron/laya-onnx",
+  "algorithm": "sha256",
+  "files": {
+    "laya.onnx": {
+      "size": 3807291,
+      "sha256": "a874eb254b58b0fcb1e7ad56fbb188c29d64e08c9a46b689433e1f52c66dba1e"
+    },
+    "laya.onnx.data": {
+      "size": 1685258240,
+      "sha256": "487746363a8da57bcadb4345352997d22a0fb90d70aa22c6856668d023242aba"
+    },
+    "laya_config.json": {
+      "size": 369,
+      "sha256": "5049005dc6ae3ca5e82cc7d85c421357d5c543817300c8e8c5281ddbc69bb561"
+    },
+    "tokenizer/tokenizer.json": {
+      "size": 3583228,
+      "sha256": "6c8aaa9a542084f2457eab775d4eeb51f92a70c0fd9de28d5edb0ddec3c08d30"
+    },
+    "tokenizer/tokenizer_config.json": {
+      "size": 308,
+      "sha256": "50044de60daaa73df97d262e15a40d4faf0160e7d742df64b377877a1320dd12"
+    }
+  }
+}

laya_onnx/cli.py

@@ -0,0 +1,87 @@
+"""Command-line prediction and checkpoint conversion."""
+
+import argparse
+import json
+from pathlib import Path
+
+from . import __version__
+from .agent import Agent
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="laya-onnx", description=__doc__)
+    parser.add_argument("--version", action="version", version=__version__)
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    predict = commands.add_parser("predict")
+    predict.add_argument("--model", default="receptron/laya-onnx")
+    predict.add_argument("--subfolder")
+    predict.add_argument("--revision")
+    predict.add_argument("--providers", choices=("cpu", "openvino", "cuda"), default="cpu")
+    predict.add_argument("--threads", type=int)
+    source = predict.add_mutually_exclusive_group(required=True)
+    source.add_argument("--state", help="Plain text input")
+    source.add_argument("--state-file", type=Path, help="JSON state file")
+    predict.add_argument("--questions", required=True, type=Path)
+    predict.add_argument("--batch-size", type=int, default=16)
+    predict.add_argument(
+        "--deterministic", action="store_true", help="threads=1, pad off, predict_argmax"
+    )
+
+    convert = commands.add_parser("convert")
+    convert.add_argument("--model", default="convaiinnovations/laya")
+    convert.add_argument("--subfolder")
+    convert.add_argument("--revision")
+    convert.add_argument("--output", type=Path, required=True)
+    convert.add_argument("--precision", choices=("fp32", "int8"), default="fp32")
+    convert.add_argument("--opset", type=int, default=17)
+
+    verify = commands.add_parser("verify")
+    verify.add_argument("--model", required=True, help="Local model directory to check")
+    verify.add_argument(
+        "--checksums",
+        type=Path,
+        help="Checksum manifest JSON (default: bundled receptron/laya-onnx manifest)",
+    )
+
+    args = parser.parse_args(argv)
+    if args.command == "convert":
+        from .convert import convert as do_convert
+
+        result = do_convert(
+            args.model,
+            args.output,
+            precision=args.precision,
+            revision=args.revision,
+            subfolder=args.subfolder,
+            opset=args.opset,
+        )
+        print(json.dumps({"output": str(result), "precision": args.precision}))
+        return
+    if args.command == "verify":
+        from .verify import verify_bundle
+
+        try:
+            ok, rows = verify_bundle(args.model, args.checksums)
+        except FileNotFoundError as error:
+            parser.error(str(error))
+        for row in rows:
+            print("%15s  %s" % (row["status"], row["file"]))
+        return 0 if ok else 1
+    state = args.state if args.state is not None else json.loads(args.state_file.read_text())
+    questions = json.loads(args.questions.read_text())
+    agent = Agent(
+        args.model,
+        providers=args.providers,
+        revision=args.revision,
+        subfolder=args.subfolder,
+        batch_size=args.batch_size,
+        threads=args.threads,
+        deterministic=args.deterministic,
+    )
+    result = (
+        agent.predict_argmax(state, questions)
+        if args.deterministic
+        else agent.predict(state, questions)
+    )
+    print(json.dumps(result, ensure_ascii=False, indent=2))

laya_onnx/common.py

@@ -0,0 +1,122 @@
+"""Laya prompt construction and calibration, adapted from upstream (see NOTICE)."""
+
+import json
+import math
+from typing import Dict, List, Optional, Union
+
+import numpy as np
+
+QTYPES = {"choice": 0, "score": 1, "noul": 2}
+QTYPE_NAMES = {v: k for k, v in QTYPES.items()}
+
+
+def serialize_state(state: Union[str, dict, list]) -> str:
+    if isinstance(state, str):
+        return state
+    return json.dumps(state, ensure_ascii=False)
+
+
+def render_criterion(value) -> str:
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, ensure_ascii=False, separators=(", ", ": "), default=str)
+
+
+def render_options(q: Dict) -> List[str]:
+    t, crit = q["t"], q.get("crit")
+    if t == "choice":
+        return [
+            k if v is None or v == "" else "%s: %s" % (k, render_criterion(v))
+            for k, v in crit.items()
+        ]
+    if t == "score":
+        return ["level %d: %s" % (i, render_criterion(c)) for i, c in enumerate(crit)]
+    crit = crit or {}
+    false_crit, true_crit = crit.get("false"), crit.get("true")
+    return [
+        "false: "
+        + (
+            render_criterion(false_crit)
+            if false_crit not in (None, "")
+            else "no, the statement does not hold"
+        ),
+        "true: "
+        + (
+            render_criterion(true_crit)
+            if true_crit not in (None, "")
+            else "yes, the statement holds"
+        ),
+    ]
+
+
+def build_prefix(tok, q: Dict, head_max_len: int = 192, option_order=None):
+    mask_tok = tok.mask_token
+    opts = render_options(q)
+    order = option_order if option_order is not None else list(range(len(opts)))
+    ins = str(q["ins"]).replace(mask_tok, " ")
+    head_ids = tok("%s question: %s" % (q["t"], ins), add_special_tokens=False)["input_ids"]
+    opt_ids = []
+    for i in order:
+        opt_ids.append(
+            [tok.mask_token_id]
+            + tok(" " + opts[i].replace(mask_tok, " "), add_special_tokens=False)["input_ids"][:48]
+        )
+    opt_budget = head_max_len - sum(len(o) for o in opt_ids)
+    if opt_budget < 16:
+        per = max(4, (head_max_len - 16) // max(1, len(opt_ids)))
+        opt_ids = [o[:per] for o in opt_ids]
+        opt_budget = head_max_len - sum(len(o) for o in opt_ids)
+    head_ids = head_ids[: max(8, opt_budget)]
+    ids = [tok.cls_token_id] + head_ids + [tok.sep_token_id]
+    markers = []
+    for o in opt_ids:
+        markers.append(len(ids))
+        ids.extend(o)
+    ids.append(tok.sep_token_id)
+    return ids, markers
+
+
+def build_sequence(
+    tok,
+    state: Union[str, dict, list],
+    q: Dict,
+    max_len: int = 512,
+    head_max_len: int = 192,
+    option_order: Optional[List[int]] = None,
+    truncate_left: bool = False,
+):
+    ids, markers = build_prefix(tok, q, head_max_len, option_order)
+    room = max(0, max_len - len(ids) - 1)
+    st = tok(serialize_state(state).replace(tok.mask_token, " "), add_special_tokens=False)[
+        "input_ids"
+    ]
+    st = st[-room:] if truncate_left else st[:room]
+    ids = ids + st + [tok.sep_token_id]
+    return ids[:max_len], [m for m in markers if m < max_len]
+
+
+def confidence_from_probs(p: np.ndarray, k: int) -> float:
+    if k < 2:
+        return 1.0
+    p = p[:k]
+    ent = -(p * np.log(np.clip(p, 1e-12, 1.0))).sum()
+    return float(np.clip(1.0 - ent / math.log(k), 0.0, 1.0))
+
+
+def temp_bucket(qtype: int, k: int) -> str:
+    size = "2" if k <= 2 else "3-5" if k <= 5 else "6-10" if k <= 10 else "11+"
+    return "%s:%s" % (QTYPE_NAMES[int(qtype)], size)
+
+
+TEMP_MIN = 0.5
+TEMP_MAX = 5.0
+
+
+def clamp_temperature(t, lo: float = TEMP_MIN, hi: float = TEMP_MAX) -> float:
+    try:
+        t = float(t)
+    except (TypeError, ValueError):
+        return 1.0
+    if not math.isfinite(t):
+        return 1.0
+    return min(hi, max(lo, t))

laya_onnx/convert.py

@@ -0,0 +1,137 @@
+"""Export DecisionModel torch → ONNX (dynamic batch/sequence, opset 17)."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+from .inputs import collate_items
+from .torch_model import DecisionModel
+
+
+def _load_torch_checkpoint(source: Path):
+    from safetensors.torch import load_file
+
+    encoder_cfg = json.loads((source / "encoder/config.json").read_text())
+    agent_cfg = json.loads((source / "rl_agent_config.json").read_text())
+    max_len = int(agent_cfg.get("max_len", 512))
+    model = DecisionModel(encoder_cfg, agent_cfg, max_len)
+    state = load_file(str(source / "model.safetensors"))
+    model.load_state_dict(state, strict=True)
+    model.eval()
+    return model, encoder_cfg, agent_cfg
+
+
+def convert(
+    model_id_or_path,
+    output,
+    *,
+    precision="fp32",
+    revision=None,
+    subfolder=None,
+    token=None,
+    opset=17,
+    batch_size=2,
+    max_options=4,
+    max_length=None,
+):
+    output = Path(output).expanduser()
+    if output.exists():
+        raise FileExistsError(f"Output already exists: {output}")
+
+    import torch
+
+    src = Path(model_id_or_path).expanduser()
+    if not src.exists():
+        from huggingface_hub import snapshot_download
+
+        src = Path(
+            snapshot_download(
+                str(model_id_or_path),
+                token=token,
+                revision=revision,
+                allow_patterns=[
+                    "model.safetensors",
+                    "encoder/*",
+                    "tokenizer/*",
+                    "rl_agent_config.json",
+                ],
+            )
+        )
+        if subfolder:
+            src /= subfolder
+
+    model, encoder_cfg, agent_cfg = _load_torch_checkpoint(src)
+    max_len = int(agent_cfg.get("max_len", max_length or 64))
+    dummy_len = min(32, max_len)
+    items = [
+        {
+            "ids": list(range(dummy_len)),
+            "markers": list(range(3, 3 + min(2, max_options))),
+            "qtype": 0,
+        }
+        for _ in range(batch_size)
+    ]
+    shape = {
+        "batch_size": batch_size,
+        "max_length": max_len,
+        "min_length": 16,
+        "max_options": max_options,
+    }
+    arrays = collate_items(items, 0, shape=shape)
+    example = {k: torch.from_numpy(v) for k, v in arrays.items()}
+    example["marker_mask"] = example["marker_mask"].bool()
+
+    output.mkdir(parents=True)
+    try:
+        graph = output / "laya.onnx"
+        dynamic_axes = {
+            "input_ids": {0: "batch", 1: "sequence"},
+            "attention_mask": {0: "batch", 1: "sequence"},
+            "marker_pos": {0: "batch", 1: "options"},
+            "marker_mask": {0: "batch", 1: "options"},
+            "qtype": {0: "batch"},
+            "logits": {0: "batch", 1: "options"},
+            "act": {0: "batch"},
+        }
+        torch.onnx.export(
+            model,
+            (
+                example["input_ids"],
+                example["attention_mask"],
+                example["marker_pos"],
+                example["marker_mask"],
+                example["qtype"],
+            ),
+            str(graph),
+            input_names=["input_ids", "attention_mask", "marker_pos", "marker_mask", "qtype"],
+            output_names=["logits", "act"],
+            dynamic_axes=dynamic_axes,
+            opset_version=opset,
+            dynamo=False,
+        )
+        from .optimize import optimize_bundle
+
+        optimize_bundle(graph, precision=precision, fuse=True)
+
+        if (src / "tokenizer").is_dir():
+            shutil.copytree(src / "tokenizer", output / "tokenizer")
+        keys = ("max_len", "head_max_len", "temperature", "temperature_by_options")
+        config = {k: agent_cfg[k] for k in keys if k in agent_cfg}
+        config.setdefault("max_len", max_len)
+        config.setdefault("head_max_len", int(agent_cfg.get("head_max_len", 32)))
+        config.setdefault("temperature", [1.0, 1.0, 1.0])
+        config.setdefault("temperature_by_options", {})
+        (output / "laya_config.json").write_text(json.dumps(config, indent=2) + "\n")
+        (output / "onnx_config.json").write_text(
+            json.dumps({"format": "laya-onnx", "format_version": 1, "precision": precision, "opset": opset, **config, "encoder": encoder_cfg}, indent=2)
+            + "\n"
+        )
+        (output / "rl_agent_config.json").write_text(json.dumps(agent_cfg, indent=2) + "\n")
+        if (src / "encoder").is_dir():
+            shutil.copytree(src / "encoder", output / "encoder")
+    except BaseException:
+        shutil.rmtree(output, ignore_errors=True)
+        raise
+    return output

laya_onnx/eval.py

@@ -0,0 +1,186 @@
+"""Decision evaluation and calibration metrics.
+
+Runs a labeled eval set through a loaded :class:`laya_onnx.Agent` and reports
+per-question-type accuracy, score MAE, confidence calibration (ECE) and latency
+percentiles. Everything here is pure/offline so it can be unit-tested with a
+stub agent.
+"""
+
+from __future__ import annotations
+
+import json
+import statistics
+import time
+from pathlib import Path
+
+DEFAULT_BINS = 10
+
+
+def percentile(sorted_values, fraction):
+    """Nearest-rank percentile. ``sorted_values`` must already be sorted."""
+    if not sorted_values:
+        return None
+    index = min(len(sorted_values) - 1, int(len(sorted_values) * fraction))
+    return sorted_values[index]
+
+
+def bin_index(value, bins=DEFAULT_BINS):
+    return min(bins - 1, max(0, int(value * bins)))
+
+
+def expected_calibration_error(confidences, correct, bins=DEFAULT_BINS):
+    """Expected Calibration Error over (confidence, correctness) pairs.
+
+    Lower is better; 0 means confidence matches accuracy exactly.
+    """
+    if not confidences:
+        return None
+    total = len(confidences)
+    error = 0.0
+    for b in range(bins):
+        low = b / bins
+        high = (b + 1) / bins
+        members = [
+            i
+            for i, confidence in enumerate(confidences)
+            if low <= confidence < high or (b == bins - 1 and confidence >= 1.0)
+        ]
+        if not members:
+            continue
+        accuracy = sum(1.0 for i in members if correct[i]) / len(members)
+        mean_confidence = sum(confidences[i] for i in members) / len(members)
+        error += (len(members) / total) * abs(accuracy - mean_confidence)
+    return error
+
+
+def score_answer(qtype, answer, gold):
+    """Return ``(correct, error)`` for one answered question.
+
+    ``correct`` is ``None`` when the item has no scoreable answer, ``error`` is
+    only set for ``score`` questions.
+    """
+    if answer is None or gold is None:
+        return None, None
+    if qtype == "choice":
+        return (answer.get("choice") == gold), None
+    if qtype == "noul":
+        try:
+            predicted = float(answer.get("noul", 0.0)) >= 0.5
+        except (TypeError, ValueError):
+            return None, None
+        return (bool(predicted) == bool(gold)), None
+    if qtype == "score":
+        try:
+            error = abs(float(answer.get("score", 0.0)) - float(gold))
+        except (TypeError, ValueError):
+            return None, None
+        return (error <= 0.5), error
+    return None, None
+
+
+def load_items(path):
+    """Read a JSONL eval set (one ``{"state", "questions", "gold"}`` per line)."""
+    items = []
+    for lineno, line in enumerate(Path(path).read_text(encoding="utf-8").splitlines(), 1):
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            items.append(json.loads(line))
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"{path}:{lineno}: {exc}")
+    return items
+
+
+def run_eval(agent, items, *, bins=DEFAULT_BINS):
+    """Run ``items`` through ``agent`` and return a results dict."""
+    latencies = []
+    records = []
+    for item in items:
+        started = time.perf_counter()
+        out = agent.predict(item["state"], item["questions"])
+        latencies.append((time.perf_counter() - started) * 1000.0)
+        answers = out.get("answers", {})
+        gold = item.get("gold") or {}
+        for qid, definition in item["questions"].items():
+            answer = answers.get(qid, {})
+            qtype = definition["type"]
+            correct, error = score_answer(qtype, answer, gold.get(qid))
+            records.append(
+                {
+                    "type": qtype,
+                    "correct": correct,
+                    "error": error,
+                    "confidence": float(answer.get("confidence", 0.0) or 0.0),
+                }
+            )
+
+    buckets = {}
+    for record in records:
+        bucket = buckets.setdefault(
+            record["type"], {"confidences": [], "outcomes": [], "errors": [], "n": 0}
+        )
+        bucket["n"] += 1
+        if record["correct"] is not None:
+            bucket["confidences"].append(record["confidence"])
+            bucket["outcomes"].append(bool(record["correct"]))
+        if record["error"] is not None:
+            bucket["errors"].append(record["error"])
+
+    by_type = {}
+    for qtype, bucket in buckets.items():
+        entry = {"n": bucket["n"]}
+        if bucket["outcomes"]:
+            entry["accuracy"] = round(sum(bucket["outcomes"]) / len(bucket["outcomes"]), 4)
+            entry["ece"] = round(
+                expected_calibration_error(bucket["confidences"], bucket["outcomes"], bins), 4
+            )
+        if bucket["errors"]:
+            entry["mae"] = round(statistics.fmean(bucket["errors"]), 4)
+        by_type[qtype] = entry
+
+    confidences = [r["confidence"] for r in records if r["correct"] is not None]
+    outcomes = [bool(r["correct"]) for r in records if r["correct"] is not None]
+    latencies.sort()
+    overall = {
+        "items": len(items),
+        "questions": len(records),
+        "answers_scored": len(outcomes),
+        "accuracy": round(sum(outcomes) / len(outcomes), 4) if outcomes else None,
+        "ece": round(expected_calibration_error(confidences, outcomes, bins), 4)
+        if confidences
+        else None,
+        "latency_ms": {
+            "mean": round(statistics.fmean(latencies), 3) if latencies else None,
+            "p50": round(percentile(latencies, 0.5), 3) if latencies else None,
+            "p95": round(percentile(latencies, 0.95), 3) if latencies else None,
+        },
+    }
+    return {"by_type": by_type, "overall": overall}
+
+
+def format_markdown(results, title="laya-onnx decision eval"):
+    """Render a results dict (from :func:`run_eval`) as Markdown."""
+    overall = results.get("overall", {})
+    latency = overall.get("latency_ms", {})
+    lines = [
+        f"### {title}",
+        "",
+        f"- items: **{overall.get('items')}**  questions: **{overall.get('questions')}**",
+        f"- accuracy: **{overall.get('accuracy')}**  ECE: **{overall.get('ece')}**",
+        f"- latency (per call, ms): mean {latency.get('mean')} / p50 {latency.get('p50')} / p95 {latency.get('p95')}",
+        "",
+        "| question type | n | accuracy | MAE | ECE |",
+        "| --- | ---: | ---: | ---: | ---: |",
+    ]
+    for qtype, entry in sorted(results.get("by_type", {}).items()):
+        lines.append(
+            "| {0} | {1} | {2} | {3} | {4} |".format(
+                qtype,
+                entry.get("n", ""),
+                entry.get("accuracy", "-"),
+                entry.get("mae", "-"),
+                entry.get("ece", "-"),
+            )
+        )
+    return "\n".join(lines)

laya_onnx/hub.py

@@ -0,0 +1,83 @@
+"""Resolve a local ONNX bundle or a Hugging Face snapshot."""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+
+from huggingface_hub import snapshot_download
+
+GRAPH_NAMES = ("laya.onnx", "model.onnx")
+CONFIG_NAMES = ("onnx_config.json", "laya_config.json", "rl_agent_config.json")
+
+
+def bundle_dir(model_id: str, revision=None) -> Path:
+    """A real, non-symlinked directory for a downloaded bundle.
+
+    ONNX Runtime validates that a model's external-data file stays inside the
+    model directory. The default Hugging Face cache stores snapshot entries as
+    symlinks into ``blobs/``, so that validation fails (seen on Windows);
+    downloading into a ``local_dir`` materialises regular files instead.
+    """
+    from huggingface_hub.constants import HF_HUB_CACHE
+
+    slug = str(model_id).replace("/", "--")
+    if revision:
+        slug += "@" + str(revision).replace("/", "--")
+    return Path(HF_HUB_CACHE) / "laya-onnx-bundles" / slug
+
+
+def find_graph(path: Path) -> Path:
+    for name in GRAPH_NAMES:
+        candidate = path / name
+        if candidate.is_file():
+            return candidate
+    raise FileNotFoundError(f"No ONNX graph (laya.onnx / model.onnx) under {path}")
+
+
+def find_config(path: Path) -> Path:
+    for name in CONFIG_NAMES:
+        candidate = path / name
+        if candidate.is_file():
+            return candidate
+    raise FileNotFoundError(f"No onnx_config.json / laya_config.json under {path}")
+
+
+def resolve_bundle(model_id_or_path, *, token=None, subfolder=None, revision=None) -> Path:
+    if subfolder:
+        part = PurePosixPath(subfolder)
+        if part.is_absolute() or ".." in part.parts:
+            raise ValueError("subfolder must be a relative path inside the model repository")
+    path = Path(model_id_or_path).expanduser()
+    if path.exists():
+        if path.suffix == ".mlpackage" or str(path).endswith(".mlpackage"):
+            raise ValueError(
+                f"{path} looks like a Core ML package (.mlpackage). "
+                "laya-onnx expects an ONNX bundle (laya.onnx + tokenizer/). "
+                "Convert with `laya-onnx convert` or point to receptron/laya-onnx."
+            )
+        if subfolder:
+            path /= subfolder
+        find_graph(path)
+        return path
+    value = str(model_id_or_path)
+    if value.startswith(("/", "./", "../", "~")) or isinstance(model_id_or_path, Path):
+        raise FileNotFoundError(f"Local model directory does not exist: {value}")
+    prefix = subfolder.rstrip("/") + "/" if subfolder else ""
+    patterns = [
+        prefix + name
+        for name in (
+            "laya.onnx",
+            "laya.onnx.data",
+            "model.onnx",
+            "model.onnx.data",
+            "laya_config.json",
+            "onnx_config.json",
+            "rl_agent_config.json",
+            "tokenizer/*",
+        )
+    ]
+    path = Path(snapshot_download(value, token=token, revision=revision, allow_patterns=patterns, local_dir=bundle_dir(value, revision)))
+    if subfolder:
+        path /= subfolder
+    find_graph(path)
+    return path

laya_onnx/inputs.py

@@ -0,0 +1,63 @@
+"""Dynamic batch collation. Pad sequence length to a multiple of 16."""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def pad_length(length: int, multiple: int = 16, max_length: int | None = None) -> int:
+    padded = ((length + multiple - 1) // multiple) * multiple
+    if max_length is not None:
+        padded = min(max(padded, multiple), max_length)
+    return max(padded, multiple if length else 1)
+
+
+def collate_items(
+    items,
+    pad_id,
+    *,
+    shape=None,
+    pad_to_multiple=16,
+    max_length=None,
+    marker_dtype=None,
+    ids_dtype=None,
+):
+    if not items:
+        raise ValueError("Cannot collate an empty batch")
+    if shape:
+        batch_size = int(shape.get("batch_size", len(items)))
+        max_length = int(shape.get("max_length", max_length or 512))
+        min_length = int(shape.get("min_length", pad_to_multiple))
+        max_options = int(shape.get("max_options", max(2, max(len(i["markers"]) for i in items))))
+        pad_to_multiple = min_length if min_length else pad_to_multiple
+    else:
+        batch_size = len(items)
+        max_options = max(2, max(len(i["markers"]) for i in items))
+
+    length = max(len(item["ids"]) for item in items)
+    if pad_to_multiple:
+        length = pad_length(length, pad_to_multiple, max_length)
+    if shape:
+        length = max(length, int(shape.get("min_length", length)))
+        if max_length is not None:
+            length = min(length, max_length)
+
+    id_dt = ids_dtype or np.int64
+    mk_dt = marker_dtype or np.int64
+    batch = {
+        "input_ids": np.full((batch_size, length), pad_id, dtype=id_dt),
+        "attention_mask": np.zeros((batch_size, length), dtype=id_dt),
+        "marker_pos": np.zeros((batch_size, max_options), dtype=mk_dt),
+        "marker_mask": np.zeros((batch_size, max_options), dtype=np.bool_),
+        "qtype": np.zeros((batch_size,), dtype=id_dt),
+    }
+    for i, item in enumerate(items[:batch_size]):
+        seq, markers = item["ids"], item["markers"]
+        seq = seq[:length]
+        batch["input_ids"][i, : len(seq)] = seq
+        batch["attention_mask"][i, : len(seq)] = 1
+        count = min(len(markers), max_options)
+        batch["marker_pos"][i, :count] = markers[:count]
+        batch["marker_mask"][i, :count] = True
+        batch["qtype"][i] = item["qtype"]
+    return batch

laya_onnx/optimize.py

@@ -0,0 +1,139 @@
+"""Offline ONNX graph optimization for a PC backend (Intel CPU / 16 GB).
+
+Order of work:
+1. Shape inference
+2. ONNX Runtime graph fusions (ORT_ENABLE_ALL) written back to disk
+3. Optional dynamic INT8 on MatMul/Gemm (best CPU win)
+4. Optional FP16 weights (useful on CUDA, usually slower on CPU)
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+
+def _find_graph(bundle: Path) -> Path:
+    for name in ("laya.onnx", "model.onnx"):
+        path = bundle / name if bundle.is_dir() else bundle
+        if bundle.is_file() and bundle.suffix == ".onnx":
+            return bundle
+        if path.is_file():
+            return path
+    raise FileNotFoundError(f"No ONNX graph under {bundle}")
+
+
+def infer_shapes(graph: Path) -> Path:
+    import onnx
+
+    model = onnx.load(str(graph), load_external_data=True)
+    try:
+        model = onnx.shape_inference.infer_shapes(model)
+        onnx.save(model, str(graph))
+    except Exception:
+        pass
+    return graph
+
+
+def fuse_graph(graph: Path, *, threads: int | None = None) -> Path:
+    import onnxruntime as ort
+
+    tmp = graph.with_suffix(".opt.onnx")
+    opts = ort.SessionOptions()
+    opts.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+    opts.optimized_model_filepath = str(tmp)
+    if threads:
+        opts.intra_op_num_threads = int(threads)
+        opts.inter_op_num_threads = 1
+    sess = ort.InferenceSession(str(graph), sess_options=opts, providers=["CPUExecutionProvider"])
+    del sess
+    if tmp.is_file() and tmp.stat().st_size > 0:
+        tmp.replace(graph)
+        extra = Path(str(tmp) + ".data")
+        dest_extra = Path(str(graph) + ".data")
+        if extra.is_file():
+            extra.replace(dest_extra)
+    return graph
+
+
+def quantize_dynamic_int8(graph: Path) -> Path:
+    from onnxruntime.quantization import QuantType, quantize_dynamic
+
+    out = graph.with_suffix(".int8.onnx")
+    quantize_dynamic(
+        str(graph),
+        str(out),
+        weight_type=QuantType.QInt8,
+        extra_options={"WeightSymmetric": True, "EnableSubgraph": True},
+    )
+    out.replace(graph)
+    return graph
+
+
+def convert_weights_fp16(graph: Path) -> Path:
+    import numpy as np
+    import onnx
+    from onnx import TensorProto, numpy_helper
+
+    model = onnx.load(str(graph), load_external_data=True)
+    for init in model.graph.initializer:
+        if init.data_type != TensorProto.FLOAT:
+            continue
+        array = numpy_helper.to_array(init).astype(np.float16)
+        new = numpy_helper.from_array(array, init.name)
+        init.CopyFrom(new)
+    onnx.save(model, str(graph))
+    return graph
+
+
+def optimize_bundle(source, output=None, *, precision="int8", threads=None, fuse=True):
+    source = Path(source).expanduser()
+    src_graph = _find_graph(source)
+    if output is None:
+        dest_graph = src_graph
+        dest_root = src_graph.parent
+    else:
+        output = Path(output).expanduser()
+        if output.suffix == ".onnx":
+            dest_graph = output
+            dest_root = output.parent
+            dest_root.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src_graph, dest_graph)
+        else:
+            if output.exists() and output.resolve() != source.resolve():
+                raise FileExistsError(f"Output already exists: {output}")
+            output.mkdir(parents=True, exist_ok=True)
+            if source.is_dir() and output.resolve() != source.resolve():
+                for item in source.iterdir():
+                    target = output / item.name
+                    if item.is_dir():
+                        shutil.copytree(item, target, dirs_exist_ok=True)
+                    else:
+                        shutil.copy2(item, target)
+            dest_graph = output / src_graph.name
+            if not dest_graph.is_file():
+                shutil.copy2(src_graph, dest_graph)
+            dest_root = output
+
+    infer_shapes(dest_graph)
+    if fuse:
+        fuse_graph(dest_graph, threads=threads)
+    if precision == "int8":
+        quantize_dynamic_int8(dest_graph)
+        infer_shapes(dest_graph)
+        if fuse:
+            fuse_graph(dest_graph, threads=threads)
+    elif precision == "fp16":
+        convert_weights_fp16(dest_graph)
+
+    manifest = dest_root / "onnx_config.json"
+    payload = {}
+    if manifest.is_file():
+        try:
+            payload = json.loads(manifest.read_text())
+        except json.JSONDecodeError:
+            payload = {}
+    payload.update({"format": payload.get("format", "laya-onnx"), "optimized": True, "precision": precision, "graph": dest_graph.name})
+    manifest.write_text(json.dumps(payload, indent=2) + "\n")
+    return dest_graph

laya_onnx/snake/__init__.py

@@ -0,0 +1 @@
+"""Local Snake demonstration for Laya ONNX."""

laya_onnx/snake/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

laya_onnx/snake/benchmark.py

@@ -0,0 +1,88 @@
+"""Headless throughput benchmark for the Snake policy (no display, no TTY)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import statistics
+import time
+
+from .game import SnakeGame
+from .policy import LayaPolicy
+
+
+def _percentile(sorted_samples, q):
+    if not sorted_samples:
+        return None
+    index = min(len(sorted_samples) - 1, int(len(sorted_samples) * q))
+    return sorted_samples[index]
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(prog="laya-onnx-snake benchmark", description=__doc__)
+    parser.add_argument("--model", help="Local model directory or an already cached Hub ID")
+    parser.add_argument("--prompt", choices=("compact", "detailed"), default="compact")
+    parser.add_argument("--optimize", action="store_true", help="Enable 16-token buckets")
+    parser.add_argument("--games", type=int, default=3)
+    parser.add_argument("--steps", type=int, default=200, help="Max steps per game")
+    parser.add_argument("--width", type=int, default=16)
+    parser.add_argument("--height", type=int, default=12)
+    parser.add_argument("--seed", type=int, default=7)
+    parser.add_argument("--initial-length", type=int, default=6)
+    parser.add_argument("--warmup", type=int, default=6, help="Warm-up decisions per game")
+    parser.add_argument("--unassisted", action="store_true")
+    args = parser.parse_args(argv)
+    if args.games < 1:
+        parser.error("--games must be positive")
+    if args.steps < 1:
+        parser.error("--steps must be positive")
+    if args.warmup < 0:
+        parser.error("--warmup must be non-negative")
+
+    policy = LayaPolicy(
+        args.model, guarded=not args.unassisted, prompt=args.prompt, optimize=args.optimize
+    )
+    samples = []
+    total_steps = deaths = wins = interventions = best = 0
+    started = time.perf_counter()
+    for game_index in range(args.games):
+        game = SnakeGame(args.width, args.height, args.seed + game_index, args.initial_length)
+        for _ in range(args.warmup):
+            if not game.alive or game.won:
+                break
+            game.step(policy.decide(game).executed)
+        played = 0
+        while played < args.steps and game.alive and not game.won:
+            decision = policy.decide(game)
+            samples.append(decision.inference_ms)
+            interventions += decision.intervened
+            game.step(decision.executed)
+            played += 1
+            total_steps += 1
+        best = max(best, game.score)
+        if game.won:
+            wins += 1
+        elif not game.alive:
+            deaths += 1
+    seconds = time.perf_counter() - started
+    samples.sort()
+    summary = {
+        "model": policy.metadata,
+        "games": args.games,
+        "steps": total_steps,
+        "seconds": round(seconds, 3),
+        "steps_per_second": round(total_steps / seconds, 2) if seconds else 0,
+        "best_score": best,
+        "wins": wins,
+        "deaths": deaths,
+        "interventions": interventions,
+        "mean_inference_ms": round(statistics.fmean(samples), 3) if samples else None,
+        "p50_inference_ms": round(_percentile(samples, 0.50), 3) if samples else None,
+        "p95_inference_ms": round(_percentile(samples, 0.95), 3) if samples else None,
+    }
+    print(json.dumps(summary, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

laya_onnx/snake/cli.py

@@ -0,0 +1,263 @@
+"""Run the live terminal demo. Also supports benchmark and export subcommands."""
+
+import argparse
+import json
+import sys
+import time
+from collections import deque
+from contextlib import nullcontext
+from datetime import datetime, timezone
+from pathlib import Path
+
+from rich.console import Console
+from rich.live import Live
+
+from .game import SnakeGame
+from .policy import LayaPolicy
+from .ui import BG, compose, layout_size
+
+
+class Keyboard:
+    """Non-blocking raw-key reader: cbreak on POSIX, msvcrt on Windows."""
+
+    def __enter__(self):
+        self._posix = sys.platform != "win32"
+        self.saved = None
+        if sys.stdin.isatty():
+            if self._posix:
+                import termios
+                import tty
+
+                self.fd = sys.stdin.fileno()
+                self.saved = termios.tcgetattr(self.fd)
+                tty.setcbreak(self.fd)
+            else:
+                import msvcrt  # noqa: F401  (present on Windows)
+
+                self.saved = True
+        return self
+
+    def read(self):
+        if not self.saved:
+            return ""
+        if self._posix:
+            import os
+            import select
+
+            if select.select([sys.stdin], [], [], 0)[0]:
+                return os.read(self.fd, 128).decode(errors="ignore")
+            return ""
+        import msvcrt
+
+        chars = []
+        while msvcrt.kbhit():
+            chars.append(msvcrt.getwch())
+        return "".join(chars)
+
+    def __exit__(self, *_):
+        if self._posix and self.saved:
+            import termios
+
+            termios.tcsetattr(self.fd, termios.TCSADRAIN, self.saved)
+
+
+def positive(value):
+    result = float(value)
+    if not 0 < result < float("inf"):
+        raise argparse.ArgumentTypeError("Expected a positive finite number")
+    return result
+
+
+def play(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="laya-onnx-snake",
+        description=__doc__,
+        epilog="Also: laya-onnx-snake benchmark --help | laya-onnx-snake export --help",
+    )
+    parser.add_argument("--model", help="Local model directory or an already cached Hub ID")
+    parser.add_argument("--prompt", choices=("compact", "detailed"), default="compact")
+    parser.add_argument(
+        "--optimize",
+        action="store_true",
+        help="Enable 16-token buckets",
+    )
+    parser.add_argument("--width", type=int, default=24)
+    parser.add_argument("--height", type=int, default=16)
+    parser.add_argument("--seed", type=int, default=7)
+    parser.add_argument("--initial-length", type=int, default=6)
+    parser.add_argument("--fps", type=positive, default=12)
+    parser.add_argument("--max-speed", action="store_true")
+    parser.add_argument("--duration", type=positive)
+    parser.add_argument("--steps", type=int)
+    parser.add_argument("--unassisted", action="store_true")
+    parser.add_argument("--record", type=Path)
+    parser.add_argument("--headless", action="store_true")
+    parser.add_argument("--no-alt-screen", action="store_true")
+    args = parser.parse_args(argv)
+    if args.steps is not None and args.steps < 1:
+        parser.error("--steps must be positive")
+    try:
+        game = SnakeGame(args.width, args.height, args.seed, args.initial_length)
+    except ValueError as error:
+        parser.error(str(error))
+    console = Console(style=f"on {BG}", highlight=False)
+    if not args.headless and not console.is_terminal:
+        parser.error("Interactive display needs a TTY. Use --headless.")
+    print("Loading local ONNX bundle; Hub only if the path is a repo id...", file=sys.stderr)
+    policy = LayaPolicy(
+        args.model, guarded=not args.unassisted, prompt=args.prompt, optimize=args.optimize
+    )
+    warm = SnakeGame(args.width, args.height, args.seed + 10000, args.initial_length)
+    for _ in range(6):
+        decision = policy.decide(warm)
+        warm.step(decision.executed)
+        if not warm.alive:
+            break
+    record = None
+    if args.record:
+        args.record.parent.mkdir(parents=True, exist_ok=True)
+        record = args.record.open("x")
+        record.write(
+            json.dumps(
+                {
+                    "type": "metadata",
+                    "format": "laya-onnx-snake-v1",
+                    "created_utc": datetime.now(timezone.utc).isoformat(),
+                    "model": policy.metadata,
+                    "settings": {
+                        k: str(v) if isinstance(v, Path) else v for k, v in vars(args).items()
+                    },
+                }
+            )
+            + "\n"
+        )
+    started = time.perf_counter()
+    stats = {
+        "hardware": policy.metadata["hardware"],
+        "guarded": policy.guarded,
+        "interventions": 0,
+        "best": 0,
+        "round": 1,
+        "paused": False,
+        "elapsed": 0,
+        "steps_per_second": 0,
+    }
+    calls = total_steps = deaths = 0
+    timestamps = deque(maxlen=60)
+    inference = []
+    displayed_board, displayed_decision = game.snapshot(), {}
+    live = (
+        Live(console=console, screen=not args.no_alt_screen, auto_refresh=False, vertical_overflow="crop")
+        if not args.headless
+        else None
+    )
+    try:
+        with Keyboard() as keys, live if live else nullcontext():
+            while True:
+                now = time.perf_counter()
+                if (args.duration and now - started >= args.duration) or (
+                    args.steps and total_steps >= args.steps
+                ):
+                    break
+                pressed = keys.read().lower()
+                if "q" in pressed or "\x03" in pressed:
+                    break
+                if " " in pressed:
+                    stats["paused"] = not stats["paused"]
+                if "+" in pressed:
+                    args.fps = min(240, args.fps + 2)
+                if "-" in pressed:
+                    args.fps = max(1, args.fps - 2)
+                if "r" in pressed:
+                    stats["round"] += 1
+                    game = SnakeGame(args.width, args.height, args.seed + stats["round"] - 1, args.initial_length)
+                    displayed_board, displayed_decision = game.snapshot(), {}
+                if stats["paused"]:
+                    stats["elapsed"] = now - started
+                    if live:
+                        live.update(compose(displayed_board, displayed_decision, stats).rich_text(), refresh=True)
+                    time.sleep(0.03)
+                    continue
+                minimum_width, minimum_height = layout_size(game.width, game.height)
+                if live and (console.width < minimum_width or console.height < minimum_height):
+                    live.update(
+                        f"Resize terminal to at least {minimum_width}x{minimum_height}. Q quits.",
+                        refresh=True,
+                    )
+                    time.sleep(0.1)
+                    continue
+                decision = policy.decide(game)
+                calls += 1
+                inference.append(decision.inference_ms)
+                stats["interventions"] += decision.intervened
+                shown = time.perf_counter()
+                timestamps.append(shown)
+                stats["elapsed"] = shown - started
+                stats["steps_per_second"] = (
+                    (len(timestamps) - 1) / (timestamps[-1] - timestamps[0]) if len(timestamps) > 1 else 0
+                )
+                stats["best"] = max(stats["best"], game.score)
+                board = game.snapshot()
+                displayed_board, displayed_decision = board, decision.to_dict()
+                if live:
+                    live.update(compose(board, decision.to_dict(), stats).rich_text(), refresh=True)
+                if record:
+                    record.write(
+                        json.dumps(
+                            {"type": "frame", "at": shown - started, "game": board, "decision": decision.to_dict(), "stats": dict(stats)},
+                            separators=(",", ":"),
+                        )
+                        + "\n"
+                    )
+                if not args.max_speed:
+                    remaining = 1 / args.fps - (time.perf_counter() - now)
+                    if remaining > 0:
+                        time.sleep(remaining)
+                game.step(decision.executed)
+                total_steps += 1
+                stats["best"] = max(stats["best"], game.score)
+                if not game.alive or game.won:
+                    deaths += not game.alive
+                    if args.unassisted:
+                        break
+                    if live:
+                        live.update(compose(game.snapshot(), {}, stats).rich_text(), refresh=True)
+                        time.sleep(1)
+                    stats["round"] += 1
+                    game = SnakeGame(args.width, args.height, args.seed + stats["round"] - 1, args.initial_length)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        elapsed = time.perf_counter() - started
+        summary = {
+            "steps": total_steps,
+            "inference_calls": calls,
+            "seconds": elapsed,
+            "steps_per_second": total_steps / elapsed if elapsed else 0,
+            "score": game.score,
+            "length": len(game.body),
+            "best_score": stats["best"],
+            "interventions": stats["interventions"],
+            "deaths": deaths,
+            "guarded": policy.guarded,
+            "network": "offline",
+            "mean_inference_ms": sum(inference) / len(inference) if inference else None,
+        }
+        if record:
+            record.write(json.dumps({"type": "end", "summary": summary, "game": game.snapshot()}) + "\n")
+            record.close()
+        print(json.dumps(summary, indent=2))
+    return 0
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv and argv[0] == "benchmark":
+        from .benchmark import main as benchmark
+
+        return benchmark(argv[1:])
+    if argv and argv[0] == "export":
+        from .replay import main as export
+
+        return export(argv[1:])
+    return play(argv)

laya_onnx/snake/game.py

@@ -0,0 +1,122 @@
+"""Deterministic, JSON-serializable Snake game used by the terminal demo.
+
+No third-party imports: the game must be runnable (and testable) with an
+empty environment. The board is a ``width`` x ``height`` grid with the head
+first in ``body``. ``seed`` fully determines the food sequence.
+"""
+
+from __future__ import annotations
+
+import random
+
+DIRECTIONS = ("UP", "DOWN", "LEFT", "RIGHT")
+DELTAS = {"UP": (0, -1), "DOWN": (0, 1), "LEFT": (-1, 0), "RIGHT": (1, 0)}
+MIN_SIZE = 4
+
+
+class SnakeGame:
+    def __init__(self, width: int = 24, height: int = 16, seed: int = 7, initial_length: int = 6):
+        if not isinstance(width, int) or not isinstance(height, int) or isinstance(width, bool) or isinstance(height, bool):
+            raise ValueError("width and height must be integers")
+        if width < MIN_SIZE or height < MIN_SIZE:
+            raise ValueError(f"width and height must be at least {MIN_SIZE}")
+        area = width * height
+        if (
+            not isinstance(initial_length, int)
+            or isinstance(initial_length, bool)
+            or not 2 <= initial_length < area
+        ):
+            raise ValueError(f"initial_length must be an integer between 2 and {area - 1}")
+        self.width = width
+        self.height = height
+        self.seed = seed
+        self.rng = random.Random(seed)
+        path = self._cycle()
+        start = path.index((width // 2, height // 2))
+        span = len(path)
+        # Head sits at the centre; the body trails backwards along the path.
+        self.body = [path[(start - i) % span] for i in range(initial_length)]
+        self.steps = 0
+        self.score = 0
+        self.alive = True
+        self.won = False
+        self.food = self._spawn()
+
+    # -- internals ---------------------------------------------------------
+    def _cycle(self):
+        """Boustrophedon Hamiltonian path over the grid (row by row)."""
+        path = []
+        for y in range(self.height):
+            xs = range(self.width) if y % 2 == 0 else range(self.width - 1, -1, -1)
+            for x in xs:
+                path.append((x, y))
+        return path
+
+    def _spawn(self):
+        occupied = set(self.body)
+        free = [
+            (x, y)
+            for y in range(self.height)
+            for x in range(self.width)
+            if (x, y) not in occupied
+        ]
+        if not free:
+            return None
+        return self.rng.choice(free)
+
+    def _target(self, direction):
+        dx, dy = DELTAS[direction]
+        hx, hy = self.body[0]
+        return hx + dx, hy + dy
+
+    # -- public API --------------------------------------------------------
+    def legal(self, direction) -> bool:
+        """True if ``direction`` can be played without dying. Pure."""
+        if not self.alive or self.won or direction not in DELTAS:
+            return False
+        nx, ny = self._target(direction)
+        if not (0 <= nx < self.width and 0 <= ny < self.height):
+            return False
+        grows = self.food is not None and (nx, ny) == self.food
+        # Without growth the tail cell vacates, so stepping onto it is safe.
+        blocked = set(self.body if grows else self.body[:-1])
+        return (nx, ny) not in blocked
+
+    def step(self, direction):
+        """Advance one tick. Returns ``ok`` / ``eat`` / ``dead`` / ``over``."""
+        if direction not in DELTAS:
+            raise ValueError(f"direction must be one of {DIRECTIONS}, got {direction!r}")
+        if not self.alive:
+            return "dead"
+        if self.won:
+            return "over"
+        if not self.legal(direction):
+            self.alive = False
+            return "dead"
+        nx, ny = self._target(direction)
+        eats = self.food is not None and (nx, ny) == self.food
+        self.body.insert(0, (nx, ny))
+        if eats:
+            self.score += 1
+            self.food = self._spawn()
+        else:
+            self.body.pop()
+        self.steps += 1
+        if self.food is None or len(self.body) >= self.width * self.height:
+            self.won = True
+        return "eat" if eats else "ok"
+
+    def snapshot(self) -> dict:
+        """JSON-serializable view of the current state."""
+        return {
+            "width": self.width,
+            "height": self.height,
+            "head": list(self.body[0]),
+            "body": [list(cell) for cell in self.body],
+            "food": list(self.food) if self.food is not None else None,
+            "score": self.score,
+            "length": len(self.body),
+            "steps": self.steps,
+            "alive": self.alive,
+            "won": self.won,
+        }

laya_onnx/snake/policy.py

@@ -0,0 +1,142 @@
+"""Laya-backed Snake policy.
+
+Each tick builds a typed System-1 decision: the local ONNX Agent is asked
+(a ``choice`` over UP/DOWN/LEFT/RIGHT) and its answer becomes the move. In
+``guarded`` mode an illegal move is replaced by the best legal alternative
+and the tick is counted as an intervention.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import time
+
+from .. import load
+from .game import DIRECTIONS
+
+
+def _hardware() -> str:
+    chip = platform.processor() or platform.machine() or "cpu"
+    return f"{platform.system()} {chip} x{os.cpu_count() or 1}"
+
+
+class Decision:
+    def __init__(self, chosen, executed, intervened, probabilities, inference_ms, confidence=None):
+        self.chosen = chosen
+        self.executed = executed
+        self.intervened = int(intervened)
+        self.probabilities = probabilities
+        self.inference_ms = float(inference_ms)
+        self.confidence = confidence
+
+    def to_dict(self) -> dict:
+        payload = {
+            "chosen": self.chosen,
+            "executed": self.executed,
+            "intervened": bool(self.intervened),
+            "probabilities": self.probabilities,
+            "inference_ms": round(self.inference_ms, 3),
+        }
+        if self.confidence is not None:
+            payload["confidence"] = self.confidence
+        return payload
+
+
+class LayaPolicy:
+    def __init__(
+        self,
+        model=None,
+        *,
+        guarded: bool = True,
+        prompt: str = "compact",
+        optimize: bool = False,
+        providers: str = "cpu",
+        threads=None,
+    ):
+        if prompt not in ("compact", "detailed"):
+            raise ValueError("prompt must be 'compact' or 'detailed'")
+        self.model_id = str(model or "receptron/laya-onnx")
+        self.guarded = bool(guarded)
+        self.prompt = prompt
+        self.optimize = bool(optimize)
+        # "optimize" keeps 16-token padding buckets; otherwise skip padding for latency.
+        self.agent = load(
+            model or "receptron/laya-onnx",
+            providers=providers,
+            threads=threads,
+            pad_to_multiple=16 if self.optimize else None,
+        )
+        self.metadata = {
+            "hardware": _hardware(),
+            "model": self.model_id,
+            "providers": self.agent.providers,
+            "prompt": self.prompt,
+            "optimized": self.optimize,
+        }
+
+    # -- prompt building ---------------------------------------------------
+    def _state(self, game) -> str:
+        snap = game.snapshot()
+        head, food = snap["head"], snap["food"]
+        if self.prompt == "detailed":
+            rows = []
+            body = {tuple(cell) for cell in snap["body"]}
+            for y in range(snap["height"]):
+                line = []
+                for x in range(snap["width"]):
+                    point = (x, y)
+                    if point == tuple(head):
+                        line.append("#")
+                    elif food is not None and point == tuple(food):
+                        line.append("*")
+                    elif point in body:
+                        line.append("o")
+                    else:
+                        line.append(".")
+                rows.append("".join(line))
+            grid = "\n".join(rows)
+            return (
+                f"Snake {snap['width']}x{snap['height']}\n{grid}\n"
+                f"#=head o=body *=food head={head} food={food} "
+                f"length={snap['length']} score={snap['score']}"
+            )
+        return (
+            f"Snake {snap['width']}x{snap['height']} head={head} food={food} "
+            f"length={snap['length']} score={snap['score']} alive={snap['alive']}"
+        )
+
+    def _questions(self) -> dict:
+        return {
+            "move": {
+                "type": "choice",
+                "instructions": (
+                    "Pick the snake's next move. Move toward the food and never "
+                    "hit the wall or the snake's own body."
+                ),
+                "criteria": {direction: direction.lower() for direction in DIRECTIONS},
+            }
+        }
+
+    # -- decision ----------------------------------------------------------
+    def decide(self, game) -> Decision:
+        started = time.perf_counter()
+        out = self.agent.predict(self._state(game), self._questions())
+        inference_ms = (time.perf_counter() - started) * 1000.0
+        answer = (out.get("answers") or {}).get("move") or {}
+        probabilities = answer.get("probabilities") or {}
+        ranked = sorted(
+            DIRECTIONS, key=lambda d: float(probabilities.get(d, 0.0)), reverse=True
+        )
+        chosen = answer.get("choice")
+        if chosen not in DIRECTIONS:
+            chosen = ranked[0]
+        executed, intervened = chosen, 0
+        if self.guarded and not game.legal(chosen):
+            fallback = next((d for d in ranked if game.legal(d)), None)
+            if fallback is None:
+                fallback = next((d for d in DIRECTIONS if game.legal(d)), chosen)
+            executed, intervened = fallback, 1
+        return Decision(
+            chosen, executed, intervened, probabilities, inference_ms, answer.get("confidence")
+        )

laya_onnx/snake/replay.py

@@ -0,0 +1,140 @@
+"""Replay or export a recorded Snake run (the JSONL written by ``--record``)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+_TEMPLATE = """<!DOCTYPE html>
+<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width,initial-scale=1"/>
+<title>laya-onnx snake replay</title>
+<style>
+html,body{margin:0;background:#070b12;color:#e2e8f0;font-family:system-ui,sans-serif}
+.wrap{max-width:680px;margin:0 auto;padding:20px}
+canvas{display:block;width:100%;max-width:640px;background:#020617;border:2px solid #34d399;border-radius:10px}
+.row{display:flex;gap:10px;align-items:center;margin-top:10px}
+button{padding:8px 12px;border:0;border-radius:8px;background:#334155;color:#fff}
+#play{background:#34d399;color:#052e16;font-weight:700}
+#st{font-size:13px;color:#94a3b8;margin-top:8px}
+</style></head><body><div class="wrap">
+<h1>Snake replay</h1><p id="model"></p>
+<canvas id="c" width="640" height="420"></canvas>
+<div class="row"><button id="play">Pause</button><button id="reset">Reset</button>
+<input id="seek" type="range" min="0" value="0" style="flex:1"/></div>
+<div id="st">-</div>
+<script>
+var FRAMES=__FRAMES__, DECISIONS=__DECISIONS__, MODEL=__MODEL__;
+var i=0, playing=true, timer=null, c=document.getElementById("c"), ctx=c.getContext("2d");
+document.getElementById("model").textContent="model: "+(MODEL.model||"?")+"   frames: "+FRAMES.length;
+function draw(){
+  var g=FRAMES[i]||{}, W=g.width||1, H=g.height||1, cw=c.width/W, ch=c.height/H;
+  ctx.fillStyle="#020617"; ctx.fillRect(0,0,c.width,c.height);
+  ctx.strokeStyle="#1e293b";
+  for(var x=0;x<=W;x++){ctx.beginPath();ctx.moveTo(x*cw,0);ctx.lineTo(x*cw,c.height);ctx.stroke();}
+  for(var y=0;y<=H;y++){ctx.beginPath();ctx.moveTo(0,y*ch);ctx.lineTo(c.width,y*ch);ctx.stroke();}
+  var f=g.food; if(f){ctx.fillStyle="#fbbf24";ctx.fillRect(f[0]*cw+2,f[1]*ch+2,cw-4,ch-4);}
+  var b=g.body||[];
+  for(var k=b.length-1;k>=0;k--){ctx.fillStyle=k===0?"#6ee7b7":"#059669";ctx.fillRect(b[k][0]*cw+2,b[k][1]*ch+2,cw-4,ch-4);}
+  var d=DECISIONS[i]||{};
+  document.getElementById("st").textContent="frame "+(i+1)+"/"+FRAMES.length+"  move "+(d.executed||"-")+(d.intervened?" (guarded)":"")+"  score "+(g.score||0)+"  len "+(g.length||0);
+  document.getElementById("seek").value=i;
+}
+function tick(){if(!playing)return; i=(i+1)%Math.max(FRAMES.length,1); draw();}
+function start(){if(timer)return; playing=true; document.getElementById("play").textContent="Pause"; timer=setInterval(tick,120);}
+function stop(){playing=false; document.getElementById("play").textContent="Play"; clearInterval(timer); timer=null;}
+document.getElementById("play").onclick=function(){playing?stop():start();};
+document.getElementById("reset").onclick=function(){i=0;draw();};
+document.getElementById("seek").oninput=function(e){i=Number(e.target.value);draw();};
+var s=document.getElementById("seek"); s.max=Math.max(FRAMES.length-1,0);
+draw(); start();
+</script></div></body></html>
+"""
+
+
+def _read_record(path: Path):
+    meta, frames, end = None, [], None
+    with path.open(encoding="utf-8") as handle:
+        for lineno, line in enumerate(handle, 1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise SystemExit(f"{path}: line {lineno} is not valid JSON: {exc}")
+            kind = record.get("type")
+            if kind == "metadata":
+                meta = record
+            elif kind == "frame":
+                frames.append(record)
+            elif kind == "end":
+                end = record
+    if meta is None:
+        raise SystemExit(f"{path}: missing metadata header (is this a --record file?)")
+    return meta, frames, end
+
+
+def _render_html(meta: dict, frames: list) -> str:
+    games = [frame.get("game") for frame in frames]
+    decisions = [frame.get("decision") for frame in frames]
+    return (
+        _TEMPLATE.replace("__FRAMES__", json.dumps(games))
+        .replace("__DECISIONS__", json.dumps(decisions))
+        .replace("__MODEL__", json.dumps(meta.get("model") or {}))
+    )
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(prog="laya-onnx-snake export", description=__doc__)
+    parser.add_argument("record", type=Path, help="JSONL file written by --record")
+    parser.add_argument("--limit", type=int, help="Show only the first N frames in the table")
+    parser.add_argument("--html", type=Path, help="Write a self-contained animated HTML replay")
+    parser.add_argument("--json", action="store_true", help="Print the summary JSON only")
+    args = parser.parse_args(argv)
+    if not args.record.is_file():
+        parser.error(f"no such record: {args.record}")
+
+    meta, frames, end = _read_record(args.record)
+    summary = (end or {}).get("summary") or {}
+    if args.json:
+        print(json.dumps(summary, indent=2))
+        return 0
+
+    console = Console()
+    model = (meta.get("model") or {}).get("model", "?")
+    console.print(
+        f"[bold]{args.record}[/]  [dim]{meta.get('format', '?')}[/]  "
+        f"model={model}  frames={len(frames)}  created={meta.get('created_utc', '?')}"
+    )
+    if summary:
+        console.print(json.dumps(summary, indent=2))
+    shown = frames if args.limit is None else frames[: args.limit]
+    if shown:
+        table = Table(title="frames")
+        for column in ("at", "executed", "chosen", "guarded", "score", "length"):
+            table.add_column(column)
+        for frame in shown:
+            decision = frame.get("decision") or {}
+            game = frame.get("game") or {}
+            table.add_row(
+                f"{float(frame.get('at', 0.0)):.2f}",
+                str(decision.get("executed", "")),
+                str(decision.get("chosen", "")),
+                "yes" if decision.get("intervened") else "",
+                str(game.get("score", "")),
+                str(game.get("length", "")),
+            )
+        console.print(table)
+    if args.html:
+        args.html.parent.mkdir(parents=True, exist_ok=True)
+        args.html.write_text(_render_html(meta, frames), encoding="utf-8")
+        console.print(f"[green]wrote[/] {args.html}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

laya_onnx/snake/ui.py

@@ -0,0 +1,103 @@
+"""Rich rendering for the terminal Snake demo.
+
+``compose`` returns a small wrapper whose ``rich_text()`` yields a
+``rich.text.Text`` renderable, matching how ``snake/cli.py`` drives
+``rich.live.Live``. Kept import-light so it can be unit-tested headlessly.
+"""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+BG = "black"
+
+HEAD_GLYPH = "█"
+BODY_GLYPH = "▪"
+FOOD_GLYPH = "◆"
+EMPTY_GLYPH = "·"
+
+HEAD_STYLE = "bold bright_green"
+BODY_STYLE = "green"
+FOOD_STYLE = "bold yellow"
+EMPTY_STYLE = "grey35"
+
+
+def layout_size(width: int, height: int) -> tuple[int, int]:
+    """Minimum console (columns, rows) for a board of ``width`` x ``height``."""
+    columns = max(2 * int(width) + 2, 48)
+    rows = int(height) + 4
+    return columns, rows
+
+
+def _cells(board: dict):
+    width = int(board.get("width") or 0)
+    height = int(board.get("height") or 0)
+    body = [tuple(cell) for cell in (board.get("body") or [])]
+    head = tuple(board["head"]) if board.get("head") else (body[0] if body else None)
+    food = tuple(board["food"]) if board.get("food") else None
+    occupied = set(body)
+    grid = []
+    for y in range(height):
+        row = []
+        for x in range(width):
+            point = (x, y)
+            if head is not None and point == head:
+                row.append((HEAD_GLYPH, HEAD_STYLE))
+            elif point in occupied:
+                row.append((BODY_GLYPH, BODY_STYLE))
+            elif food is not None and point == food:
+                row.append((FOOD_GLYPH, FOOD_STYLE))
+            else:
+                row.append((EMPTY_GLYPH, EMPTY_STYLE))
+        grid.append(row)
+    return grid
+
+
+class Frame:
+    def __init__(self, board: dict, decision: dict, stats: dict):
+        self.board = board or {}
+        self.decision = decision or {}
+        self.stats = stats or {}
+
+    def rich_text(self) -> Text:
+        text = Text(style=f"on {BG}")
+        for y, row in enumerate(_cells(self.board)):
+            if y:
+                text.append("\n")
+            for x, (glyph, style) in enumerate(row):
+                text.append(glyph, style=style)
+                if x < len(row) - 1:
+                    text.append(" ")
+        board = self.board
+        stats = self.stats
+        decision = self.decision
+        text.append("\n\n")
+        text.append(
+            "score {score}  best {best}  len {length}  steps {steps}  "
+            "{sps:.1f}/s  guarded {guarded}  int {interventions}".format(
+                score=board.get("score", 0),
+                best=stats.get("best", 0),
+                length=board.get("length", 0),
+                steps=board.get("steps", 0),
+                sps=float(stats.get("steps_per_second", 0.0) or 0.0),
+                guarded=stats.get("guarded", "-"),
+                interventions=stats.get("interventions", 0),
+            ),
+            style="dim",
+        )
+        text.append("\n")
+        guarded = "  [guarded]" if decision.get("intervened") else ""
+        text.append(
+            "next {executed}  model {chosen}{guarded}  {ms:.2f} ms".format(
+                executed=decision.get("executed", "-"),
+                chosen=decision.get("chosen", "-"),
+                guarded=guarded,
+                ms=float(decision.get("inference_ms", 0.0) or 0.0),
+            ),
+            style="cyan",
+        )
+        return text
+
+
+def compose(board: dict, decision: dict, stats: dict) -> Frame:
+    return Frame(board, decision, stats)

laya_onnx/tokenizer.py

@@ -0,0 +1,27 @@
+"""Load the checkpoint tokenizer without Transformers or torch."""
+
+import json
+from pathlib import Path
+
+from tokenizers import Tokenizer as Backend
+
+
+class Tokenizer:
+    def __init__(self, path):
+        path = Path(path)
+        self.backend = Backend.from_file(str(path / "tokenizer.json"))
+        self.backend.no_padding()
+        self.backend.no_truncation()
+        config = json.loads((path / "tokenizer_config.json").read_text())
+        for name in ("cls_token", "sep_token", "pad_token", "mask_token"):
+            value = config.get(name)
+            if isinstance(value, dict):
+                value = value.get("content")
+            token_id = self.backend.token_to_id(value) if isinstance(value, str) else None
+            if token_id is None:
+                raise ValueError(f"Tokenizer is missing a valid {name}")
+            setattr(self, name, value)
+            setattr(self, name + "_id", token_id)
+
+    def __call__(self, text, add_special_tokens=False):
+        return {"input_ids": self.backend.encode(text, add_special_tokens=add_special_tokens).ids}

laya_onnx/torch_model.py

@@ -0,0 +1,121 @@
+"""Tiny ModernBERT-style DecisionModel used for export and parity tests."""
+
+from __future__ import annotations
+
+import math
+
+import torch
+from torch import nn
+
+
+class EncoderConfig:
+    def __init__(self, data: dict):
+        self.hidden_size = int(data["hidden_size"])
+        self.intermediate_size = int(data.get("intermediate_size", self.hidden_size * 4))
+        self.vocab_size = int(data["vocab_size"])
+        self.num_hidden_layers = int(data["num_hidden_layers"])
+        self.num_attention_heads = int(data["num_attention_heads"])
+        self.local_attention = int(data.get("local_attention", 128))
+        self.global_attn_every_n_layers = int(data.get("global_attn_every_n_layers", 3))
+        self.max_position_embeddings = int(data.get("max_position_embeddings", 512))
+        self.layer_norm_eps = float(data.get("layer_norm_eps", 1e-5))
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(data)
+
+
+class EncoderLayer(nn.Module):
+    def __init__(self, cfg: EncoderConfig, global_attn: bool):
+        super().__init__()
+        self.global_attn = global_attn
+        self.local_attention = cfg.local_attention
+        self.n_heads = cfg.num_attention_heads
+        self.head_dim = cfg.hidden_size // cfg.num_attention_heads
+        self.in_proj = nn.Linear(cfg.hidden_size, 3 * cfg.hidden_size, bias=True)
+        self.out_proj = nn.Linear(cfg.hidden_size, cfg.hidden_size, bias=True)
+        self.norm1 = nn.LayerNorm(cfg.hidden_size, eps=cfg.layer_norm_eps)
+        self.norm2 = nn.LayerNorm(cfg.hidden_size, eps=cfg.layer_norm_eps)
+        self.ff = nn.Sequential(
+            nn.Linear(cfg.hidden_size, cfg.intermediate_size),
+            nn.GELU(),
+            nn.Linear(cfg.intermediate_size, cfg.hidden_size),
+        )
+
+    def forward(self, hidden, attention_mask):
+        b, t, c = hidden.shape
+        x = self.norm1(hidden)
+        qkv = self.in_proj(x).view(b, t, 3, self.n_heads, self.head_dim)
+        q, k, v = qkv.unbind(2)
+        q = q.transpose(1, 2)
+        k = k.transpose(1, 2)
+        v = v.transpose(1, 2)
+        scale = 1.0 / math.sqrt(self.head_dim)
+        scores = torch.matmul(q, k.transpose(-2, -1)) * scale
+        pad = attention_mask.eq(0).unsqueeze(1).unsqueeze(2)
+        scores = scores.masked_fill(pad, torch.finfo(scores.dtype).min)
+        if not self.global_attn:
+            idx = torch.arange(t, device=hidden.device)
+            dist = (idx[None, :] - idx[:, None]).abs()
+            local = dist.gt(self.local_attention // 2).unsqueeze(0).unsqueeze(0)
+            scores = scores.masked_fill(local, torch.finfo(scores.dtype).min)
+        attn = torch.softmax(scores, dim=-1)
+        ctx = torch.matmul(attn, v).transpose(1, 2).contiguous().view(b, t, c)
+        hidden = hidden + self.out_proj(ctx)
+        hidden = hidden + self.ff(self.norm2(hidden))
+        return hidden
+
+
+class Encoder(nn.Module):
+    def __init__(self, cfg: EncoderConfig, max_len: int):
+        super().__init__()
+        self.embed = nn.Embedding(cfg.vocab_size, cfg.hidden_size)
+        self.pos = nn.Embedding(max(max_len, cfg.max_position_embeddings), cfg.hidden_size)
+        self.norm = nn.LayerNorm(cfg.hidden_size, eps=cfg.layer_norm_eps)
+        layers = []
+        for i in range(cfg.num_hidden_layers):
+            global_attn = ((i + 1) % cfg.global_attn_every_n_layers) == 0 or i == 0
+            layers.append(EncoderLayer(cfg, global_attn))
+        self.layers = nn.ModuleList(layers)
+
+    def forward(self, input_ids, attention_mask):
+        positions = torch.arange(input_ids.shape[1], device=input_ids.device)
+        hidden = self.embed(input_ids) + self.pos(positions)[None, :, :]
+        hidden = self.norm(hidden)
+        for layer in self.layers:
+            hidden = layer(hidden, attention_mask)
+        return hidden
+
+
+class DecisionModel(nn.Module):
+    def __init__(self, encoder_cfg: dict, agent_cfg: dict, max_len: int = 512):
+        super().__init__()
+        if isinstance(encoder_cfg, EncoderConfig):
+            enc = encoder_cfg
+        else:
+            enc = EncoderConfig(encoder_cfg)
+        self.max_len = int(agent_cfg.get("max_len", max_len))
+        self.encoder = Encoder(enc, self.max_len)
+        hidden = enc.hidden_size
+        layers = int(agent_cfg.get("head_layers", 2))
+        blocks = []
+        for _ in range(max(1, layers)):
+            blocks.extend([nn.Linear(hidden, hidden), nn.GELU()])
+        self.option_mlp = nn.Sequential(*blocks)
+        self.option_out = nn.Linear(hidden, 1)
+        self.act_mlp = nn.Sequential(nn.Linear(hidden, hidden), nn.GELU(), nn.Linear(hidden, 2))
+        self.qtype_embed = nn.Embedding(4, hidden)
+
+    def forward(self, input_ids, attention_mask, marker_pos, marker_mask, qtype):
+        hidden = self.encoder(input_ids.long(), attention_mask)
+        gather_index = marker_pos.long().clamp(min=0, max=hidden.shape[1] - 1)
+        gather_index = gather_index.unsqueeze(-1).expand(-1, -1, hidden.shape[-1])
+        option_h = hidden.gather(1, gather_index)
+        option_h = option_h + self.qtype_embed(qtype.long().clamp(0, 3)).unsqueeze(1)
+        logits = self.option_out(self.option_mlp(option_h)).squeeze(-1)
+        invalid = marker_mask.eq(0) if marker_mask.dtype != torch.bool else ~marker_mask.bool()
+        logits = logits.masked_fill(invalid, -1e4)
+        pooled = (option_h * (~invalid).unsqueeze(-1).to(option_h.dtype)).sum(1)
+        denom = (~invalid).sum(1).clamp(min=1).unsqueeze(-1).to(option_h.dtype)
+        act = self.act_mlp(pooled / denom)
+        return logits, act

laya_onnx/ultrafast/__init__.py

@@ -0,0 +1,7 @@
+"""NL-goal + DOM loop using local Laya ONNX (jev-ultrafast shape)."""
+
+from .agent import UltrafastAgent
+from .ops import OPS
+from .snapshot import Element, PageSnapshot
+
+__all__ = ["UltrafastAgent", "OPS", "Element", "PageSnapshot"]

laya_onnx/ultrafast/agent.py

@@ -0,0 +1,80 @@
+"""Goal-driven DOM loop. Decisions from local Laya ONNX."""
+from __future__ import annotations
+import os
+from typing import Iterator
+from .browser import open_browser
+from .ops import MAX_STEPS
+from .policy import decide
+
+def _heuristic_text(goal: str, el_name: str) -> str:
+    low = (el_name + " " + goal).lower()
+    if ("zurich" in goal.lower() or "zürich" in goal.lower()) and ("from" in low or "origin" in low or "depart" in low):
+        return "Zurich"
+    if "london" in goal.lower() and ("to" in low or "dest" in low):
+        return "London"
+    return goal.replace(" to ", " | ").split("|")[-1].strip(" ,.")[:40]
+
+def _type_text(goal: str, el_name: str) -> str:
+    key = os.environ.get("TEXT_MODEL_API_KEY")
+    base = os.environ.get("TEXT_MODEL_BASE_URL")
+    if not key and not base:
+        return _heuristic_text(goal, el_name)
+    try:
+        import json, urllib.request
+        url = (base or "https://openrouter.ai/api/v1").rstrip("/") + "/chat/completions"
+        body = json.dumps({"model": os.environ.get("TEXT_MODEL", "openai/gpt-4.1-mini"), "messages": [{"role": "system", "content": "Return only the exact string to type."}, {"role": "user", "content": f"Goal: {goal}\nField: {el_name}"}], "max_tokens": 32}).encode()
+        req = urllib.request.Request(url, data=body, headers={"Content-Type": "application/json", "Authorization": f"Bearer {key or ''}"})
+        with urllib.request.urlopen(req, timeout=20) as resp:
+            return json.loads(resp.read().decode())["choices"][0]["message"]["content"].strip().strip('"')
+    except Exception:
+        return _heuristic_text(goal, el_name)
+
+class UltrafastAgent:
+    def __init__(self, url: str, goal: str, *, model: str = "receptron/laya-onnx", providers: str = "cpu", fixture: str | None = None, headless: bool = True, laya=None, deterministic: bool = False):
+        self.url, self.goal, self.fixture, self.headless = url, goal, fixture, headless
+        self.deterministic = bool(deterministic)
+        if laya is None:
+            from laya_onnx import load
+            self.laya = load(model, providers=providers, deterministic=self.deterministic)
+        else:
+            self.laya = laya
+        self.browser = None
+    def __enter__(self):
+        self.browser = open_browser(self.url, fixture=self.fixture, headless=self.headless)
+        return self
+    def __exit__(self, *exc):
+        if self.browser:
+            self.browser.close()
+        return False
+    def run(self, max_steps: int = MAX_STEPS) -> Iterator[dict]:
+        if self.browser is None:
+            self.browser = open_browser(self.url, fixture=self.fixture, headless=self.headless)
+        for step in range(max_steps):
+            snap = self.browser.snapshot()
+            decision = decide(self.laya, snap, self.goal, argmax=self.deterministic)
+            op, target, text, status = decision["op"], decision["target"], None, "ok"
+            try:
+                if op == "CLICK" and target is not None:
+                    self.browser.click(target)
+                elif op == "TYPE_TEXT" and target is not None:
+                    el = snap.by_index(target)
+                    name = el.name if el else ""
+                    text = (
+                        _heuristic_text(self.goal, name)
+                        if self.deterministic
+                        else _type_text(self.goal, name)
+                    )
+                    self.browser.type_text(target, text)
+                elif op == "SELECT" and target is not None:
+                    self.browser.select(target)
+                elif op in ("SCROLL_DOWN", "SCROLL_UP"):
+                    self.browser.scroll(op)
+                elif op == "WAIT":
+                    self.browser.wait(400)
+                elif op in ("DONE", "BLOCKED"):
+                    yield {"step": step, "op": op, "target": target, "status": op.lower(), "url": snap.url, **decision}
+                    return
+            except Exception as exc:
+                status = f"error:{exc}"
+            yield {"step": step, "op": op, "target": target, "text": text, "status": status, "url": snap.url, "ready": decision["ready"]}
+        yield {"step": max_steps, "op": "BLOCKED", "status": "max_steps", "url": self.url}

laya_onnx/ultrafast/browser.py

@@ -0,0 +1,57 @@
+"""Playwright driver with a fixture/mock fallback."""
+from __future__ import annotations
+import json
+from pathlib import Path
+from .snapshot import PageSnapshot, SNAPSHOT_JS
+
+class MockBrowser:
+    def __init__(self, fixture):
+        self.snap = fixture if isinstance(fixture, PageSnapshot) else PageSnapshot.from_dict(fixture)
+        self.actions = []
+    def snapshot(self):
+        return self.snap
+    def click(self, index: int):
+        self.actions.append({"op": "CLICK", "target": index})
+    def type_text(self, index: int, text: str):
+        el = self.snap.by_index(index)
+        if el:
+            el.value = text
+        self.actions.append({"op": "TYPE_TEXT", "target": index, "text": text})
+    def select(self, index: int):
+        self.actions.append({"op": "SELECT", "target": index})
+    def scroll(self, direction: str):
+        self.actions.append({"op": "SCROLL", "direction": direction})
+    def wait(self, ms: int = 400):
+        self.actions.append({"op": "WAIT", "ms": ms})
+    def close(self):
+        pass
+
+class PlaywrightBrowser:
+    def __init__(self, url: str, headless: bool = True):
+        from playwright.sync_api import sync_playwright
+        self._pw = sync_playwright().start()
+        self._browser = self._pw.chromium.launch(headless=headless)
+        self._page = self._browser.new_page()
+        self._page.goto(url, wait_until="domcontentloaded", timeout=30000)
+    def snapshot(self):
+        return PageSnapshot.from_dict(self._page.evaluate(SNAPSHOT_JS))
+    def click(self, index: int):
+        self._page.evaluate("(i) => { const n = document.querySelectorAll('a,button,input,select,textarea,[role=button],[role=link]')[i]; n && n.click(); }", int(index))
+    def type_text(self, index: int, text: str):
+        self._page.evaluate("([i, t]) => { const n = document.querySelectorAll('input,textarea,select,[role=textbox]')[i]; if (n) { n.focus(); n.value = t; n.dispatchEvent(new Event('input', {bubbles:true})); } }", [int(index), text])
+    def select(self, index: int):
+        self.click(index)
+    def scroll(self, direction: str):
+        self._page.mouse.wheel(0, 600 if direction == "SCROLL_DOWN" else -600)
+    def wait(self, ms: int = 400):
+        self._page.wait_for_timeout(ms)
+    def close(self):
+        self._browser.close(); self._pw.stop()
+
+def open_browser(url: str, *, fixture=None, headless: bool = True):
+    if fixture:
+        return MockBrowser(json.loads(Path(fixture).read_text()))
+    try:
+        return PlaywrightBrowser(url, headless=headless)
+    except Exception as exc:
+        raise RuntimeError("Playwright missing. pip install -e '.[ultrafast]' && playwright install chromium, or pass --fixture") from exc

laya_onnx/ultrafast/cli.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+import argparse, json
+from .agent import UltrafastAgent
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(prog="laya-onnx-ultrafast")
+    p.add_argument("--url", default="https://example.com")
+    p.add_argument("--goal", required=True)
+    p.add_argument("--model", default="receptron/laya-onnx")
+    p.add_argument("--providers", default="cpu")
+    p.add_argument("--fixture")
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--max-steps", type=int, default=20)
+    p.add_argument("--headed", action="store_true")
+    p.add_argument("--deterministic", action="store_true")
+    args = p.parse_args(argv)
+    if args.dry_run and not args.fixture:
+        raise SystemExit("--dry-run needs --fixture")
+    with UltrafastAgent(args.url, args.goal, model=args.model, providers=args.providers, fixture=args.fixture, headless=not args.headed, deterministic=args.deterministic) as agent:
+        for step in agent.run(max_steps=args.max_steps):
+            print(json.dumps(step, ensure_ascii=False))
+            if step.get("op") in ("DONE", "BLOCKED") or step.get("status") == "max_steps":
+                break
+    return 0
+
+if __name__ == "__main__":
+    raise SystemExit(main())

laya_onnx/ultrafast/ops.py

@@ -0,0 +1,3 @@
+OPS = ("CLICK", "TYPE_TEXT", "SELECT", "SCROLL_DOWN", "SCROLL_UP", "WAIT", "DONE", "BLOCKED")
+MAX_ELEMENTS = 250
+MAX_STEPS = 60

laya_onnx/ultrafast/policy.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from .ops import OPS
+from .snapshot import PageSnapshot
+
+def questions(snap: PageSnapshot, goal: str) -> dict:
+    labels = [el.label() for el in snap.elements[:32]] or ["(none)"]
+    return {
+        "op": {"type": "choice", "instructions": f"Goal: {goal}\nURL: {snap.url}\nPick the next browser operation.", "criteria": list(OPS)},
+        "ready": {"type": "noul", "instructions": f"Is the goal already satisfied? Goal: {goal}. Text: {snap.text[:400]}"},
+        "target": {"type": "choice", "instructions": f"Goal: {goal}. Which control?", "criteria": labels[:16]},
+    }
+
+def decide(agent, snap: PageSnapshot, goal: str, *, argmax: bool = False) -> dict:
+    state = f"GOAL\n{goal}\n\nPAGE {snap.url}\n{snap.title}\n{snap.table(40)}"
+    ask = agent.predict_argmax if argmax and hasattr(agent, "predict_argmax") else agent.predict
+    out = ask(state, questions(snap, goal))
+    answers = out["answers"]
+    ready = float(answers.get("ready", {}).get("noul", 0))
+    op = answers.get("op", {}).get("choice", "WAIT")
+    if ready >= 0.72:
+        op = "DONE"
+    if op not in OPS:
+        op = "WAIT"
+    target_label = answers.get("target", {}).get("choice")
+    target = None
+    if target_label:
+        for el in snap.elements:
+            if el.label() == target_label:
+                target = el.index
+                break
+        if target is None and snap.elements:
+            target = snap.elements[0].index
+    return {"op": op, "target": target, "ready": ready, "raw": answers, "usage": out.get("usage", {})}

laya_onnx/ultrafast/snapshot.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+from dataclasses import asdict, dataclass, field
+
+@dataclass
+class Element:
+    index: int
+    role: str
+    name: str
+    value: str = ""
+    tag: str = ""
+    editable: bool = False
+    def label(self) -> str:
+        bits = [f"#{self.index}", self.role or self.tag or "el", self.name[:80]]
+        if self.value:
+            bits.append(f"= {self.value[:40]}")
+        return " ".join(x for x in bits if x)
+
+@dataclass
+class PageSnapshot:
+    url: str
+    title: str = ""
+    elements: list = field(default_factory=list)
+    text: str = ""
+    def table(self, cap: int = 250) -> str:
+        return "\n".join(el.label() for el in self.elements[:cap]) or "(no interactive elements)"
+    def by_index(self, idx: int):
+        for el in self.elements:
+            if el.index == idx:
+                return el
+        return None
+    def to_dict(self) -> dict:
+        return {"url": self.url, "title": self.title, "text": self.text, "elements": [asdict(e) for e in self.elements]}
+    @classmethod
+    def from_dict(cls, raw: dict):
+        els = [e if isinstance(e, Element) else Element(**e) for e in raw.get("elements", [])]
+        return cls(url=raw.get("url", ""), title=raw.get("title", ""), text=raw.get("text", ""), elements=els)
+
+SNAPSHOT_JS = """() => {
+  const seen = new WeakSet(); const out = [];
+  const nodes = document.querySelectorAll('a,button,input,select,textarea,[role=button],[role=link],[role=textbox],[contenteditable=true]');
+  for (const n of nodes) {
+    if (seen.has(n) || out.length >= 250) break; seen.add(n);
+    const r = n.getBoundingClientRect(); if (r.width < 2 || r.height < 2) continue;
+    const role = n.getAttribute('role') || n.tagName.toLowerCase();
+    const name = (n.getAttribute('aria-label') || n.getAttribute('placeholder') || n.innerText || n.value || '').trim();
+    out.push({index: out.length, role, name: name.slice(0,120), value: String(n.value||'').slice(0,80), tag: n.tagName.toLowerCase(), editable: !!(n.isContentEditable || /input|textarea|select/.test(n.tagName.toLowerCase()))});
+  }
+  return {url: location.href, title: document.title, text: (document.body.innerText||'').slice(0,1500), elements: out};
+}"""

laya_onnx/verify.py

@@ -0,0 +1,71 @@
+"""Verify a downloaded ONNX bundle against a SHA-256 manifest."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+MANIFEST_DIR = Path(__file__).with_name("checksums")
+DEFAULT_MANIFEST = MANIFEST_DIR / "receptron-laya-onnx.json"
+
+CHUNK = 1 << 20
+
+
+def sha256_file(path, chunk=CHUNK) -> str:
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as handle:
+        for block in iter(lambda: handle.read(chunk), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def load_manifest(path=None) -> dict:
+    manifest = Path(path) if path else DEFAULT_MANIFEST
+    if not manifest.is_file():
+        raise FileNotFoundError(f"No checksum manifest at {manifest}")
+    return json.loads(manifest.read_text(encoding="utf-8"))
+
+
+def verify_bundle(path, manifest=None):
+    """Check every file in the manifest against ``path``.
+
+    Returns ``(ok, rows)`` where each row is ``{"file", "status", ...}`` and
+    status is one of ``ok`` / ``missing`` / ``size-mismatch`` / ``sha256-mismatch``.
+    """
+    data = manifest if isinstance(manifest, dict) else load_manifest(manifest)
+    root = Path(path).expanduser()
+    rows = []
+    ok = True
+    for name, expected in data.get("files", {}).items():
+        target = root / name
+        if not target.is_file():
+            rows.append({"file": name, "status": "missing"})
+            ok = False
+            continue
+        size = target.stat().st_size
+        if expected.get("size") is not None and size != expected["size"]:
+            rows.append(
+                {
+                    "file": name,
+                    "status": "size-mismatch",
+                    "expected_size": expected["size"],
+                    "size": size,
+                }
+            )
+            ok = False
+            continue
+        digest = sha256_file(target)
+        if expected.get("sha256") and digest != expected["sha256"]:
+            rows.append(
+                {
+                    "file": name,
+                    "status": "sha256-mismatch",
+                    "expected": expected["sha256"],
+                    "actual": digest,
+                }
+            )
+            ok = False
+        else:
+            rows.append({"file": name, "status": "ok", "sha256": digest})
+    return ok, rows

pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "laya-onnx"
+version = "0.1.0"
+description = "ONNX Runtime inference for Laya typed decision models (CPU, OpenVINO, CUDA)"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+dependencies = [
+  "onnxruntime>=1.18",
+  "onnx>=1.16",
+  "numpy>=1.26",
+  "huggingface-hub>=0.34,<2",
+  "tokenizers>=0.21,<1",
+]
+
+[project.optional-dependencies]
+openvino = ["onnxruntime-openvino>=1.18"]
+gpu = ["onnxruntime-gpu>=1.18"]
+export = ["torch>=2.4", "transformers>=4.44", "safetensors>=0.4"]
+dev = ["pytest>=8", "ruff>=0.12", "build>=1"]
+demo = ["rich>=13,<16", "Pillow>=10"]
+ultrafast = ["playwright>=1.47"]
+
+[project.scripts]
+laya-onnx = "laya_onnx.cli:main"
+laya-onnx-snake = "laya_onnx.snake.cli:main"
+laya-onnx-ultrafast = "laya_onnx.ultrafast.cli:main"
+
+[project.urls]
+Repository = "https://github.com/Geoking2104/laya-onnx"
+
+[tool.hatch.build.targets.wheel]
+packages = ["laya_onnx"]