typellm 0.2.5__tar.gz → 0.2.6__tar.gz

{typellm-0.2.5/typellm.egg-info → typellm-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typellm
-Version: 0.2.5
+Version: 0.2.6
 Summary: Type-Safe Decoding for Autoregressive LLMs
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://typellm.ai/
@@ -96,7 +96,7 @@ client = TypeLLMClient(
 Example request:
 
 ```python
-result = client.generate(
+response = client.generate(
     context="""
     Receipt from Hilton London
     Total: £324.50
@@ -128,10 +128,12 @@ result = client.generate(
     },
 )
 
-print(result)
+print(response.result)
 ```
 
-Example output:
+`generate()` returns what the HTTP API does: the typed answers in `.result`, the
+reasoning of each field that thought in `.thinking`, and the call's tokens in
+`.usage`. Example `.result`:
 
 ```python
 {
@@ -160,7 +162,7 @@ Enum choices support `string`, `integer`, and `number` types, with at most 24 va
 A string without `enum` generates free text:
 
 ```python
-result = client.generate(
+response = client.generate(
     context="The train ticket is for a client meeting.",
     questions={
         "summary": {"type": "string", "instructions": "Summarize in one sentence."},
@@ -169,12 +171,13 @@ result = client.generate(
 ```
 
 Free text stops after 128 tokens. Pass `text_max_tokens=` to the client for
-longer answers, or set `maxLength` on a field to cap its characters.
+longer answers, and ask for the length you want in the field's instructions.
+`maxLength` is not supported.
 
 Ask for a numeric answer without enumerating every possible value:
 
 ```python
-result = client.generate(
+response = client.generate(
     context="Calculate the requested value accurately.",
     questions={
         "answer": {
@@ -184,7 +187,7 @@ result = client.generate(
     },
 )
 
-print(result)
+print(response.result)
 # {"answer": 70.0}
 ```
 
@@ -210,7 +213,7 @@ Add `"null"` to the type to allow a missing value. The field returns `None`
 when the input has no value for it:
 
 ```python
-result = client.generate(
+response = client.generate(
     context="Read the attached receipt.",
     images=["receipt.jpg"],
     questions={
@@ -236,7 +239,7 @@ Thinking is off by default. Turn it on for the fields that need it; the others
 answer at once, and the fields that think reason side by side:
 
 ```python
-result = client.generate(context=context, questions={
+response = client.generate(context=context, questions={
     "total": {"type": "number"},
     "category": {"type": "string", "enum": ["meal", "travel", "equipment"]},
     "policy_ok": {"type": "boolean", "instructions": "Does it meet the travel policy?",
@@ -244,13 +247,12 @@ result = client.generate(context=context, questions={
 })
 ```
 
-`thinking_budget` caps a field's reasoning; there is no budget by default.
-`TypeLLMClient(..., thinking_budget=2048)` sets one for every field that thinks
-without its own. When reasoning reaches the budget, TypeLLM closes it and moves
-on to the typed answer.
+`thinking_budget` caps a field's reasoning. Without one, a field may reason until
+the model's context is full. When reasoning reaches the budget, TypeLLM closes it
+and moves on to the typed answer.
 
-After a call, `client.last_thinking` maps each field that thought to its
-reasoning, and `client.last_usage.thinking_tokens` counts the reasoning tokens.
+`response.thinking` maps each field that thought to its reasoning, and
+`response.usage.thinking_tokens` counts the reasoning tokens.
 
 Models with always-on thinking reason on every field; `thinking_budget` applies
 to them too. See [Supported models](#supported-models).
@@ -261,7 +263,7 @@ Pass images with `images=` alongside the text context. The served model must be
 a vision-language model, such as `Qwen/Qwen3.8-27B`.
 
 ```python
-result = client.generate(
+response = client.generate(
     context="The customer says this receipt was charged twice.",
     images=["receipt.png"],
     questions={
@@ -281,7 +283,7 @@ Fields run together by default, and each sees only the original context.
 When a field needs earlier results, list them in `depends_on`:
 
 ```python
-result = client.generate(
+response = client.generate(
     context="The payments service is returning errors after a deployment.",
     questions={
         "system": {
@@ -319,7 +321,7 @@ step reuses its parent's cached prompt. Unknown names and cycles raise
 Set `return_probabilities` on individual enum or boolean fields:
 
 ```python
-result = client.generate(
+response = client.generate(
     context=context,
     questions={
         "expense_type": {
@@ -371,7 +373,7 @@ For a one-off request, use the convenience function:
 ```python
 from typellm import run_schema
 
-result = run_schema(
+response = run_schema(
     context=context,
     questions=questions,
     base_url="http://127.0.0.1:30000",
@@ -384,7 +386,7 @@ result = run_schema(
 Add `permutations` to an `enum` question to reduce option-order bias. TypeLLM averages the probabilities and keeps the same return format.
 
 ```python
-result = client.generate(
+response = client.generate(
     context="A single roll of a fair die.",
     questions={"roll": {
         "type": "string",
@@ -417,19 +419,19 @@ prompts and usage, and connections to SGLang are reused.
 import threading
 
 cancel = threading.Event()
-result = client.generate(
+response = client.generate(
     context=context,
     questions=questions,
     seed=7,          # this call's random choices only
     timeout=30,      # seconds for the whole call; raises GenerationTimeout
     cancel=cancel,   # set it from another thread; raises GenerationCancelled
 )
-print(client.last_usage)
-# Usage(requests=4, prompt_tokens=1830, cached_tokens=1504, completion_tokens=7, thinking_tokens=0, input_tokens=410)
+print(response.usage)
+# Usage(input_tokens=410, thinking_tokens=0, requests=4, prompt_tokens=1830, cached_tokens=1504, completion_tokens=7)
 ```
 
-`last_usage` reports the tokens of the last call made in the current thread,
-including a call that failed partway. `input_tokens` is what you sent, each part
+`usage` reports the tokens of the call. When a call fails partway, the
+exception's `.usage` holds what it spent. `input_tokens` is what you sent, each part
 counted once: the context, the questions as JSON, and the images. The other
 counts are SGLang's for the call's requests, where every prompt carries the
 shared context. A timeout or cancel stops
@@ -468,8 +470,9 @@ Other sizes in the Qwen3.5 and Qwen3.8 families are expected to be compatible.
 
 [Image input](#image-input) has been tested with `Qwen/Qwen3.8-27B`.
 
-Use the checkpoint ID as `model=`. If the server's tokenizer path is unavailable
-locally, set `tokenizer=` to its matching Hugging Face ID or local directory.
+Use the checkpoint ID as `model=`. TypeLLM loads the tokenizer from the server's
+paths, then its served model name; if none of those loads locally, set
+`tokenizer=` to the matching Hugging Face ID or local directory.
 The tokenizer must load from standard artifacts without custom model code.
 
 ## Comparison with Jev-style models

{typellm-0.2.5 → typellm-0.2.6}/README.md

@@ -81,7 +81,7 @@ client = TypeLLMClient(
 Example request:
 
 ```python
-result = client.generate(
+response = client.generate(
     context="""
     Receipt from Hilton London
     Total: £324.50
@@ -113,10 +113,12 @@ result = client.generate(
     },
 )
 
-print(result)
+print(response.result)
 ```
 
-Example output:
+`generate()` returns what the HTTP API does: the typed answers in `.result`, the
+reasoning of each field that thought in `.thinking`, and the call's tokens in
+`.usage`. Example `.result`:
 
 ```python
 {
@@ -145,7 +147,7 @@ Enum choices support `string`, `integer`, and `number` types, with at most 24 va
 A string without `enum` generates free text:
 
 ```python
-result = client.generate(
+response = client.generate(
     context="The train ticket is for a client meeting.",
     questions={
         "summary": {"type": "string", "instructions": "Summarize in one sentence."},
@@ -154,12 +156,13 @@ result = client.generate(
 ```
 
 Free text stops after 128 tokens. Pass `text_max_tokens=` to the client for
-longer answers, or set `maxLength` on a field to cap its characters.
+longer answers, and ask for the length you want in the field's instructions.
+`maxLength` is not supported.
 
 Ask for a numeric answer without enumerating every possible value:
 
 ```python
-result = client.generate(
+response = client.generate(
     context="Calculate the requested value accurately.",
     questions={
         "answer": {
@@ -169,7 +172,7 @@ result = client.generate(
     },
 )
 
-print(result)
+print(response.result)
 # {"answer": 70.0}
 ```
 
@@ -195,7 +198,7 @@ Add `"null"` to the type to allow a missing value. The field returns `None`
 when the input has no value for it:
 
 ```python
-result = client.generate(
+response = client.generate(
     context="Read the attached receipt.",
     images=["receipt.jpg"],
     questions={
@@ -221,7 +224,7 @@ Thinking is off by default. Turn it on for the fields that need it; the others
 answer at once, and the fields that think reason side by side:
 
 ```python
-result = client.generate(context=context, questions={
+response = client.generate(context=context, questions={
     "total": {"type": "number"},
     "category": {"type": "string", "enum": ["meal", "travel", "equipment"]},
     "policy_ok": {"type": "boolean", "instructions": "Does it meet the travel policy?",
@@ -229,13 +232,12 @@ result = client.generate(context=context, questions={
 })
 ```
 
-`thinking_budget` caps a field's reasoning; there is no budget by default.
-`TypeLLMClient(..., thinking_budget=2048)` sets one for every field that thinks
-without its own. When reasoning reaches the budget, TypeLLM closes it and moves
-on to the typed answer.
+`thinking_budget` caps a field's reasoning. Without one, a field may reason until
+the model's context is full. When reasoning reaches the budget, TypeLLM closes it
+and moves on to the typed answer.
 
-After a call, `client.last_thinking` maps each field that thought to its
-reasoning, and `client.last_usage.thinking_tokens` counts the reasoning tokens.
+`response.thinking` maps each field that thought to its reasoning, and
+`response.usage.thinking_tokens` counts the reasoning tokens.
 
 Models with always-on thinking reason on every field; `thinking_budget` applies
 to them too. See [Supported models](#supported-models).
@@ -246,7 +248,7 @@ Pass images with `images=` alongside the text context. The served model must be
 a vision-language model, such as `Qwen/Qwen3.8-27B`.
 
 ```python
-result = client.generate(
+response = client.generate(
     context="The customer says this receipt was charged twice.",
     images=["receipt.png"],
     questions={
@@ -266,7 +268,7 @@ Fields run together by default, and each sees only the original context.
 When a field needs earlier results, list them in `depends_on`:
 
 ```python
-result = client.generate(
+response = client.generate(
     context="The payments service is returning errors after a deployment.",
     questions={
         "system": {
@@ -304,7 +306,7 @@ step reuses its parent's cached prompt. Unknown names and cycles raise
 Set `return_probabilities` on individual enum or boolean fields:
 
 ```python
-result = client.generate(
+response = client.generate(
     context=context,
     questions={
         "expense_type": {
@@ -356,7 +358,7 @@ For a one-off request, use the convenience function:
 ```python
 from typellm import run_schema
 
-result = run_schema(
+response = run_schema(
     context=context,
     questions=questions,
     base_url="http://127.0.0.1:30000",
@@ -369,7 +371,7 @@ result = run_schema(
 Add `permutations` to an `enum` question to reduce option-order bias. TypeLLM averages the probabilities and keeps the same return format.
 
 ```python
-result = client.generate(
+response = client.generate(
     context="A single roll of a fair die.",
     questions={"roll": {
         "type": "string",
@@ -402,19 +404,19 @@ prompts and usage, and connections to SGLang are reused.
 import threading
 
 cancel = threading.Event()
-result = client.generate(
+response = client.generate(
     context=context,
     questions=questions,
     seed=7,          # this call's random choices only
     timeout=30,      # seconds for the whole call; raises GenerationTimeout
     cancel=cancel,   # set it from another thread; raises GenerationCancelled
 )
-print(client.last_usage)
-# Usage(requests=4, prompt_tokens=1830, cached_tokens=1504, completion_tokens=7, thinking_tokens=0, input_tokens=410)
+print(response.usage)
+# Usage(input_tokens=410, thinking_tokens=0, requests=4, prompt_tokens=1830, cached_tokens=1504, completion_tokens=7)
 ```
 
-`last_usage` reports the tokens of the last call made in the current thread,
-including a call that failed partway. `input_tokens` is what you sent, each part
+`usage` reports the tokens of the call. When a call fails partway, the
+exception's `.usage` holds what it spent. `input_tokens` is what you sent, each part
 counted once: the context, the questions as JSON, and the images. The other
 counts are SGLang's for the call's requests, where every prompt carries the
 shared context. A timeout or cancel stops
@@ -453,8 +455,9 @@ Other sizes in the Qwen3.5 and Qwen3.8 families are expected to be compatible.
 
 [Image input](#image-input) has been tested with `Qwen/Qwen3.8-27B`.
 
-Use the checkpoint ID as `model=`. If the server's tokenizer path is unavailable
-locally, set `tokenizer=` to its matching Hugging Face ID or local directory.
+Use the checkpoint ID as `model=`. TypeLLM loads the tokenizer from the server's
+paths, then its served model name; if none of those loads locally, set
+`tokenizer=` to the matching Hugging Face ID or local directory.
 The tokenizer must load from standard artifacts without custom model code.
 
 ## Comparison with Jev-style models

{typellm-0.2.5 → typellm-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "typellm"
-version = "0.2.5"
+version = "0.2.6"
 description = "Type-Safe Decoding for Autoregressive LLMs"
 readme = "README.md"
 license = "Apache-2.0"

{typellm-0.2.5 → typellm-0.2.6}/tests/test_batching.py

@@ -96,7 +96,7 @@ class PrefixWarmupTests(unittest.TestCase):
             with self.subTest(thinking=thinking):
                 client = TypeLLMClient(model="fake")
                 client.sglang = FakeServer()
-                client.generate(context="Receipt", questions=thinks(self.MIXED) if thinking else self.MIXED)
+                client.generate(context="Receipt", questions=thinks(self.MIXED) if thinking else self.MIXED).result
                 warm = client.sglang.requests("count")
                 self.assertEqual(len(warm), 1)
                 # First, before the thinking, number, text and scoring batches.
@@ -107,7 +107,7 @@ class PrefixWarmupTests(unittest.TestCase):
     def test_open_fields_alone_are_not_warmed(self):
         client = TypeLLMClient(model="fake")
         client.sglang = FakeServer()
-        client.generate(context="Receipt", questions={"a": {"type": "integer"}, "n": {"type": "string"}})
+        client.generate(context="Receipt", questions={"a": {"type": "integer"}, "n": {"type": "string"}}).result
         self.assertEqual(client.sglang.requests("count"), [])
 
 
@@ -123,7 +123,7 @@ class PerFieldThinkingTests(unittest.TestCase):
             "hard": {"type": "boolean", "instructions": "Hard?", "thinking": True},
             "easy": {"type": "boolean", "instructions": "Easy?"},
             "count": {"type": "integer"},
-        })
+        }).result
         self.assertEqual(result, {"hard": True, "easy": True, "count": 7})
         [prompt] = self.thinking_prompts(client.sglang)  # one batch, one prompt
         self.assertIn("Hard?", prompt)
@@ -139,7 +139,7 @@ class PerFieldThinkingTests(unittest.TestCase):
             "a": {"type": "boolean", "instructions": "A?", "thinking": True},
             "b": {"type": "boolean", "instructions": "B?", "thinking": True},
             "skip": {"type": "boolean", "instructions": "Skip?", "thinking": False},
-        })
+        }).result
         prompts = self.thinking_prompts(client.sglang)
         self.assertEqual(len(client.sglang.requests("think")), 1)
         self.assertEqual(len(prompts), 2)
@@ -153,7 +153,7 @@ class PerFieldThinkingTests(unittest.TestCase):
             "short": {"type": "boolean", "instructions": "Short?", "thinking": True, "thinking_budget": 100},
             "long": {"type": "boolean", "instructions": "Long?", "thinking": True, "thinking_budget": 300},
             "default": {"type": "boolean", "instructions": "Default?", "thinking": True},
-        })
+        }).result
         [request] = client.sglang.requests("think")
         budgets = {next(q for q in ("Short?", "Long?", "Default?") if q in t): params["max_new_tokens"]
                    for t, params in zip(request["text"], request["sampling_params"])}
@@ -172,16 +172,14 @@ class PerFieldThinkingTests(unittest.TestCase):
 
         client = TypeLLMClient(model="fake")
         client.sglang = Metered()
-        client.generate(context="Receipt", questions={
+        done = client.generate(context="Receipt", questions={
             "hard": {"type": "boolean", "instructions": "Hard?", "thinking": True},
             "easy": {"type": "boolean", "instructions": "Easy?"},
         })
-        self.assertEqual(client.last_thinking, {"hard": "Reasoned."})
-        self.assertEqual(client.last_usage.thinking_tokens, 40)
-        self.assertGreater(client.last_usage.completion_tokens, 40)  # answers count too
-        with self.assertRaises(ValueError):
-            client.generate(questions={"x": {"type": "boolean"}})
-        self.assertEqual(client.last_thinking, {})
+        self.assertEqual(done.thinking, {"hard": "Reasoned."})
+        self.assertEqual(done.usage.thinking_tokens, 40)
+        self.assertGreater(done.usage.completion_tokens, 40)  # answers count too
+        self.assertEqual(client.generate(context="Receipt", questions={"x": {"type": "boolean"}}).thinking, {})
 
     def test_invalid_settings_are_schema_errors(self):
         from typellm import SchemaError
@@ -202,7 +200,7 @@ class BatchedThinkingTests(unittest.TestCase):
     def test_one_thinking_request_covers_every_prompt_in_a_layer(self):
         client = TypeLLMClient(model="fake")
         client.sglang = FakeServer()
-        result = client.generate(context="Receipt", questions=thinks(self.QUESTIONS))
+        result = client.generate(context="Receipt", questions=thinks(self.QUESTIONS)).result
         self.assertEqual(result, {"flag": True, "count": 7, "name": "blue", "pick": "x"})
         [think] = client.sglang.requests("think")
         # Four fields plus the reversed ordering of "pick".
@@ -219,14 +217,14 @@ class BatchedThinkingTests(unittest.TestCase):
             "a": {"type": "boolean"}, "b": {"type": "integer"},
             "c": {"type": "boolean", "depends_on": ["a", "b"]},
             "d": {"type": "string", "depends_on": ["a"]},
-        }))
+        })).result
         self.assertEqual([width(p) for p in client.sglang.requests("think")], [2, 2])
 
     def test_images_count_prompt_tokens_in_one_batch(self):
         client = TypeLLMClient(model="fake")
         client.sglang = FakeServer()
         client.generate(context="Receipt", images=[PNG],
-                        questions=thinks({"a": {"type": "boolean"}, "b": {"type": "boolean"}}))
+                        questions=thinks({"a": {"type": "boolean"}, "b": {"type": "boolean"}})).result
         counts = [p for p in client.sglang.requests("count") if width(p) > 1]
         self.assertEqual([width(p) for p in counts], [2])
         [think] = client.sglang.requests("think")

{typellm-0.2.5 → typellm-0.2.6}/tests/test_concurrency.py

@@ -42,9 +42,9 @@ class SharedClientTests(unittest.TestCase):
         def run(n):
             client.generate(context=f"Receipt {n}", questions={
                 "a": {"type": "integer"}, "b": {"type": "boolean"},
-            })
+            }).result
             finished.wait()  # Every call has finished before any reads its prompts.
-            return n, client.last_prompts
+            return n, client._last_prompts.get()
 
         with ThreadPoolExecutor(8) as pool:
             for n, prompts in pool.map(run, range(16)):
@@ -56,22 +56,22 @@ class SharedClientTests(unittest.TestCase):
         client = TypeLLMClient(model="fake", seed=1)
         client.sglang = FakeServer()
         state = client.rng.getstate()
-        client.generate(context="Roll", questions=PICK, seed=5)
-        first = client.last_prompts
-        client.generate(context="Roll", questions=PICK, seed=5)
-        self.assertEqual(client.last_prompts, first)
+        client.generate(context="Roll", questions=PICK, seed=5).result
+        first = client._last_prompts.get()
+        client.generate(context="Roll", questions=PICK, seed=5).result
+        self.assertEqual(client._last_prompts.get(), first)
         self.assertEqual(client.rng.getstate(), state)
-        client.generate(context="Roll", questions=PICK)
+        client.generate(context="Roll", questions=PICK).result
         self.assertNotEqual(client.rng.getstate(), state)
 
     def test_clients_pickle_after_a_call(self):
         client = TypeLLMClient(model="fake")
         client.sglang = FakeServer()
-        client.generate(context="Receipt", questions={"b": {"type": "boolean"}})
+        client.generate(context="Receipt", questions={"b": {"type": "boolean"}}).result
         copy = pickle.loads(pickle.dumps(client))
-        self.assertEqual(copy.last_prompts, [])
-        copy.generate(context="Receipt", questions={"b": {"type": "boolean"}})
-        self.assertEqual(len(copy.last_prompts), 1)
+        self.assertEqual(copy._last_prompts.get(), [])
+        copy.generate(context="Receipt", questions={"b": {"type": "boolean"}}).result
+        self.assertEqual(len(copy._last_prompts.get()), 1)
 
 
 class MeteredServer(SlowServer):
@@ -102,19 +102,23 @@ class UsageTests(unittest.TestCase):
     def test_usage_sums_every_generate_request_of_the_call(self):
         client = TypeLLMClient(model="fake")
         client.sglang = MeteredServer()
-        self.assertIsNone(client.last_usage)
-        client.generate(context="Receipt", questions=self.QUESTIONS)
+        usage = client.generate(context="Receipt", questions=self.QUESTIONS).usage
         n = prompts_sent(client.sglang)
         # The input counts once, though every prompt carries it.
         sent = client.sglang.count_tokens("Receipt") + client.sglang.count_tokens(json.dumps(self.QUESTIONS))
-        self.assertEqual(client.last_usage, Usage(
+        self.assertEqual(usage, Usage(
             requests=len(client.sglang.payloads),
             prompt_tokens=10 * n, cached_tokens=4 * n, completion_tokens=n, input_tokens=sent,
         ))
-        self.assertGreater(client.last_usage.requests, 1)
+        self.assertGreater(usage.requests, 1)
         client.sglang.payloads.clear()
-        client.generate(context="Receipt", questions={"b": {"type": "boolean"}})
-        self.assertEqual(client.last_usage.requests, len(client.sglang.payloads))
+        usage = client.generate(context="Receipt", questions={"b": {"type": "boolean"}}).usage
+        self.assertEqual(usage.requests, len(client.sglang.payloads))
+
+    def test_usage_shows_billed_tokens_first_and_only_counts_it_has(self):
+        self.assertEqual(repr(Usage(input_tokens=66)), "Usage(input_tokens=66, thinking_tokens=0)")
+        self.assertEqual(repr(Usage(input_tokens=5, requests=2, prompt_tokens=30)),
+                         "Usage(input_tokens=5, thinking_tokens=0, requests=2, prompt_tokens=30)")
 
     def test_concurrent_calls_count_only_their_own_requests(self):
         client = TypeLLMClient(model="fake")
@@ -122,9 +126,9 @@ class UsageTests(unittest.TestCase):
         finished = threading.Barrier(4)
 
         def run(questions):
-            client.generate(context="Receipt", questions=questions)
+            usage = client.generate(context="Receipt", questions=questions).usage
             finished.wait()
-            return client.last_usage.requests
+            return usage.requests
 
         one = {"b": {"type": "boolean"}}
         with ThreadPoolExecutor(4) as pool:
@@ -137,13 +141,13 @@ class UsageTests(unittest.TestCase):
     def test_a_failed_call_still_reports_the_requests_it_made(self):
         client = TypeLLMClient(model="fake")
         client.sglang = MeteredServer(fail_after=2)
-        with self.assertRaisesRegex(SGLangError, "went away"):
+        with self.assertRaisesRegex(SGLangError, "went away") as caught:
             client.generate(context="Receipt", questions=self.QUESTIONS)
-        self.assertEqual(client.last_usage.requests, 2)
-        self.assertGreater(client.last_usage.input_tokens, 0)
-        with self.assertRaises(ValueError):
+        self.assertEqual(caught.exception.usage.requests, 2)
+        self.assertGreater(caught.exception.usage.input_tokens, 0)
+        with self.assertRaises(ValueError) as caught:
             client.generate(questions=self.QUESTIONS)
-        self.assertIsNone(client.last_usage)
+        self.assertFalse(hasattr(caught.exception, "usage"))  # refused before any work
 
 
 class DeadlineTests(unittest.TestCase):
@@ -158,13 +162,13 @@ class DeadlineTests(unittest.TestCase):
 
         client = TypeLLMClient(model="fake")
         client.sglang = Slower()
-        client.generate(context="Receipt", questions=self.QUESTIONS)
+        client.generate(context="Receipt", questions=self.QUESTIONS).result
         needed = len(client.sglang.payloads)
         client.sglang.payloads.clear()
-        with self.assertRaises(GenerationTimeout):
+        with self.assertRaises(GenerationTimeout) as caught:
             client.generate(context="Receipt", questions=self.QUESTIONS, timeout=0.05)
         self.assertLess(len(client.sglang.payloads), needed)
-        self.assertEqual(client.last_usage.requests, len(client.sglang.payloads))
+        self.assertEqual(caught.exception.usage.requests, len(client.sglang.payloads))
 
     def test_a_cancelled_call_sends_no_further_requests(self):
         cancel = threading.Event()
@@ -179,7 +183,7 @@ class DeadlineTests(unittest.TestCase):
         client = TypeLLMClient(model="fake")
         client.sglang = Cancelling()
         with self.assertRaises(GenerationCancelled):
-            client.generate(context="Receipt", questions=self.QUESTIONS, cancel=cancel)
+            client.generate(context="Receipt", questions=self.QUESTIONS, cancel=cancel).result
         self.assertEqual(len(client.sglang.payloads), 2)
 
     def test_socket_timeouts_never_outlast_the_call(self):
@@ -256,7 +260,7 @@ class DeadlineTests(unittest.TestCase):
         for kwargs in ({"timeout": 0}, {"timeout": -1}, {"timeout": True}, {"timeout": "5"},
                        {"cancel": True}):
             with self.subTest(**kwargs), self.assertRaises(ValueError):
-                client.generate(context="Receipt", questions={"b": {"type": "boolean"}}, **kwargs)
+                client.generate(context="Receipt", questions={"b": {"type": "boolean"}}, **kwargs).result
         self.assertEqual(client.sglang.paths, [])  # Rejected before even compiling.