annoscript 0.1.0__py3-none-any.whl

annoscript/test_metrics_server.py

@@ -0,0 +1,261 @@
+"""Metric persistence, explicit migration and real HTTP Backend/Runtime tests."""
+
+import asyncio
+from contextlib import closing
+import json
+from pathlib import Path
+import sqlite3
+import unittest
+from unittest.mock import patch
+
+import httpx
+
+from annoscript._client_common import Result
+from annoscript._test_evaluation_http import http_backends, llm_calls, llm_content
+from annoscript.compiler import compile_program
+from annoscript.metrics import validate_metrics
+from annoscript.server.migrate import migrate
+from annoscript.server.store import SCHEMA_V1, ServiceError, Store
+from annoscript.server.worker import Worker
+from annoscript.server.releases import Releases
+from annoscript.test_jobs import generate
+from annoscript.test_jobs_server import ExecutionTests, StoreTests, payload, configurations
+
+
+def reused(anno):
+    a = anno.generate("same request", max_length=512)
+    b = anno.generate("same request", max_length=512)
+    return [a.text, b.text]
+
+
+def concurrent(anno):
+    a = anno.generate("first", max_length=512)
+    b = anno.generate("second", max_length=512)
+    return [a.text, b.text]
+
+
+class MetricStoreTests(StoreTests):
+    # Only new methods are discovered in this subclass (the existing suite runs
+    # independently); inheritance provides a small setup/helper harness.
+    def test_metric_fencing_retry_unknown_and_once_only(self):
+        job = self.submit(states=("a",))
+        claim = self.claim()
+        self.store.meter_attempt(claim, True)
+        self.store.request_started(claim, "r1", "generation", 1)
+        self.store.request_started(claim, "r1", "generation", 1)
+        self.store.request_finished(claim, "r1", seconds=1, http_status=200, usage={"prompt_tokens": 10, "completion_tokens": 2})
+        self.store.request_finished(claim, "r1", seconds=9, http_status=200, usage={"prompt_tokens": 100})
+        self.store.request_started(claim, "uncertain", "generation", 1)
+        self.clock.now += 61
+        replacement = self.claim()
+        self.assertFalse(self.store.request_finished(claim, "uncertain", seconds=1, http_status=200, usage={}))
+        self.store.meter_attempt(replacement, True)
+        self.store.request_started(replacement, "r2", "generation", 1)
+        self.store.request_finished(replacement, "r2", seconds=2, http_status=200, usage={"prompt_tokens": 7, "completion_tokens": 3})
+        self.store.finish(replacement, Result(0, "success", "a"), elapsed_seconds=3)
+        value = self.store.metrics("alice", job["job_id"])
+        validate_metrics(value, job["job_id"])
+        g = value["summary"]["backends"]["generation"]
+        self.assertEqual((g["requests"], g["unknown_requests"], g["input_tokens"]["observed"]), (3, 1, 17))
+        self.assertIsNone(g["input_tokens"]["total"])
+        self.assertIsNone(value["summary"]["attempts"]["seconds"]["total"])
+        self.assertEqual(value["summary"]["attempts"]["count"], 2)
+        self.assertEqual(Store(self.path, clock=self.clock).metrics("alice", job["job_id"]), value)
+
+    def test_cancel_and_expiration_authorization_and_queue_epoch(self):
+        self.store.monotonic = lambda: 10
+        job = self.submit(states=("a",))
+        self.store.monotonic = lambda: 13
+        claim = self.claim()
+        self.store.meter_attempt(claim, True)
+        self.store.request_started(claim, "r", "decision", 4)
+        self.store.cancel("alice", job["job_id"])
+        self.assertFalse(self.store.request_finished(claim, "r", seconds=1, http_status=200, usage={}))
+        value = self.store.metrics("alice", job["job_id"])
+        self.assertEqual(value["summary"]["queue_wait_seconds"]["total"], 3)
+        self.assertEqual(value["summary"]["backends"]["decision"]["unknown_requests"], 1)
+        with self.assertRaises(ServiceError) as error:
+            self.store.metrics("bob", job["job_id"])
+        self.assertEqual(error.exception.status, 404)
+        self.clock.now += 8 * 86400
+        with self.assertRaises(ServiceError) as error:
+            self.store.metrics("alice", job["job_id"])
+        self.assertEqual(error.exception.status, 410)
+        job2 = self.submit(states=("b",), key="new")
+        self.store.clock_epoch = "different-boot"
+        claim2 = self.claim()
+        self.store.meter_attempt(claim2, True)
+        self.store.finish(claim2, Result(0, "success", "b"), elapsed_seconds=1)
+        self.assertIsNone(self.store.metrics("alice", job2["job_id"])["summary"]["queue_wait_seconds"]["total"])
+
+    def legacy_copy(self):
+        path = Path(self.folder.name, "legacy.sqlite")
+        with closing(sqlite3.connect(path)) as old, closing(sqlite3.connect(self.path)) as new:
+            old.executescript(SCHEMA_V1)
+            for table in ("releases", "sessions", "jobs", "inputs", "attempts", "results", "resume_ops"):
+                names = [r[1] for r in old.execute(f"PRAGMA table_info({table})")]
+                rows = new.execute(f"SELECT {','.join(names)} FROM {table}").fetchall()
+                old.executemany(f"INSERT INTO {table} VALUES ({','.join('?' for _ in names)})", rows)
+            old.commit()
+        return path
+
+    def test_explicit_migration_preserves_binding_backup_and_history(self):
+        job = self.submit(states=("a",))
+        self.store.finish(self.claim(), Result(0, "success", "a"))
+        legacy = self.legacy_copy()
+        with self.assertRaisesRegex(RuntimeError, "schema 1"):
+            Store(legacy)
+        backup = Path(self.folder.name, "backup.sqlite")
+        migrate(legacy, backup)
+        upgraded = Store(legacy, clock=self.clock)
+        self.assertEqual(upgraded.lookup("alice", "job"), job | {"state": "completed", "counts": {"total": 1, "completed": 1, "success": 1, "error": 0}})
+        value = upgraded.metrics("alice", job["job_id"])
+        self.assertFalse(value["summary"]["history_complete"])
+        self.assertIsNone(value["summary"]["backends"]["generation"]["total_requests"])
+        self.assertEqual(upgraded.results("alice", job["job_id"])["results"][0]["value"], "a")
+        with closing(sqlite3.connect(backup)) as db:
+            self.assertEqual(db.execute("PRAGMA user_version").fetchone()[0], 1)
+            self.assertEqual(db.execute("SELECT COUNT(*) FROM results").fetchone()[0], 1)
+
+    def test_migration_rolls_back_and_does_not_replace_backup(self):
+        legacy = self.legacy_copy()
+        backup = Path(self.folder.name, "backup.sqlite")
+        def fail(statement):
+            raise RuntimeError("simulated failure")
+        with self.assertRaisesRegex(RuntimeError, "simulated"):
+            migrate(legacy, backup, _after_statement=fail)
+        with closing(sqlite3.connect(legacy)) as db:
+            self.assertEqual(db.execute("PRAGMA user_version").fetchone()[0], 1)
+            self.assertNotIn("metrics_available", [r[1] for r in db.execute("PRAGMA table_info(jobs)")])
+        with self.assertRaises(FileExistsError):
+            migrate(legacy, backup)
+
+
+class MetricExecutionTests(ExecutionTests):
+    def test_runtime_reuse_is_one_physical_request(self):
+        requests = []
+        client = self.client()
+        job = client.submit_ir(compile_program(reused, optimize=False), [{"index": 0, "state": "hello"}], idempotency_key="reuse")
+        self.run_claim(lambda _: http_backends(requests=requests))
+        self.assertEqual(len(requests), 1)
+        self.assertEqual(client.metrics(job)["summary"]["backends"]["generation"]["total_requests"], 1)
+
+    def test_concurrent_http_sums_are_not_attempt_wall_time(self):
+        from annoscript.backends import DecisionAPIBackend
+        from annoscript._test_evaluation_http import FixtureLLMBackend as LLMAPIBackend
+        started = []
+        async def handle(request):
+            started.append(request)
+            while len(started) < 2:
+                await asyncio.sleep(0)
+            return httpx.Response(200, json={"choices": [{"finish_reason": "stop", "message": {"content": "hello"}}],
+                                            "usage": {"prompt_tokens": 1, "completion_tokens": 1}})
+        def factory(_):
+            transport = httpx.MockTransport(handle)
+            return (DecisionAPIBackend("http://offline", "fixture", "fixture", transport=transport),
+                    LLMAPIBackend("http://offline", "fixture", "fixture", transport=transport))
+        # This test needs two independent physical HTTP requests, irrespective
+        # of the default batching optimization covered by the car tests.
+        config = configurations()
+        config["test"]["runtime"] = {"max_llm_batch_calls": 1}
+        configured = Releases(config, "test")
+        self.releases.manifests.update(configured.manifests)
+        self.releases.default = configured.default
+        client = self.client()
+        job = client.submit_ir(compile_program(concurrent), [{"index": 0, "state": "hello"}], idempotency_key="concurrent")
+        ticks = iter((0., 0., 10., 10.))
+        from annoscript.server.metrics import RequestMeter
+        original = RequestMeter.__init__
+        def meter_init(instance, *args, **kwargs):
+            original(instance, *args, **kwargs)
+            instance.clock = lambda: next(ticks)
+        with patch.object(RequestMeter, "__init__", meter_init):
+            self.run_claim(factory)
+        summary = client.metrics(job)["summary"]
+        self.assertEqual(summary["backends"]["generation"]["http_seconds"]["total"], 20)
+        self.assertLess(summary["attempts"]["seconds"]["total"], 20)
+
+    def test_mixed_batch_and_local_repair_meter_each_http_once(self):
+        from annoscript.test_llm_batch import mixed_generation, answer, completion
+        requests = []
+        def fail_one(body):
+            content = llm_content(body, answer)
+            if llm_calls(body)[0]:
+                value = json.loads(content)
+                del value["answers"][next(iter(value["answers"]))]
+                content = json.dumps(value)
+            return completion(content)
+        client = self.client()
+        job = client.submit_ir(compile_program(mixed_generation), [{"index": 0, "state": "广州与北京"}],
+                               idempotency_key="batch-repair-metrics")
+        self.run_claim(lambda _: http_backends(requests=requests, override=fail_one))
+        self.assertEqual(client.fetch_results(job)["results"][0]["status"], "success")
+        self.assertEqual([len(llm_calls(r)[1]) for r in requests], [3, 1])
+        g = client.metrics(job)["summary"]["backends"]["generation"]
+        self.assertEqual((g["requests"], g["questions"], g["unknown_requests"]), (2, 4, 0))
+        self.assertEqual((g["input_tokens"]["total"], g["output_tokens"]["total"]), (26, 10))
+
+
+    def test_content_repair_budget_resets_only_with_new_execution_attempt(self):
+        from annoscript.test_llm_batch import mixed_generation, answer, completion
+        requests, repairs = [], []
+        def response(body):
+            content = llm_content(body, answer)
+            if llm_calls(body)[0]:
+                value = json.loads(content)
+                del value["answers"][next(iter(value["answers"]))]
+                return completion(json.dumps(value))
+            repairs.append(body)
+            if len(repairs) == 1:
+                return httpx.Response(429, json={"usage": {"prompt_tokens": 4, "completion_tokens": 0}},
+                                      headers={"Retry-After": "0"})
+            return completion(content)
+        client = self.client()
+        job = client.submit_ir(compile_program(mixed_generation), [{"index": 0, "state": "广州与北京"}],
+                               idempotency_key="repair-per-attempt")
+        for _ in range(2):
+            self.run_claim(lambda _: http_backends(requests=requests, override=response))
+        self.assertEqual(client.fetch_results(job)["results"][0]["attempts"], 2)
+        self.assertEqual(client.fetch_results(job)["results"][0]["status"], "success")
+        self.assertEqual([len(llm_calls(r)[1]) for r in requests], [3, 1, 3, 1])
+        metrics = client.metrics(job)["summary"]["backends"]["generation"]
+        self.assertEqual((metrics["requests"], metrics["questions"], metrics["input_tokens"]["total"]), (4, 8, 43))
+
+    def test_retry_usage_survives_pause_and_resume(self):
+        client = self.client()
+        job = client.submit_ir(compile_program(generate), [{"index": 0, "state": "hello"}], idempotency_key="retry-metrics")
+        def fail(body):
+            return httpx.Response(429, json={"usage": {"prompt_tokens": 4, "completion_tokens": 0}}, headers={"Retry-After": "0"})
+        for _ in range(3):
+            self.run_claim(lambda _: http_backends(override=fail))
+        status = client.status(job)
+        self.assertEqual(status["state"], "paused")
+        self.assertEqual(client.metrics(job)["summary"]["backends"]["generation"]["input_tokens"]["total"], 12)
+        client.resume(job, pause_generation=status["pause_generation"], idempotency_key="resume-metrics")
+        self.run_claim(lambda _: http_backends())
+        metrics = client.metrics(job)
+        self.assertEqual(metrics["summary"]["attempts"]["count"], 4)
+        self.assertEqual(metrics["summary"]["backends"]["generation"]["input_tokens"]["total"], 19)
+
+    def test_timeout_and_missing_usage_are_not_zero(self):
+        for name in ("timeout", "missing"):
+            client = self.client()
+            job = client.submit_ir(compile_program(generate), [{"index": 0, "state": "hello"}], idempotency_key=name)
+            def response(body):
+                if name == "timeout":
+                    raise httpx.ReadTimeout("offline")
+                return httpx.Response(200, json={"choices": [{"finish_reason": "stop", "message": {"content": "hello"}}]})
+            self.run_claim(lambda _: http_backends(override=response))
+            g = client.metrics(job)["summary"]["backends"]["generation"]
+            self.assertIsNone(g["input_tokens"]["total"])
+            self.assertEqual(g["input_tokens"]["unknown"], 1)
+            self.assertEqual(g["unknown_requests"], int(name == "timeout"))
+            client.cancel(job)
+
+
+# Reuse setup helpers, not the inherited test cases themselves.
+for cls, base in ((MetricStoreTests, StoreTests), (MetricExecutionTests, ExecutionTests)):
+    for name in base.__dict__:
+        if name.startswith("test_") and name not in cls.__dict__:
+            setattr(cls, name, None)
+del StoreTests, ExecutionTests, cls, base

