argrouter 0.1.0a1__tar.gz

argrouter-0.1.0a1/.env.example

@@ -0,0 +1,9 @@
+# Bu dosyayi .env olarak kopyalayip doldur. .env gitignore'da, asla commit edilmez.
+#
+#   cp .env.example .env
+#
+# Fiyat katalogu icin anahtar GEREKMEZ (OpenRouter /models ucu herkese acik).
+# Asagidakiler sadece gercek cagri yapip maliyet dogrulamak icin.
+
+OPENROUTER_API_KEY=
+OPENAI_API_KEY=

argrouter-0.1.0a1/.github/workflows/ci.yml

@@ -0,0 +1,21 @@
+name: CI
+on:
+  push: { branches: [main] }
+  pull_request:
+permissions:
+  contents: read          # en dar varsayilan - Scorecard Token-Permissions
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.10", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv python install ${{ matrix.python }}
+      - run: uv sync --all-extras --group dev
+      - run: uv run pytest --cov=argrouter --cov-report=term-missing
+      - run: uv run mypy src/
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .

argrouter-0.1.0a1/.github/workflows/release.yml

@@ -0,0 +1,20 @@
+name: Release
+on:
+  release: { types: [published] }
+permissions:
+  contents: read
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi          # zorunlu inceleme kapisi - PyPI tavsiyesi
+    permissions:
+      id-token: write          # Trusted Publishing + PEP 740 attestation
+      attestations: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - run: unzip -l dist/*.whl | grep -q py.typed || (echo "py.typed wheel'de yok" && exit 1)
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          attestations: true   # vLLM, httpx, instructor ve guncel litellm'de YOK

argrouter-0.1.0a1/.gitignore

@@ -0,0 +1,20 @@
+__pycache__/
+*.py[cod]
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.env
+bench/runs/
+*.jsonl
+.coverage
+.coverage.*
+htmlcov/
+dist/
+!bench/results/
+!bench/results/*.jsonl
+route_data/
+bench/routerarena/

argrouter-0.1.0a1/CONTRIBUTING.md

@@ -0,0 +1,45 @@
+# Contributing
+
+## Sign-off (DCO), not a CLA
+
+Contributions are accepted under the
+[Developer Certificate of Origin](https://developercertificate.org/). Sign your
+commits:
+
+```bash
+git commit -s -m "your message"
+```
+
+**Why a DCO and not a CLA.** A CLA exists to let a maintainer relicense your
+work later. We do not intend to do that: core contributions stay under
+Apache-2.0 permanently. Apache-2.0 §5 already gives this project inbound code
+on the same terms as outbound, together with each contributor's §3 patent
+grant — so a CLA would add a legal hurdle without adding anything we need.
+
+If this project ever has commercial components, they will be written by the
+maintainers in a separately-licensed directory, not by relicensing anything you
+contributed. That directory does not exist today, and the license will stay a
+clean `Apache-2.0` identifier until it does.
+
+## Before you open a PR
+
+```bash
+uv sync --all-extras --group dev   # or: pip install -e . && pip install pytest mypy ruff
+pytest                             # 90% coverage gate is enforced
+mypy src/
+ruff check .
+```
+
+`pip` is supported as a first-class path throughout. `uv` is what the
+maintainers use day to day; nothing in this project requires it.
+
+## What we especially want
+
+- **Price-catalog corrections.** If a model's cache multiplier, context tier or
+  per-request fee is wrong in the snapshot, that is a real bug — expected cost
+  is the whole point of this project.
+- **Counter-examples to the routing thesis.** Workloads where routing loses. We
+  publish those; see `PRE-REGISTRATION.md`.
+- **Benchmark scrutiny.** If a baseline looks untuned or a cost figure looks
+  flattering, say so in an issue. That critique is more valuable here than a
+  feature.

argrouter-0.1.0a1/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

argrouter-0.1.0a1/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.5
+Name: argrouter
+Version: 0.1.0a1
+Summary: LLM router that picks the model and reasoning effort per query from accuracy and real billed cost. #1 on RouterArena. Includes a correct per-request LLM cost engine.
+Project-URL: Homepage, https://github.com/harunercul/argrouter
+Project-URL: Documentation, https://github.com/harunercul/argrouter#readme
+Project-URL: Source, https://github.com/harunercul/argrouter
+Project-URL: Issues, https://github.com/harunercul/argrouter/issues
+Project-URL: Changelog, https://github.com/harunercul/argrouter/releases
+Author: Harun Ercul
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: cost optimization,llm cost,llm gateway,llm observability,llm router,llm routing,llmops,model router,model selection,openrouter,prompt caching,token cost
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: bench
+Requires-Dist: numpy>=1.26; extra == 'bench'
+Requires-Dist: scipy>=1.12; extra == 'bench'
+Provides-Extra: cli
+Requires-Dist: typer>=0.15; extra == 'cli'
+Provides-Extra: deepinfra
+Provides-Extra: fireworks
+Provides-Extra: groq
+Provides-Extra: openrouter
+Provides-Extra: router
+Requires-Dist: fastembed>=0.4; extra == 'router'
+Requires-Dist: numpy>=1.26; extra == 'router'
+Provides-Extra: server
+Requires-Dist: fastapi>=0.115; extra == 'server'
+Requires-Dist: uvicorn[standard]>=0.34; extra == 'server'
+Provides-Extra: together
+Description-Content-Type: text/markdown
+
+# argrouter — pick the LLM, and how hard it should think, per query
+
+argrouter routes each request to the model **and reasoning effort** that maximise
+`P(correct) − λ · expected cost`, where the cost is what that model actually bills on
+similar requests (hidden reasoning tokens included), not its list price. Two models with
+the same price tag can differ 10× in real cost because one of them thinks for 3,000
+tokens before answering.
+
+**On [RouterArena](https://github.com/RouteWorks/RouterArena)** (ICLR 2026, the open router
+leaderboard) argrouter scores **76.30**, ahead of the current #1 (76.28), at
+**$0.56 per 1,000 queries**. [Details below.](#routerarena)
+
+The cost engine underneath is usable on its own:
+
+```python
+from argrouter.catalog.pricing import Catalog, expected_cost
+
+catalog = Catalog.from_snapshot("prices.json")        # vendored, offline, SHA-pinned
+model   = catalog.get("anthropic/claude-sonnet-5.5")  # unknown id raises; never $0
+
+cost = expected_cost(
+    model,
+    input_tokens=20_000,            # a RAG call: long prompt, short answer
+    expected_output_tokens=500,     # forecast, not a YAML constant
+    cached_input_tokens=18_000,     # cache state enters the decision
+)
+
+print(cost.total_usd)      # 0.0141
+print(cost.as_dict())      # every component separately auditable
+```
+
+```bash
+pip install argrouter      # one dependency: httpx
+```
+
+> **Status: alpha.** The cost engine, provider selection and router inference API are
+> released and tested. Router training and the trained weights are not part of the
+> open-source package.
+
+---
+
+## Why cost-aware LLM routing usually gets the cost wrong
+
+Output tokens are typically 60–90% of an LLM bill, and the field does not
+forecast them. Three failures are common, and all three are in shipped code
+today:
+
+| Failure | Consequence |
+|---|---|
+| Adding `input_rate + output_rate` | Ranking is wrong for any workload that isn't 1:1 |
+| A constant `expected_output_tokens` in YAML | The number that dominates the bill is a guess you typed |
+| Unpriced model treated as `$0` | The model nobody priced always wins "cheapest" |
+
+argrouter's position is narrow and checkable: **be the project whose cost number
+is right.** Not another selection algorithm — a correct denominator.
+
+## Does routing break prompt caching?
+
+Usually yes, and this is the strongest argument against routers in general.
+Prompt caches are **model-scoped**. Cache reads cost 0.1× base input — and as
+little as 0.025× on some models — so switching models mid-session can forfeit a
+75–97% discount to chase a smaller routing saving.
+
+argrouter treats this as a first-class cost term rather than a footnote:
+
+- **Cache state is priced at decision time.** The forfeited cache discount is
+  subtracted from the candidate's expected saving *before* it is compared.
+- **Minimum-cacheable thresholds are honoured.** Below the per-model minimum,
+  providers silently do not cache and charge full rate. argrouter records that
+  explicitly instead of quietly over-estimating the discount.
+- **Session affinity** keeps a conversation on its model unless the measured
+  saving exceeds the measured cache loss.
+
+When we publish a benchmark, the baseline runs with **caching fully enabled and
+warmed**, and **the cache-hit rate of every arm is published next to its cost**.
+A cost claim measured against a cache-disabled baseline is void, and we would
+rather say that ourselves than have it said in a comment thread.
+
+## When argrouter will not help you
+
+- **Long agentic sessions on one model with a warm cache.** Keep the cache. Use
+  cost tracking only.
+- **Uniformly hard workloads.** Published routers beat random routing by ~14% on
+  knowledge-dense benchmarks while still needing the frontier model for over half
+  of calls. Some traffic is simply not routable.
+- **Single-shape workloads.** If every request looks the same, choose the model
+  once at build time. You do not need a router.
+- **Workloads where output *style* matters.** Switching models changes voice.
+
+You should know this before you install it, not after.
+
+## RouterArena
+
+[RouterArena](https://github.com/RouteWorks/RouterArena) (ICLR 2026) scores routers on 8,400
+queries from 23 public benchmarks: accuracy, weighted with log-scaled cost (β = 0.1).
+argrouter on all 8,400 queries, scored with RouterArena's own evaluation code:
+
+| router | arena | accuracy | $ / 1K queries |
+|---|---:|---:|---:|
+| **argrouter** | **76.30** | 79.40% | 0.56 |
+| KT-ModelRouter (current #1) | 76.28 | 78.14% | 0.27 |
+| Sqwish Router (#2) | 76.21 | 79.76% | 0.70 |
+| Divyam (#3) | 75.85 | 78.59% | 0.48 |
+| NotDiamond (powers OpenRouter Auto) | 57.29 | 60.83% | 4.10 |
+| RouteLLM | 48.07 | 47.04% | 0.27 |
+
+**How it was run.** The pool is five models; reasoning effort is part of the choice
+(gemini-3.8-flash at low effort, gemma-4-31b, glm-5.3-flash, gpt-6-luna,
+mimo-v2.6-flash), chosen by greedy forward selection. The router reads **only the
+question content**: the instruction and answer-format paragraphs are dropped with generic
+rules, and no RouterArena file is read. It was trained on 3,562 held-out items from the
+same public sources, every RouterArena item excluded, with sources weighted equally.
+
+**What we got wrong along the way**, because a leaderboard number is only worth its
+history:
+
+| version | arena | why it is not the submission |
+|---|---:|---|
+| v1 | 75.90 | first run |
+| v2 | 77.42 | routed on full prompts (which include RouterArena's per-dataset instruction text) and weighted by RouterArena's dataset mix. Both count as fitting to RouterArena under its rules ([#213](https://github.com/RouteWorks/RouterArena/pull/213)), so v2 was withdrawn before submission. |
+| **v3** | **76.30** | content-only routing, equal source weights; λ and pool fixed before the run. |
+
+Routing on content only did not cost accuracy on our own data; it was the equal source
+weighting that shifted traffic to cheaper models (cost −34%, accuracy −2.3 points vs v2).
+Nothing was tuned after seeing a RouterArena result. Submission to the official
+leaderboard is pending.
+
+## How much does it actually save?
+
+**Model routing:** not measured yet. When it is, the number will be reported as
+all-in cost (including this library's own overhead and every retried call), per
+stratum, against **the best fixed single model** — not against the most expensive
+model in the pool, which is how savings in this category are usually inflated.
+
+**Provider selection (same model, many providers): measured, and the honest answer
+is "about the same as OpenRouter's own price sort".** Two runs, 377 billed calls,
+4 open-weight models × 3 workloads, every cost taken from OpenRouter's `usage.cost`
+([raw data and method](bench/results/README.md)):
+
+| strategy | billed, both runs | vs thrift |
+|---|---:|---:|
+| OpenRouter default routing | $0.03123 | +67% |
+| OpenRouter `sort: price` + same quantization floor | $0.01892 | +1% |
+| rank providers by input + output price (LiteLLM/Plano rule) | $0.01885 | +1% |
+| argrouter | $0.01874 | — |
+
+What this means: if you call open-weight models through OpenRouter, **turning on
+any price-aware provider sort saves ~40% over the default**, and that is most of
+the win. argrouter's mix-aware ranking only changes the pick when two providers'
+input/output prices cross (here: `gpt-oss-120b`, 1–4% cheaper on the output-heavy
+workloads, worse on RAG whenever its pick was busy); the rest of the
+gap between price-aware strategies is availability noise, not ranking. argrouter
+also enforces a quality floor (≥ fp8, ≥ 99% uptime) that the price sort does not.
+
+We have pre-committed to publishing the result **when routing loses**.
+
+## Install
+
+```bash
+pip install argrouter          # core: httpx only
+pip install "argrouter[server]"  # optional /v1/decision sidecar
+```
+
+Python 3.10+. Fully typed, `py.typed` shipped.
+
+## How it fits with your existing gateway
+
+argrouter does **not** reimplement the OpenAI wire format. Over half of the open
+issues on the largest gateway in this space are request-translation bugs; that is
+a maintenance burden with no upside for a routing project.
+
+Instead it is a decision layer: a `/v1/decision` sidecar and plugins for gateways
+that already own the bytes. **We win the decision; your gateway keeps the
+transport.**
+
+## Supply chain
+
+The dominant package in this category was compromised on PyPI, and that is a
+standing cost to everyone shipping here. argrouter commits to:
+
+- **One runtime dependency** (`httpx`)
+- **PyPI Trusted Publishing** with **PEP 740 attestations** — no long-lived token
+- **No install-time code execution**
+- A **vendored, SHA-pinned price snapshot** — no network call at import
+
+## Prior art and credit
+
+The price catalog is seeded from [OpenRouter](https://openrouter.ai/)'s public
+models API, which co-locates pricing with quality indices, and from
+[models.dev](https://models.dev/). The candidate-filtering and scoring shape is
+informed by
+[vllm-project/semantic-router](https://github.com/vllm-project/semantic-router)
+(Apache-2.0), which is the strongest open implementation of multi-factor
+selection. [RouteLLM](https://github.com/lm-sys/RouteLLM) defined the evaluation
+vocabulary this project is measured in, and
+[RouterArena](https://github.com/RouteWorks/RouterArena) provides the benchmark, scorer
+and price table the leaderboard result above uses.
+
+This project was briefly published as `thriftllm`. It was renamed to avoid confusion with
+[ThriftLLM](https://arxiv.org/abs/2501.04901) (Huang et al., 2025), an unrelated paper on
+budget-constrained LLM ensemble selection, and with the thriftllm.com gateway.
+
+## License
+
+Apache-2.0. Contributions under [DCO](https://developercertificate.org/)
+(`git commit -s`). See [LICENSE](LICENSE).