typellm 0.2.0__tar.gz → 0.2.2__tar.gz

{typellm-0.2.0 → typellm-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typellm
-Version: 0.2.0
+Version: 0.2.2
 Summary: Type-Safe Decoding for Autoregressive LLMs
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://typellm.ai/
@@ -168,6 +168,9 @@ 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.
+
 Ask for a numeric answer without enumerating every possible value:
 
 ```python
@@ -229,23 +232,28 @@ result = client.generate(
 
 ## Thinking mode
 
-Thinking is off by default. Enable it when constructing the client:
+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
-client = TypeLLMClient(
-    "http://127.0.0.1:30000",
-    model="Qwen/Qwen3.8-27B",
-    thinking=True,
-)
-result = client.generate(context=context, questions=questions)
+result = 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?",
+                  "thinking": True, "thinking_budget": 1024},
+})
 ```
 
-Set `thinking_budget=2048` to cap reasoning per field; there is no budget by
-default. When reasoning reaches the budget, TypeLLM closes it and moves on to
-the typed answer.
+`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.
+
+After a call, `client.last_thinking` maps each field that thought to its
+reasoning, and `client.last_usage.thinking_tokens` counts the reasoning tokens.
 
-Models with always-on thinking still reason with `thinking=False`;
-`thinking_budget` applies to them too. See [Supported models](#supported-models).
+Models with always-on thinking reason on every field; `thinking_budget` applies
+to them too. See [Supported models](#supported-models).
 
 ## Image input
 
@@ -416,7 +424,7 @@ result = client.generate(
     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)
+# Usage(requests=4, prompt_tokens=1830, cached_tokens=1504, completion_tokens=7, thinking_tokens=0)
 ```
 
 `last_usage` reports the SGLang requests and tokens of the last call made in the

{typellm-0.2.0 → typellm-0.2.2}/README.md

@@ -153,6 +153,9 @@ 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.
+
 Ask for a numeric answer without enumerating every possible value:
 
 ```python
@@ -214,23 +217,28 @@ result = client.generate(
 
 ## Thinking mode
 
-Thinking is off by default. Enable it when constructing the client:
+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
-client = TypeLLMClient(
-    "http://127.0.0.1:30000",
-    model="Qwen/Qwen3.8-27B",
-    thinking=True,
-)
-result = client.generate(context=context, questions=questions)
+result = 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?",
+                  "thinking": True, "thinking_budget": 1024},
+})
 ```
 
-Set `thinking_budget=2048` to cap reasoning per field; there is no budget by
-default. When reasoning reaches the budget, TypeLLM closes it and moves on to
-the typed answer.
+`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.
+
+After a call, `client.last_thinking` maps each field that thought to its
+reasoning, and `client.last_usage.thinking_tokens` counts the reasoning tokens.
 
-Models with always-on thinking still reason with `thinking=False`;
-`thinking_budget` applies to them too. See [Supported models](#supported-models).
+Models with always-on thinking reason on every field; `thinking_budget` applies
+to them too. See [Supported models](#supported-models).
 
 ## Image input
 
@@ -401,7 +409,7 @@ result = client.generate(
     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)
+# Usage(requests=4, prompt_tokens=1830, cached_tokens=1504, completion_tokens=7, thinking_tokens=0)
 ```
 
 `last_usage` reports the SGLang requests and tokens of the last call made in the

{typellm-0.2.0 → typellm-0.2.2}/pyproject.toml

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

typellm-0.2.2/tests/test_batching.py

@@ -0,0 +1,237 @@
+import json
+import unittest
+
+from typellm import SGLangClient, TypeLLMClient
+from typellm.images import encode_image
+
+from tests.test_images import PNG, VisionTokenizer, fake_detokenize, fake_tokenize
+
+THINK_STOP = "</think>"
+
+
+class ThinkingTokenizer(VisionTokenizer):
+    def apply_chat_template(self, messages, *, add_generation_prompt, enable_thinking=False, **kwargs):
+        rendered = super().apply_chat_template(messages, add_generation_prompt=add_generation_prompt)
+        return rendered + ("<think>\n" if add_generation_prompt and enable_thinking else "")
+
+
+def is_number_pattern(pattern):
+    """Whether a regex is typellm's numeric one rather than the string one."""
+    return pattern.startswith((" ?-?", " ?(?:-?"))
+
+
+class FakeServer(SGLangClient):
+    """A real SGLangClient whose HTTP layer answers like SGLang.
+
+    Numeric fields decode to 7: the server prefers the end token, then "7".
+    """
+
+    def __init__(self):
+        super().__init__(model="fake")
+        self._chat_tokenizer = ThinkingTokenizer()
+        self._context_length_cache = 100_000
+        self.payloads = []
+
+    def _request(self, path, payload=None, *, allow_text=False):
+        if path == "/v1/tokenize":
+            return {"tokens": fake_tokenize(payload["prompt"])}
+        if path == "/v1/detokenize":
+            return {"text": fake_detokenize(payload["tokens"])}
+        assert path == "/generate", path
+        self.payloads.append(payload)
+        texts = [payload["text"]] if isinstance(payload["text"], str) else payload["text"]
+        params = payload["sampling_params"]
+        params = params if isinstance(params, list) else [params] * len(texts)
+        if "token_ids_logprob" in payload:
+            rows = payload["token_ids_logprob"]
+            rows = [rows] if isinstance(rows[0], int) else rows
+            out = []
+            for ids in rows:
+                # Like the real model: a number starts with the lone space token.
+                pick = ord(" ") if ord(" ") in ids else 1 if 1 in ids else ord("7") if ord("7") in ids else ids[0]
+                out.append({"meta_info": {"output_token_ids_logprobs": [
+                    [[0.0 if t == pick else -9.0, t, "?"] for t in ids]]}})
+        elif params[0].get("stop") == [THINK_STOP]:
+            out = [{"text": "Reasoned." + THINK_STOP, "meta_info": {}} for _ in texts]
+        elif "regex" in params[0]:
+            # The prompt ends with '{"name":'; a number's digits, or a string's quote,
+            # characters and '"}' follow.
+            out = [{"text": " 7}" if is_number_pattern(p["regex"]) else ' "blue"}',
+                    "meta_info": {"finish_reason": {"type": "stop"}}} for p in params]
+        elif "json_schema" in params[0]:
+            out = []
+            for p in params:
+                schema = json.loads(p["json_schema"])
+                # An object schema answers {"key": "blue"}; a plain string schema "blue".
+                value = {next(iter(schema["properties"])): "blue"} if schema["type"] == "object" else "blue"
+                out.append({"text": json.dumps(value), "meta_info": {"finish_reason": {"type": "stop"}}})
+        else:
+            out = [{"meta_info": {"prompt_tokens": 900}} for _ in texts]
+        return out[0] if isinstance(payload["text"], str) else out
+
+    def requests(self, kind):
+        def matches(p):
+            params = p["sampling_params"]
+            first = params[0] if isinstance(params, list) else params
+            return {"score": "token_ids_logprob" in p,
+                    "think": first.get("stop") == [THINK_STOP],
+                    "count": first.get("max_new_tokens") == 0}[kind]
+        return [p for p in self.payloads if matches(p)]
+
+
+def width(payload):
+    return 1 if isinstance(payload["text"], str) else len(payload["text"])
+
+
+def thinks(questions):
+    return {name: {**field, "thinking": True} for name, field in questions.items()}
+
+
+class PrefixWarmupTests(unittest.TestCase):
+    MIXED = {"a": {"type": "integer"}, "b": {"type": "number"}, "n": {"type": "string"},
+             "k": {"type": "string", "enum": ["x", "y"]}}
+
+    def test_the_context_is_warmed_before_any_batch_that_shares_it(self):
+        for thinking in (False, True):
+            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)
+                warm = client.sglang.requests("count")
+                self.assertEqual(len(warm), 1)
+                # First, before the thinking, number, text and scoring batches.
+                self.assertIs(client.sglang.payloads[0], warm[0])
+                self.assertIn("Receipt", warm[0]["text"])
+                self.assertNotIn('{"a":', warm[0]["text"])
+
+    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"}})
+        self.assertEqual(client.sglang.requests("count"), [])
+
+
+class PerFieldThinkingTests(unittest.TestCase):
+    def thinking_prompts(self, server):
+        return [t for p in server.requests("think")
+                for t in ([p["text"]] if isinstance(p["text"], str) else p["text"])]
+
+    def test_only_fields_that_ask_for_it_think(self):
+        client = TypeLLMClient(model="fake")
+        client.sglang = FakeServer()
+        result = client.generate(context="Receipt", questions={
+            "hard": {"type": "boolean", "instructions": "Hard?", "thinking": True},
+            "easy": {"type": "boolean", "instructions": "Easy?"},
+            "count": {"type": "integer"},
+        })
+        self.assertEqual(result, {"hard": True, "easy": True, "count": 7})
+        [prompt] = self.thinking_prompts(client.sglang)  # one batch, one prompt
+        self.assertIn("Hard?", prompt)
+        self.assertTrue(prompt.endswith("<think>\n"))
+        answers = [t for p in client.sglang.payloads if p not in client.sglang.requests("think")
+                   for t in ([p["text"]] if isinstance(p["text"], str) else p["text"])]
+        self.assertTrue(any("Easy?" in t and "<think>" not in t for t in answers))
+
+    def test_thinking_false_is_the_same_as_leaving_it_out(self):
+        client = TypeLLMClient(model="fake")
+        client.sglang = FakeServer()
+        client.generate(context="Receipt", questions={
+            "a": {"type": "boolean", "instructions": "A?", "thinking": True},
+            "b": {"type": "boolean", "instructions": "B?", "thinking": True},
+            "skip": {"type": "boolean", "instructions": "Skip?", "thinking": False},
+        })
+        prompts = self.thinking_prompts(client.sglang)
+        self.assertEqual(len(client.sglang.requests("think")), 1)
+        self.assertEqual(len(prompts), 2)
+        self.assertFalse(any("Skip?" in t for t in prompts))
+
+    def test_each_field_gets_its_own_budget(self):
+        client = TypeLLMClient(model="fake")
+        client.sglang = FakeServer()
+        client.sglang.thinking_budget = 500  # the client's budget, for fields without their own
+        client.generate(context="Receipt", questions={
+            "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},
+        })
+        [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"])}
+        self.assertEqual(budgets, {"Short?": 100, "Long?": 300, "Default?": 500})
+
+    def test_reasoning_and_its_tokens_are_reported_per_field(self):
+        class Metered(FakeServer):
+            def _request(self, path, payload=None, *, allow_text=False):
+                response = super()._request(path, payload, allow_text=allow_text)
+                if path == "/generate":
+                    params = payload["sampling_params"]
+                    thinking = (params[0] if isinstance(params, list) else params).get("stop") == [THINK_STOP]
+                    for item in response if isinstance(response, list) else [response]:
+                        item["meta_info"]["completion_tokens"] = 40 if thinking else 1
+                return response
+
+        client = TypeLLMClient(model="fake")
+        client.sglang = Metered()
+        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, {})
+
+    def test_invalid_settings_are_schema_errors(self):
+        from typellm import SchemaError
+        for field in ({"type": "boolean", "thinking": "yes"}, {"type": "boolean", "thinking_budget": 0},
+                      {"type": "boolean", "thinking_budget": 2.5}):
+            with self.subTest(field=field), self.assertRaises(SchemaError):
+                TypeLLMClient(model="fake").compile_schema({"type": "object", "properties": {"x": field}})
+
+
+class BatchedThinkingTests(unittest.TestCase):
+    QUESTIONS = {
+        "flag": {"type": "boolean"},
+        "count": {"type": "integer"},
+        "name": {"type": "string"},
+        "pick": {"type": "string", "enum": ["x", "y"], "permutations": "all"},
+    }
+
+    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))
+        self.assertEqual(result, {"flag": True, "count": 7, "name": "blue", "pick": "x"})
+        [think] = client.sglang.requests("think")
+        # Four fields plus the reversed ordering of "pick".
+        self.assertEqual(width(think), 5)
+        self.assertEqual(len(think["sampling_params"]), 5)
+        for payload in client.sglang.requests("score"):
+            texts = [payload["text"]] if isinstance(payload["text"], str) else payload["text"]
+            self.assertTrue(all("Reasoned." + THINK_STOP in t for t in texts))
+
+    def test_dag_thinks_once_per_layer(self):
+        client = TypeLLMClient(model="fake")
+        client.sglang = FakeServer()
+        client.generate(context="Receipt", questions=thinks({
+            "a": {"type": "boolean"}, "b": {"type": "integer"},
+            "c": {"type": "boolean", "depends_on": ["a", "b"]},
+            "d": {"type": "string", "depends_on": ["a"]},
+        }))
+        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"}}))
+        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")
+        self.assertEqual(think["image_data"], encode_image(PNG))
+
+
+if __name__ == "__main__":
+    unittest.main()