annoscript/test_minimal_fusion.py

@@ -0,0 +1,59 @@
+"""Minimal fusion regression: synthetic fixtures only; no live model calls."""
+import json
+import unittest
+from copy import deepcopy
+import httpx
+
+from annoscript.backends import InferenceContext
+from annoscript._test_evaluation_http import FixtureLLMBackend as LLMAPIBackend
+from annoscript.backends.base import normalize_call
+from annoscript._test_evaluation_http import llm_calls, llm_content
+from annoscript.test_llm_batch import completion
+from annoscript.anno import GenerateListResponse, ExtractResponse
+from annoscript.server.releases import Releases
+from annoscript.test_jobs_server import configurations
+
+
+
+class LayoutBudgetTests(unittest.IsolatedAsyncioTestCase):
+    async def test_inline_single_batch_and_repair_preserve_sources_and_160_budget(self):
+        ctx=InferenceContext({'text':'广州😀é\\"\n'},'固定策略')
+        calls=[normalize_call('name','generate_list',('名称',),dict(min_items=0,max_items=1,min_length_per_item=1,max_length_per_item=80,max_num_tokens=160),ctx),
+               normalize_call('e','extract',('片段',),dict(source_field='text',max_items=2,max_length_per_item=20),ctx)]
+        for profile in ('legacy','qwen_vllm'):
+            sent=[];events=[]
+            def handle(req):
+                body=json.loads(req.content);sent.append(body)
+                return completion(llm_content(body,lambda c,x: GenerateListResponse(['名称']) if x.operation=='generate_list' else ExtractResponse(['广州'])))
+            b=LLMAPIBackend('http://offline.invalid','fixture','fixture',profile=profile,
+                           transport=httpx.MockTransport(handle),diagnostic_observer=events.append)
+            try:
+                for c in calls: await b.infer(ctx,c)
+                await b.infer(ctx,calls[0],repair_feedback='invalid',max_tokens_override=160)
+                await b.infer(ctx,calls[1],repair_feedback='invalid')
+                plan=b.plan_batch(ctx,calls,max_calls=8,max_input_bytes=262144,max_output_tokens=4096,default_tokens=1024)
+                await b.infer_batch(ctx,plan.calls,max_tokens=plan.max_tokens,prepared=plan.prepared)
+                self.assertEqual(sent[0]['max_tokens'],160);self.assertEqual(sent[2]['max_tokens'],160)
+                self.assertEqual(plan.max_tokens,64+160+32+(2*2*20+32+8*2)+32)
+                for body in (sent[1],sent[3],sent[4]):
+                    payload=json.loads(body['messages'][-1]['content'])
+                    self.assertNotIn('source_ref',json.dumps(payload))
+                    self.assertEqual(json.dumps(body['messages'],ensure_ascii=False).count('广州'),1)
+                    self.assertEqual(llm_calls(body)[1][-1][1].extraction_source,ctx.state['text'])
+                self.assertTrue(all(e['source_layout']=='source_field_v1' for e in events if 'source_layout' in e))
+            finally:await b.aclose()
+
+    async def test_obsolete_layout_rejected_and_release_records_new_binding(self):
+        for value in ('inline','state_refs_v1',False,'bad'):
+            with self.assertRaisesRegex(TypeError, 'source_layout'):
+                LLMAPIBackend('http://offline.invalid','fixture','m',source_layout=value)
+            cfg=configurations()['test'];cfg['generation']['source_layout']=value
+            with self.assertRaisesRegex(ValueError, 'source_layout was removed'):
+                Releases({'test':cfg},'test')
+        release=Releases(configurations(),'test')
+        self.assertEqual(release.manifests[release.default]['engineering']['qwen_source_layout'],'source_field_v1')
+
+if __name__=='__main__':unittest.main()
+
+class WorkerFusionTests(unittest.TestCase):
+    pass

