semantic-operators 0.1.0__tar.gz

semantic_operators-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+# Publishes to PyPI when a GitHub Release is published.
+# Uses PyPI Trusted Publishing: no API token is stored anywhere.
+# One-time setup on pypi.org: add a (pending) publisher for this repo,
+# workflow "publish.yml", environment "pypi".
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # lets PyPI verify this workflow's identity
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv build
+      - run: uv publish

semantic_operators-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+.env
+.venv/
+__pycache__/
+*.egg-info/
+dist/

semantic_operators-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jason Duncan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

semantic_operators-0.1.0/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.5
+Name: semantic-operators
+Version: 0.1.0
+Summary: One small, provider-neutral interface for System One models (Jev, Laya, and compatibles).
+Project-URL: Homepage, https://github.com/jasonduncan/semantic-operators
+Project-URL: Source, https://github.com/jasonduncan/semantic-operators
+Project-URL: Issues, https://github.com/jasonduncan/semantic-operators/issues
+Author: Jason Duncan
+License-Expression: MIT
+License-File: LICENSE
+Keywords: benchmark,classification,jev,laya,llm,system-one,typesafe
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: jev
+Requires-Dist: typesafe-sdk>=0.7.1; extra == 'jev'
+Provides-Extra: laya
+Requires-Dist: laya>=0.3.20; extra == 'laya'
+Description-Content-Type: text/markdown
+
+# Semantic Operators
+
+One small interface for **System One models**: fast models that answer structured
+questions about text or data with probabilities, not prose. [Jev](https://typesafe.ai)
+was the first; [Laya](https://huggingface.co/convaiinnovations/laya) is an open-weight,
+Jev-compatible alternative you can run locally. More are coming. This library lets you
+write your code once and swap the model underneath.
+
+| Provider | Where it runs | Install |
+|----------|---------------|---------|
+| `providers.jev.Jev`   | TypeSafe's hosted API (needs `TYPESAFE_API_KEY`) | `[jev]`  |
+| `providers.laya.Laya` | on your machine (~800 MB download on first use)  | `[laya]` |
+
+## Install
+
+```sh
+pip install "semantic-operators[jev]"        # Jev (hosted)
+pip install "semantic-operators[laya]"       # Laya (local; pulls in torch)
+pip install "semantic-operators[jev,laya]"   # both
+```
+
+The core alone (`pip install semantic-operators`) has no dependencies.
+
+## The whole idea
+
+A System One model is asked **named questions about a piece of state** and returns an
+answer with probabilities for each. There are three kinds of question:
+
+| Question  | You give it                                   | `answer.value`                       |
+|-----------|-----------------------------------------------|--------------------------------------|
+| `Boolean` | instructions (+ optional true/false meanings) | `True` / `False`                     |
+| `Choice`  | instructions + named options                  | the chosen option name               |
+| `Score`   | instructions + ordered rubric levels          | expected level as a float, e.g. `1.7` |
+
+Every `Answer` also carries `probabilities` (a dict, in the question's option/level
+order) and `raw` (the provider's own answer object).
+
+A **provider** is anything with one method:
+
+```python
+def ask(self, state, questions: dict[str, Question]) -> dict[str, Answer]
+```
+
+That's the entire abstraction.
+
+## Quick start
+
+```sh
+echo "TYPESAFE_API_KEY=..." > .env
+uv run --env-file .env --extra jev python examples/hello.py
+```
+
+```python
+from typesafe_sdk import TypeSafeClient
+from semantic_operators import Boolean, Choice, Score
+from semantic_operators.providers.jev import Jev
+
+with TypeSafeClient() as client:          # you create and own the SDK client
+    jev = Jev(client)                     # model defaults to "jev-latest"
+    answers = jev.ask(
+        "I was charged twice and I'm furious.",
+        {
+            "is_complaint": Boolean("Is the customer complaining?"),
+            "department": Choice("Which team should handle this?",
+                                 {"billing": "Payments, refunds", "other": "Anything else"}),
+            "urgency": Score("How urgent is this?", ["low", "medium", "high"]),
+        },
+    )
+
+answers["department"].value           # "billing"
+answers["department"].probabilities   # {"billing": 0.97, "other": 0.03}
+```
+
+Swapping to Laya changes only how the provider is built:
+
+```python
+import laya
+from semantic_operators.providers.laya import Laya
+
+provider = Laya(laya.load("convaiinnovations/laya"))   # or Laya(laya.Router())
+answers = provider.ask(state, questions)                # same questions, same Answer type
+```
+
+Compare both side by side:
+
+```sh
+uv run --env-file .env --extra jev --extra laya python examples/compare.py
+```
+
+## Benchmark
+
+`bench.run(provider, questions, cases)` asks each labeled case all questions in one call
+and reports, per question, **accuracy** (Score values are rounded to the nearest level)
+and **p(correct)**, the average probability the provider gave the right answer, plus
+latency and every miss.
+
+```sh
+uv run --env-file .env --extra jev --extra laya python benchmarks/run.py
+```
+
+`benchmarks/support_tickets.py` holds 20 hand-written, hand-labeled support messages
+and the same 3 questions in three wordings. `bench.stability(reports)` reports how often
+a provider's decision stays the same when only the wording changes (labels play no part). It's a smoke test, not a verdict: small, authored, one person's labels.
+
+## Async
+
+Every provider has an async twin with the same contract, `await provider.ask(...)`:
+
+```python
+from typesafe_sdk import AsyncTypeSafeClient
+from semantic_operators.providers.jev import AsyncJev
+from semantic_operators.providers.laya import AsyncLaya
+
+async with AsyncTypeSafeClient() as client:
+    answers = await AsyncJev(client).ask(state, questions)
+```
+
+`AsyncLaya` runs the local model in a worker thread, one call at a time. Concurrency
+speeds up a hosted API (many requests in flight), not a single local model.
+`bench.run_async(provider, questions, cases, concurrency=8)` benchmarks async providers:
+
+```sh
+uv run --env-file .env --extra jev --extra laya python benchmarks/run_async.py
+```
+
+## Layout
+
+```
+src/semantic_operators/
+  types.py          Boolean, Choice, Score, Answer: our vocabulary
+  provider.py       Provider and AsyncProvider (one method each)
+  providers/jev.py  translates to/from the TypeSafe SDK
+  providers/laya.py translates to/from the laya package
+  bench.py          (higher layer) run labeled cases through a provider, score them
+examples/
+  hello.py          one real call to Jev
+  compare.py        the same questions through Jev and Laya
+benchmarks/
+  support_tickets.py  20 labeled messages + the questions
+  run.py              runs the suite through Jev and Laya
+  run_async.py        concurrency, and both providers at once
+```
+
+## Layers
+
+Semantic Operators is built in layers inside one package:
+
+1. **Base layer:** a clean, provider-neutral abstraction over System One
+   models: `types.py`, `provider.py`, `providers/`.
+2. **Higher layers:** built only on the base layer. So far: `bench.py`. Later: reusable
+   named operators and composition.
+
+The base layer never imports from a higher layer, so it could later be split out as its
+own package without changing how it's used.
+
+## Rules
+
+- The library never reads API keys or environment variables. You build the client.
+- The core has no dependencies. Each provider's SDK is an optional extra (`[jev]`, `[laya]`).
+- Our names, not the provider's: `Boolean`, not `noul`.
+
+## Not here yet (on purpose)
+
+Reusable named operators, error types, and
+"don't know" answers. Each will be added as its own small step.
+
+## License
+
+MIT

semantic_operators-0.1.0/README.md

@@ -0,0 +1,169 @@
+# Semantic Operators
+
+One small interface for **System One models**: fast models that answer structured
+questions about text or data with probabilities, not prose. [Jev](https://typesafe.ai)
+was the first; [Laya](https://huggingface.co/convaiinnovations/laya) is an open-weight,
+Jev-compatible alternative you can run locally. More are coming. This library lets you
+write your code once and swap the model underneath.
+
+| Provider | Where it runs | Install |
+|----------|---------------|---------|
+| `providers.jev.Jev`   | TypeSafe's hosted API (needs `TYPESAFE_API_KEY`) | `[jev]`  |
+| `providers.laya.Laya` | on your machine (~800 MB download on first use)  | `[laya]` |
+
+## Install
+
+```sh
+pip install "semantic-operators[jev]"        # Jev (hosted)
+pip install "semantic-operators[laya]"       # Laya (local; pulls in torch)
+pip install "semantic-operators[jev,laya]"   # both
+```
+
+The core alone (`pip install semantic-operators`) has no dependencies.
+
+## The whole idea
+
+A System One model is asked **named questions about a piece of state** and returns an
+answer with probabilities for each. There are three kinds of question:
+
+| Question  | You give it                                   | `answer.value`                       |
+|-----------|-----------------------------------------------|--------------------------------------|
+| `Boolean` | instructions (+ optional true/false meanings) | `True` / `False`                     |
+| `Choice`  | instructions + named options                  | the chosen option name               |
+| `Score`   | instructions + ordered rubric levels          | expected level as a float, e.g. `1.7` |
+
+Every `Answer` also carries `probabilities` (a dict, in the question's option/level
+order) and `raw` (the provider's own answer object).
+
+A **provider** is anything with one method:
+
+```python
+def ask(self, state, questions: dict[str, Question]) -> dict[str, Answer]
+```
+
+That's the entire abstraction.
+
+## Quick start
+
+```sh
+echo "TYPESAFE_API_KEY=..." > .env
+uv run --env-file .env --extra jev python examples/hello.py
+```
+
+```python
+from typesafe_sdk import TypeSafeClient
+from semantic_operators import Boolean, Choice, Score
+from semantic_operators.providers.jev import Jev
+
+with TypeSafeClient() as client:          # you create and own the SDK client
+    jev = Jev(client)                     # model defaults to "jev-latest"
+    answers = jev.ask(
+        "I was charged twice and I'm furious.",
+        {
+            "is_complaint": Boolean("Is the customer complaining?"),
+            "department": Choice("Which team should handle this?",
+                                 {"billing": "Payments, refunds", "other": "Anything else"}),
+            "urgency": Score("How urgent is this?", ["low", "medium", "high"]),
+        },
+    )
+
+answers["department"].value           # "billing"
+answers["department"].probabilities   # {"billing": 0.97, "other": 0.03}
+```
+
+Swapping to Laya changes only how the provider is built:
+
+```python
+import laya
+from semantic_operators.providers.laya import Laya
+
+provider = Laya(laya.load("convaiinnovations/laya"))   # or Laya(laya.Router())
+answers = provider.ask(state, questions)                # same questions, same Answer type
+```
+
+Compare both side by side:
+
+```sh
+uv run --env-file .env --extra jev --extra laya python examples/compare.py
+```
+
+## Benchmark
+
+`bench.run(provider, questions, cases)` asks each labeled case all questions in one call
+and reports, per question, **accuracy** (Score values are rounded to the nearest level)
+and **p(correct)**, the average probability the provider gave the right answer, plus
+latency and every miss.
+
+```sh
+uv run --env-file .env --extra jev --extra laya python benchmarks/run.py
+```
+
+`benchmarks/support_tickets.py` holds 20 hand-written, hand-labeled support messages
+and the same 3 questions in three wordings. `bench.stability(reports)` reports how often
+a provider's decision stays the same when only the wording changes (labels play no part). It's a smoke test, not a verdict: small, authored, one person's labels.
+
+## Async
+
+Every provider has an async twin with the same contract, `await provider.ask(...)`:
+
+```python
+from typesafe_sdk import AsyncTypeSafeClient
+from semantic_operators.providers.jev import AsyncJev
+from semantic_operators.providers.laya import AsyncLaya
+
+async with AsyncTypeSafeClient() as client:
+    answers = await AsyncJev(client).ask(state, questions)
+```
+
+`AsyncLaya` runs the local model in a worker thread, one call at a time. Concurrency
+speeds up a hosted API (many requests in flight), not a single local model.
+`bench.run_async(provider, questions, cases, concurrency=8)` benchmarks async providers:
+
+```sh
+uv run --env-file .env --extra jev --extra laya python benchmarks/run_async.py
+```
+
+## Layout
+
+```
+src/semantic_operators/
+  types.py          Boolean, Choice, Score, Answer: our vocabulary
+  provider.py       Provider and AsyncProvider (one method each)
+  providers/jev.py  translates to/from the TypeSafe SDK
+  providers/laya.py translates to/from the laya package
+  bench.py          (higher layer) run labeled cases through a provider, score them
+examples/
+  hello.py          one real call to Jev
+  compare.py        the same questions through Jev and Laya
+benchmarks/
+  support_tickets.py  20 labeled messages + the questions
+  run.py              runs the suite through Jev and Laya
+  run_async.py        concurrency, and both providers at once
+```
+
+## Layers
+
+Semantic Operators is built in layers inside one package:
+
+1. **Base layer:** a clean, provider-neutral abstraction over System One
+   models: `types.py`, `provider.py`, `providers/`.
+2. **Higher layers:** built only on the base layer. So far: `bench.py`. Later: reusable
+   named operators and composition.
+
+The base layer never imports from a higher layer, so it could later be split out as its
+own package without changing how it's used.
+
+## Rules
+
+- The library never reads API keys or environment variables. You build the client.
+- The core has no dependencies. Each provider's SDK is an optional extra (`[jev]`, `[laya]`).
+- Our names, not the provider's: `Boolean`, not `noul`.
+
+## Not here yet (on purpose)
+
+Reusable named operators, error types, and
+"don't know" answers. Each will be added as its own small step.
+
+## License
+
+MIT

semantic_operators-0.1.0/benchmarks/run.py

@@ -0,0 +1,38 @@
+"""Run the support-ticket benchmark through Jev and Laya, in every wording.
+
+Run:  uv run --env-file .env --extra jev --extra laya python benchmarks/run.py
+Makes 63 Jev API calls (3 wordings x (1 warm-up + 20 cases)).
+"""
+
+import statistics
+
+import laya
+from typesafe_sdk import TypeSafeClient
+
+from semantic_operators import Provider
+from semantic_operators.bench import run, stability
+from semantic_operators.providers.jev import Jev
+from semantic_operators.providers.laya import Laya
+from support_tickets import cases, wordings
+
+
+def benchmark(name: str, provider: Provider) -> None:
+    reports = {wording: run(provider, qs, cases) for wording, qs in wordings.items()}
+    stable = stability(list(reports.values()))
+    latencies = [ms for r in reports.values() for ms in r.latencies_ms]
+
+    print(f"\n{name}: median {statistics.median(latencies):.0f} ms per call")
+    print("  accuracy, p(correct) in brackets")
+    print(f"  {'question':<14}" + "".join(f"{w:>18}" for w in reports) + f"{'stability':>12}")
+    for question in stable:
+        cells = "".join(
+            f"{f'{s.correct}/{s.total} ({s.mean_p_correct:.2f})':>18}"
+            for s in (r.questions[question] for r in reports.values())
+        )
+        print(f"  {question:<14}{cells}{stable[question]:>12.0%}")
+
+
+with TypeSafeClient() as client:
+    benchmark("Jev", Jev(client))
+
+benchmark("Laya", Laya(laya.load("convaiinnovations/laya")))

semantic_operators-0.1.0/benchmarks/run_async.py

@@ -0,0 +1,47 @@
+"""What concurrency buys each provider, and both providers benchmarked at once.
+
+Run:  uv run --env-file .env --extra jev --extra laya python benchmarks/run_async.py
+Makes 63 Jev API calls (3 runs x (1 warm-up + 20 cases)).
+"""
+
+import asyncio
+import statistics
+
+import laya
+from typesafe_sdk import AsyncTypeSafeClient
+
+from semantic_operators.bench import Report, run_async
+from semantic_operators.providers.jev import AsyncJev
+from semantic_operators.providers.laya import AsyncLaya
+from support_tickets import cases, questions
+
+
+def show(label: str, report: Report) -> None:
+    correct = sum(s.correct for s in report.questions.values())
+    total = sum(s.total for s in report.questions.values())
+    print(f"  {label:<28} total {report.total_ms:>6.0f} ms   "
+          f"per call: median {statistics.median(report.latencies_ms):>4.0f} ms, "
+          f"slowest {max(report.latencies_ms):>4.0f} ms   correct {correct}/{total}")
+
+
+async def main() -> None:
+    async with AsyncTypeSafeClient() as client:
+        jev = AsyncJev(client)
+        lay = AsyncLaya(laya.load("convaiinnovations/laya"))
+
+        for name, provider in [("Jev", jev), ("Laya", lay)]:
+            print(f"\n{name}")
+            for concurrency in (1, 8):
+                report = await run_async(provider, questions, cases, concurrency=concurrency)
+                show(f"concurrency {concurrency}", report)
+
+        print("\nBoth at once (concurrency 8 each)")
+        jev_report, laya_report = await asyncio.gather(
+            run_async(jev, questions, cases, concurrency=8),
+            run_async(lay, questions, cases, concurrency=8),
+        )
+        show("Jev", jev_report)
+        show("Laya", laya_report)
+
+
+asyncio.run(main())

semantic_operators-0.1.0/benchmarks/support_tickets.py

@@ -0,0 +1,111 @@
+"""Support-ticket triage: 20 hand-written messages, labeled by hand.
+
+These are authored examples, not real customer data, and one person's labels.
+"Urgency" in particular is a judgment call. Treat results as a smoke test of
+the providers, not a verdict on them.
+"""
+
+from semantic_operators import Boolean, Choice, Score
+from semantic_operators.bench import Case
+
+# The same three questions, worded three ways. Option names and level order are
+# identical across wordings, so one set of labels applies to all of them.
+wordings = {
+    "descriptive": {
+        "is_complaint": Boolean("Is the customer complaining or expressing dissatisfaction?"),
+        "department": Choice(
+            "Which team should handle this message?",
+            {
+                "billing": "Charges, invoices, payments, refunds, or pricing.",
+                "technical": "Bugs, errors, outages, or difficulty using the product.",
+                "account": "Logging in, passwords, profile details, or account access and closure.",
+                "other": "Anything else, such as feedback, partnerships, or general questions.",
+            },
+        ),
+        "urgency": Score(
+            "How urgently does this need a response?",
+            ["low: can wait days", "medium: should be handled today", "high: needs attention now"],
+        ),
+    },
+    "plain": {
+        "is_complaint": Boolean("Is this a complaint?"),
+        "department": Choice(
+            "Which department?",
+            {"billing": None, "technical": None, "account": None, "other": None},
+        ),
+        "urgency": Score("How urgent is this?", ["not urgent", "soon", "urgent"]),
+    },
+    "reworded": {
+        "is_complaint": Boolean("Does the writer express frustration, disappointment, or a grievance?"),
+        "department": Choice(
+            "Route this message to the right team.",
+            {
+                "billing": "Money: payments, invoices, refunds, prices.",
+                "technical": "The product not working as expected.",
+                "account": "Sign-in, credentials, account settings, or deleting the account.",
+                "other": "None of the above.",
+            },
+        ),
+        "urgency": Score(
+            "How quickly should support reply?",
+            ["whenever convenient", "within the day", "immediately"],
+        ),
+    },
+}
+
+questions = wordings["descriptive"]
+
+LOW, MEDIUM, HIGH = 0, 1, 2  # urgency labels are level indexes
+
+
+def case(state: str, complaint: bool, department: str, urgency: int) -> Case:
+    return Case(state, {"is_complaint": complaint, "department": department, "urgency": urgency})
+
+
+cases = [
+    # Clear-cut
+    case("I was charged twice for my subscription this month. Please refund one of them.",
+         True, "billing", MEDIUM),
+    case("Your whole site has been down for an hour and our store can't take any orders!",
+         True, "technical", HIGH),
+    case("How do I change the email address on my profile?",
+         False, "account", LOW),
+    case("Can you send me a copy of last month's invoice for our accountant?",
+         False, "billing", LOW),
+    case("The export button does nothing when I click it. Tried Chrome and Safari.",
+         True, "technical", MEDIUM),
+    case("I think someone else logged into my account, I see orders I never placed. Help!",
+         True, "account", HIGH),
+    case("Just wanted to say the new dashboard is fantastic. Great work, team!",
+         False, "other", LOW),
+    case("We're a design agency interested in a partnership. Who should we talk to?",
+         False, "other", LOW),
+    case("Payment failed three times at checkout and now my card is locked by the bank.",
+         True, "billing", HIGH),
+    case("I forgot my password and the reset email never arrives.",
+         True, "account", MEDIUM),
+
+    # Harder: sarcasm, politeness masking a problem, mixed topics, JSON state
+    case("Oh great, another 'minor update' that wiped all my saved reports. Love it.",
+         True, "technical", HIGH),
+    case("No rush at all, but I noticed the annual plan price on your site doesn't match "
+         "what I was billed.",
+         True, "billing", LOW),
+    case("Please delete my account and all my data. I no longer want to use this service.",
+         False, "account", MEDIUM),
+    case("Is there a discount for nonprofits?",
+         False, "billing", LOW),
+    case("The app keeps crashing, and since I can't use it I want a refund for this month.",
+         True, "billing", MEDIUM),
+    case("Our CEO is presenting from your platform in 20 minutes and nothing loads.",
+         True, "technical", HIGH),
+    case("Thanks for fixing the login bug so quickly yesterday!",
+         False, "other", LOW),
+    case("I've emailed three times about my refund and nobody has replied. Unacceptable.",
+         True, "billing", HIGH),
+    case({"channel": "chat", "plan": "enterprise", "message": "SSO login is failing for all "
+          "500 of our users since this morning."},
+         True, "account", HIGH),
+    case({"channel": "email", "plan": "free", "message": "Where can I find your API docs?"},
+         False, "other", LOW),
+]

semantic_operators-0.1.0/examples/compare.py

@@ -0,0 +1,51 @@
+"""Ask Jev (hosted) and Laya (local) the same questions, through the same interface.
+
+Run:  uv run --env-file .env --extra jev --extra laya python examples/compare.py
+The first run downloads the Laya checkpoint (~800 MB) from Hugging Face.
+"""
+
+import time
+
+import laya
+from typesafe_sdk import TypeSafeClient
+
+from semantic_operators import Boolean, Choice, Provider, Score
+from semantic_operators.providers.jev import Jev
+from semantic_operators.providers.laya import Laya
+
+message = "I was charged twice for my subscription this month and I'm furious."
+
+questions = {
+    "is_complaint": Boolean("Is the customer complaining?"),
+    "department": Choice(
+        "Which team should handle this?",
+        {
+            "billing": "Charges, invoices, payments, or refunds.",
+            "technical": "A product defect or difficulty using the product.",
+            "other": "Anything else.",
+        },
+    ),
+    "urgency": Score("How urgent is this request?", ["low", "medium", "high"]),
+}
+
+
+def show(name: str, provider: Provider) -> None:
+    start = time.perf_counter()
+    answers = provider.ask(message, questions)
+    ms = (time.perf_counter() - start) * 1000
+    print(f"\n{name} ({ms:.0f} ms)")
+    for question, answer in answers.items():
+        value = f"{answer.value:.2f}" if isinstance(answer.value, float) else repr(answer.value)
+        probabilities = ", ".join(f"{k}={p:.2f}" for k, p in answer.probabilities.items())
+        print(f"  {question:>13}: {value:<12} ({probabilities})")
+
+
+print(f"Message: {message}")
+
+with TypeSafeClient() as client:
+    show("Jev", Jev(client))
+
+model = laya.load("convaiinnovations/laya")  # English checkpoint, runs on this machine
+laya_provider = Laya(model)
+laya_provider.ask(message, questions)  # warm-up: the first call pays one-time setup costs
+show("Laya", laya_provider)