{typellm-0.2.0 → typellm-0.2.2}/tests/test_dependencies.py

@@ -102,7 +102,7 @@ class DependencyTests(unittest.TestCase):
         self.assertTrue(client.last_prompts[1].startswith(client.last_prompts[0]))
 
     def test_always_thinking_template_continuation_runs_once(self):
-        client = SGLangClient(thinking=False)
+        client = SGLangClient()
 
         class Tokenizer:
             chat_template = 'test'

{typellm-0.2.0 → typellm-0.2.2}/tests/test_grammar_fields.py

@@ -5,7 +5,7 @@ import unittest
 from typellm import SGLangError, TypeLLMClient
 from typellm.runtime import _numeric_text_is_complete, numeric_pattern
 
-from tests.test_batching import FakeServer, width
+from tests.test_batching import FakeServer, is_number_pattern, width
 from tests.test_nullable import NullServer
 
 
@@ -72,6 +72,20 @@ class GrammarNumberTests(unittest.TestCase):
         self.assertEqual(numbers["sampling_params"][0]["temperature"], 0)
         self.assertIn('{"a": 7}', client.last_prompts[0])
 
+    def test_numbers_and_strings_of_a_layer_share_one_request(self):
+        client = TypeLLMClient(model="fake")
+        client.sglang = FakeServer()
+        result = client.generate(context="Receipt", questions={
+            "a": {"type": "integer"}, "n": {"type": "string"},
+            "b": {"type": "number"}, "m": {"type": ["string", "null"]}})
+        self.assertEqual(result, {"a": 7, "n": "blue", "b": 7, "m": "blue"})
+        [request] = regex_requests(client.sglang)
+        self.assertEqual(width(request), 4)
+        patterns = [p["regex"] for p in request["sampling_params"]]
+        self.assertEqual([is_number_pattern(p) for p in patterns], [True, True, False, False])
+        self.assertTrue(all(t.endswith(k) for t, k in zip(request["text"], ('{"a":', '{"b":', '{"n":', '{"m":'))))
+        self.assertIn("null", patterns[3])
+
     def test_sampling_passes_the_temperature_and_no_truncation(self):
         client = TypeLLMClient(model="fake", mode="sample", temperature=0.7, seed=1)
         client.sglang = FakeServer()