annoscript/test_nullable_generate.py

@@ -0,0 +1,169 @@
+"""Native nullable scalars, default compatibility and mixed runtime requests."""
+
+import asyncio
+from dataclasses import replace
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+import httpx
+
+from annoscript._data import thaw
+from annoscript._test_evaluation_http import FixtureLLMBackend, llm_calls
+from annoscript.backends import InferenceContext, InferenceError, LLMAPIBackend
+from annoscript.backends.base import normalize_call, validate_response
+from annoscript.compiler import compile_program
+from annoscript.ir import Program
+from annoscript.anno import GenerateResponse
+from annoscript.plan import ExecutionPlan
+from annoscript.plan_lowering import lower_to_plan
+from annoscript.runtime import AnnoRuntime, RunInput
+from annoscript.server.releases import Releases
+from annoscript.server.store import Store
+from annoscript.server.worker import Worker
+from annoscript.test_jobs_server import configurations, payload
+from annoscript.test_runtime import FakeBackend
+
+
+def optional_calls(anno):
+    normal = anno.generate("same", min_length=1, max_length=24, max_num_tokens=64).text
+    optional = anno.generate("same", min_length=1, max_length=24, max_num_tokens=64, nullable=True).text
+    again = anno.generate("same", min_length=1, max_length=24, max_num_tokens=64, nullable=True).text
+    return [normal, optional, again]
+
+
+def completion(content):
+    return httpx.Response(200, json={"choices": [{"finish_reason": "stop", "message": {"content": content}}],
+                                     "usage": {"prompt_tokens": 7, "completion_tokens": 2}})
+
+
+def fixture_handler(sent, repair=False):
+    def handle(request):
+        body = json.loads(request.content); sent.append(body)
+        batched, calls = llm_calls(body)
+        values = [None if call.arguments.get("nullable") else "normal" for _, call in calls]
+        if batched:
+            if repair:
+                values = [[] if value is None else value for value in values]
+            return completion(json.dumps({"answers": {f"q{i}": value for i, value in enumerate(values, 1)}}))
+        return completion(json.dumps(values[0]) if calls[0][1].arguments.get("nullable") else values[0])
+    return handle
+
+
+class NullableGenerateTests(unittest.IsolatedAsyncioTestCase):
+    def call(self, *, identity="internal", **options):
+        return normalize_call(identity, "generate", ("标签",),
+                              {"min_length": 1, "max_length": 24, "max_num_tokens": 64, **options},
+                              InferenceContext("合成正文"))
+
+    async def test_false_is_exact_default_and_true_binds_cache_and_examples(self):
+        ctx = InferenceContext("合成正文")
+        backend = LLMAPIBackend("http://offline.invalid", "fixture", "fixture", profile="qwen_vllm")
+        try:
+            a, b, c = self.call(), self.call(nullable=False), self.call(nullable=True)
+            self.assertEqual(a, b)
+            self.assertNotIn("nullable", a.arguments)
+            for batch in (False, True):
+                pa = backend._prepare(ctx, [a], 64, batch=batch)
+                pb = backend._prepare(ctx, [b], 64, batch=batch)
+                pc = backend._prepare(ctx, [c], 64, batch=batch)
+                self.assertEqual((pa.binding, pa.body), (pb.binding, pb.body))
+                self.assertNotEqual(pa.binding, pc.binding)
+            for invalid in (None, 0, 1, "true", [], {}):
+                with self.subTest(value=invalid), self.assertRaisesRegex(ValueError, "nullable"):
+                    self.call(nullable=invalid)
+            for answer in (None, "评价", "null"):
+                self.call(nullable=True, examples=[{"state": "示例", "answer": answer}])
+            with self.assertRaises(ValueError):
+                self.call(examples=[{"state": "示例", "answer": None}])
+            validate_response(c, GenerateResponse(None))
+            empty_allowed = self.call(nullable=True, min_length=0)
+            validate_response(empty_allowed, GenerateResponse(""))
+            validate_response(empty_allowed, GenerateResponse(None))
+            validate_response(c, GenerateResponse(" \t"))  # Business constrain rejects whitespace separately.
+            with self.assertRaisesRegex(InferenceError, "generated text must be a string and satisfy nonempty requirement"):
+                validate_response(a, GenerateResponse(None))
+        finally:
+            await backend.aclose()
+
+    async def test_single_repair_strict_json_scalars_and_null_diagnostics(self):
+        ctx = InferenceContext("合成正文")
+        for profile in ("legacy", "qwen_vllm"):
+            for feedback in (None, "invalid response"):
+                for value in (None, "null", "评价", '甲"\\\n😀'):
+                    sent = []
+                    def handle(request):
+                        sent.append(json.loads(request.content)); return completion(json.dumps(value, ensure_ascii=False))
+                    backend = LLMAPIBackend("http://offline.invalid", "fixture", "fixture", profile=profile,
+                                            transport=httpx.MockTransport(handle))
+                    try:
+                        out = await backend.infer(ctx, self.call(nullable=True), repair_feedback=feedback)
+                        self.assertEqual(out.response.text, value)
+                        observed = out.metadata["advisory_lengths"]["internal"]
+                        self.assertEqual(observed["is_null"], value is None)
+                        self.assertEqual(observed["actual_codepoints"], [] if value is None else [len(value)])
+                        self.assertEqual(sent[0]["max_tokens"], 64)
+                        self.assertIn("JSON null", sent[0]["messages"][0]["content"])
+                    finally:
+                        await backend.aclose()
+            for raw in ('[]', '["评价"]', '{}', '1', 'true', '""', '未加引号', '"截断', ''):
+                backend = LLMAPIBackend("http://offline.invalid", "fixture", "fixture", profile=profile,
+                                        transport=httpx.MockTransport(lambda r: completion(raw)))
+                try:
+                    with self.subTest(profile=profile, raw=raw), self.assertRaises(InferenceError):
+                        await backend.infer(ctx, self.call(nullable=True))
+                finally:
+                    await backend.aclose()
+        # Ordinary raw text "null" retains its literal value.
+        backend = LLMAPIBackend("http://offline.invalid", "fixture", "fixture",
+                                transport=httpx.MockTransport(lambda r: completion("null")))
+        try:
+            self.assertEqual((await backend.infer(ctx, self.call())).response.text, "null")
+        finally:
+            await backend.aclose()
+
+
+    async def test_ir_runtime_reuse_and_repair_in_all_modes(self):
+        for optimize in (False, True):
+            program = Program.from_json(compile_program(optional_calls, optimize=optimize).to_json())
+            plan = ExecutionPlan.from_json(lower_to_plan(program).to_json())
+            for mode in ("strict", "eager", "speculative"):
+                for repair in (False, True):
+                    sent = []
+                    backend = FixtureLLMBackend("http://offline.invalid", "fixture", "fixture", profile="qwen_vllm",
+                                                transport=httpx.MockTransport(fixture_handler(sent, repair)))
+                    async with AnnoRuntime(FakeBackend(), backend, trace=True) as runtime:
+                        rows = [r async for r in await runtime.submit(plan, [RunInput(0, "正文")], mode=mode)]
+                    self.assertEqual(rows[0].status, "success", rows[0])
+                    self.assertEqual(rows[0].value, ["normal", None, None])
+                    expected = 3 if repair and mode != "strict" else 2
+                    self.assertEqual(sum(len(llm_calls(body)[1]) for body in sent), expected)
+                    self.assertTrue(all(body["max_tokens"] == (256 if llm_calls(body)[0] else 64) for body in sent))
+
+
+class DurableNullableTests(unittest.TestCase):
+    def test_native_worker_persists_none_and_collect_never_infers(self):
+        with tempfile.TemporaryDirectory() as directory:
+            store = Store(Path(directory) / "jobs.sqlite")
+            releases = Releases(configurations(), "test")
+            sent = []
+            def factory(_):
+                return FakeBackend(), FixtureLLMBackend("http://offline.invalid", "fixture", "fixture", profile="qwen_vllm",
+                                                        transport=httpx.MockTransport(fixture_handler(sent)))
+            job = store.submit("alice", "nullable", payload(("甲", "乙"), mode="speculative", program=optional_calls), releases)
+            worker = Worker(store, releases, backend_factory=factory)
+            async def run():
+                while (claim := store.claim("worker", releases)) is not None:
+                    await worker.execute(claim)
+                await worker.aclose()
+            asyncio.run(run()); before = len(sent)
+            for _ in range(2):
+                rows = store.results("alice", job["job_id"])["results"]
+                self.assertEqual([r["value"] for r in rows], [["normal", None, None]] * 2)
+                self.assertIsNone(store.claim("worker", releases))
+            self.assertEqual(len(sent), before)
+
+
+if __name__ == "__main__":
+    unittest.main()