{typellm-0.2.0 → typellm-0.2.2}/tests/test_images.py

@@ -255,7 +255,6 @@ class ImageRequestTests(unittest.TestCase):
 
     def test_thinking_budget_counts_image_tokens_on_the_server(self):
         client = FakeServerClient()
-        client.thinking = True
         client.thinking_budget = None
         client._context_length_cache = 1000
         prefix = VisionTokenizer().apply_chat_template(

{typellm-0.2.0 → typellm-0.2.2}/tests/test_protocols.py

@@ -39,8 +39,8 @@ class ProtocolTokenizer(FakeChatTokenizer):
 
 
 class ProtocolTests(unittest.TestCase):
-    def client(self, family, thinking=False, response=None):
-        client = SGLangClient(thinking=thinking, thinking_budget=64)
+    def client(self, family, response=None):
+        client = SGLangClient(thinking_budget=64)
         client._chat_tokenizer = ProtocolTokenizer(family)
         client._context_length_cache = 8192
         end = '</think>'
@@ -59,9 +59,9 @@ class ProtocolTests(unittest.TestCase):
 
     def test_gemma_is_rejected_before_inference(self):
         for thinking in (False, True):
-            client = self.client('gemma', thinking)
+            client = self.client('gemma')
             with self.assertRaisesRegex(SGLangError, 'Gemma 4.*not supported'):
-                client.render_chat([], add_generation_prompt=True)
+                client.render_chat([], add_generation_prompt=True, thinking=thinking)
             client._request.assert_not_called()
 
     def test_native_turn_stop_recovers_preserved_and_filtered_terminators(self):
@@ -69,7 +69,7 @@ class ProtocolTests(unittest.TestCase):
             for matched in (ending, token):
                 for suffix in ('', ending + '\n'):
                     with self.subTest(family=family, matched=matched, suffix=suffix):
-                        client = self.client(family, True, {
+                        client = self.client(family, {
                             'text': 'Keep reasoning' + suffix,
                             'meta_info': {'finish_reason': {'type': 'stop', 'matched': matched}},
                         })
@@ -91,15 +91,15 @@ class ProtocolTests(unittest.TestCase):
             ('Partial<|im_end|>', {'type': 'error', 'matched': 3}),
         ]:
             with self.subTest(text=text, finish=finish):
-                client = self.client('minicpm5', True, {'text': text, 'meta_info': {'finish_reason': finish}})
+                client = self.client('minicpm5', {'text': text, 'meta_info': {'finish_reason': finish}})
                 with self.assertRaises(SGLangError):
                     client._finish_thinking('<think>\n')
 
     def test_minicpm5_switch_and_ring_always_thinking(self):
         for family in ('minicpm5', 'ring'):
             for thinking in (False, True):
-                client = self.client(family, thinking)
-                prompt = client.render_chat([], add_generation_prompt=True)
+                client = self.client(family)
+                prompt = client.render_chat([], add_generation_prompt=True, thinking=thinking)
                 expected = thinking or family == 'ring'
                 self.assertEqual(client._request.called, expected)
                 parent = client.complete_chat_prefix(prompt, 'A')
@@ -108,9 +108,9 @@ class ProtocolTests(unittest.TestCase):
 
     def test_non_thinking_templates_reject_requested_thinking(self):
         for family in ('ling',):
-            client = self.client(family, True)
+            client = self.client(family)
             with self.assertRaisesRegex(SGLangError, 'may not support thinking'):
-                client.render_chat([], add_generation_prompt=True)
+                client.render_chat([], add_generation_prompt=True, thinking=True)
             client._request.assert_not_called()
 
 

{typellm-0.2.0 → typellm-0.2.2}/tests/test_text.py

@@ -63,13 +63,13 @@ class TextTests(unittest.TestCase):
                 TypeLLMClient(text_max_tokens=budget)
 
     def test_thinking_then_constrained_text(self):
-        client=TypeLLMClient(thinking=True)
+        client=TypeLLMClient()
         client.sglang._context_length_cache=8192
         client.sglang._chat_tokenizer=FakeChatTokenizer()
         client.sglang._chat_tokenizer.apply_chat_template=lambda *args,**kw: "assistant\n<think>\n" if kw["enable_thinking"] else "completed"
         responses=[{'text':'brief</think>'},[{'text':' "done"}','meta_info':{'finish_reason':{'type':'stop'}}}]]
         with patch.object(client.sglang,'_request',side_effect=responses) as request:
-            self.assertEqual(client.generate(state='x',questions={'t':{'type':'string'}}),{'t':'done'})
+            self.assertEqual(client.generate(state='x',questions={'t':{'type':'string','thinking':True}}),{'t':'done'})
             self.assertIn('</think>',request.call_args.args[1]['text'][0])
             self.assertTrue(request.call_args.args[1]['text'][0].endswith('{"t":'))
             self.assertIn('regex',request.call_args.args[1]['sampling_params'][0])

{typellm-0.2.0 → typellm-0.2.2}/tests/test_typellm.py

@@ -60,6 +60,12 @@ class FakeSGLang:
         self.number_patterns.extend(patterns)
         return [next(self.numbers, " 7}") for _ in prefixes]
 
+    def generate_fields(self, number_prefixes, patterns, number_max_tokens, text_prefixes, max_lengths,
+                        *, temperature=0, number_seed=0, text_seed=0, after_key=False, nullable=None):
+        numbers = self.generate_numbers(number_prefixes, patterns, number_max_tokens)
+        texts = self.generate_texts(text_prefixes, max_lengths) if text_prefixes else []
+        return numbers, texts
+
     def score_candidates(self, prefix, candidate_ids):
         self.prompts.append(prefix)
         self.candidate_sets.append(list(candidate_ids))
@@ -421,7 +427,7 @@ class ThinkingTests(unittest.TestCase):
         from typellm import run_schema
         self.assertIsNone(SGLangClient().thinking_budget)
         self.assertIsNone(TypeLLMClient().sglang.thinking_budget)
-        client = SGLangClient(thinking=True)
+        client = SGLangClient()
         client._chat_tokenizer = FakeChatTokenizer()
         client._context_length_cache = 8192
         client._request = Mock(return_value={"text": "Done.</think>"})
@@ -437,7 +443,7 @@ class ThinkingTests(unittest.TestCase):
 
     def make_client(self, response=None):
         from unittest.mock import Mock
-        client = SGLangClient(thinking=True, thinking_budget=128)
+        client = SGLangClient(thinking_budget=128)
         client._context_length_cache = 8192
         tokenizer = FakeChatTokenizer()
         tokenizer.apply_chat_template = Mock(return_value="assistant\n<think>\n")
@@ -447,7 +453,7 @@ class ThinkingTests(unittest.TestCase):
 
     def test_thinking_stops_before_constrained_answer(self):
         client = self.make_client()
-        prompt = client.render_chat([], add_generation_prompt=True)
+        prompt = client.render_chat([], add_generation_prompt=True, thinking=True)
         self.assertEqual(prompt, "assistant\n<think>\nWork done. </think>\n\n")
         self.assertNotIn("illegal answer", prompt)
         params = client._request.call_args.args[1]["sampling_params"]
@@ -458,7 +464,7 @@ class ThinkingTests(unittest.TestCase):
 
     def test_length_stop_forces_closure_and_retains_reasoning(self):
         client = self.make_client({"text": "Partial reasoning", "meta_info": {"finish_reason": {"type": "length"}}})
-        prompt = client.render_chat([], add_generation_prompt=True)
+        prompt = client.render_chat([], add_generation_prompt=True, thinking=True)
         self.assertIn("Partial reasoning", prompt)
         self.assertIn("I will now give the final answer.", prompt)
         self.assertTrue(prompt.endswith("</think>\n\n"))
@@ -493,7 +499,7 @@ class ThinkingTests(unittest.TestCase):
         for text in ("Partial", "Partial</think>"):
             client = self.make_client({"text": text, "meta_info": {"finish_reason": {"type": "abort"}}})
             with self.assertRaisesRegex(SGLangError, "aborted"):
-                client.render_chat([], add_generation_prompt=True)
+                client.render_chat([], add_generation_prompt=True, thinking=True)
 
     def test_forced_thinking_keeps_all_final_decoders(self):
         stops = [{"type": "length"}, {"type": "stop", "matched": "<|im_end|>"}]
@@ -522,20 +528,19 @@ class ThinkingTests(unittest.TestCase):
             client = self.make_client()
             client._request.return_value = response
             with self.subTest(response=response), self.assertRaises(SGLangError):
-                client.render_chat([], add_generation_prompt=True)
+                client.render_chat([], add_generation_prompt=True, thinking=True)
 
     def test_unsupported_template_does_not_generate(self):
         from typellm import SGLangError
         client = self.make_client()
         client._chat_tokenizer.apply_chat_template.return_value = "<think></think>"
         with self.assertRaisesRegex(SGLangError, "native chat template"):
-            client.render_chat([], add_generation_prompt=True)
+            client.render_chat([], add_generation_prompt=True, thinking=True)
         client._request.assert_not_called()
 
     def test_always_thinking_template_reasons_even_when_thinking_is_off(self):
         client = self.make_client()
-        client.thinking = False
-        prompt = client.render_chat([], add_generation_prompt=True)
+        prompt = client.render_chat([], add_generation_prompt=True)  # thinking not asked for
         self.assertEqual(prompt, "assistant\n<think>\nWork done. </think>\n\n")
         self.assertFalse(client._chat_tokenizer.apply_chat_template.call_args.kwargs["enable_thinking"])
 
@@ -546,12 +551,11 @@ class ThinkingTests(unittest.TestCase):
         self.assertFalse(client._chat_tokenizer.apply_chat_template.call_args.kwargs["enable_thinking"])
 
     def test_public_configuration_and_validation(self):
-        self.assertFalse(TypeLLMClient().sglang.thinking)
-        client = TypeLLMClient(thinking=True, thinking_budget=256)
-        self.assertTrue(client.sglang.thinking)
+        client = TypeLLMClient(thinking_budget=256)
         self.assertEqual(client.sglang.thinking_budget, 256)
-        for kwargs in [{"thinking": "false"}, {"thinking": 1}, {"thinking_budget": 0},
-                       {"thinking_budget": True}, {"thinking_budget": 1.5}]:
+        with self.assertRaises(TypeError):
+            TypeLLMClient(thinking=True)  # thinking is chosen per field
+        for kwargs in [{"thinking_budget": 0}, {"thinking_budget": True}, {"thinking_budget": 1.5}]:
             with self.subTest(kwargs=kwargs), self.assertRaises(ValueError):
                 TypeLLMClient(**kwargs)