annoscript 0.1.0__py3-none-any.whl

annoscript/test_backends.py

@@ -0,0 +1,181 @@
+"""Protocol and contract checks use HTTPX transports, never real credentials."""
+
+import asyncio
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+import httpx
+
+from annoscript.backends import DecisionAPIBackend, LLMAPIBackend, InferenceContext, InferenceError, BackendFatalError
+from annoscript.backends.base import normalize_call, validate_response
+from annoscript.backends.config import backends_from_env
+from annoscript.anno import ChoiceResponse, GenerateResponse, ExtractResponse, GenerateListResponse
+
+
+class BackendTests(unittest.IsolatedAsyncioTestCase):
+    async def test_decision_mixed_payload_and_id_mapping(self):
+        context = InferenceContext({"text": "中文"}, "共同规则")
+        calls = [normalize_call("q1", "noul", ("是否",), {}, context),
+                 normalize_call("q2", "choice", ("选项", {"a": "甲", "b": "乙"}), {}, context),
+                 normalize_call("q3", "score", ("程度", ["低", "高"]), {}, context)]
+        async def handle(request):
+            self.assertEqual(str(request.url), "https://decision.invalid/full/path")
+            self.assertEqual(request.headers["Authorization"], "Bearer secret")
+            body = json.loads(request.content)
+            self.assertEqual(body["state"], {"text": "中文"})
+            self.assertEqual(list(body["questions"]), ["q1", "q2", "q3"])
+            self.assertNotIn("criteria", body["questions"]["q1"])
+            self.assertEqual([q["instructions"] for q in body["questions"].values()], ["是否", "选项", "程度"])
+            return httpx.Response(200, json={"answers": {
+                "q3": {"type": "score", "score": 0.7, "confidence": 0.8, "probabilities": {"0": 0.3, "1": 0.7}, "legend": {"0": "低", "1": "高"}},
+                "q1": {"type": "noul", "noul": 0.8},
+                "q2": {"type": "choice", "choice": "b", "confidence": 0.9, "probabilities": {"a": 0.1, "b": 0.9}},
+            }, "usage": {"input_tokens": 20, "output_tokens": 4}})
+        backend = DecisionAPIBackend("https://decision.invalid/full/path", "secret", "model", transport=httpx.MockTransport(handle))
+        try:
+            result = await backend.infer_batch(context, calls)
+            self.assertEqual(result.responses["q2"].choice, "b")
+            self.assertEqual(result.responses["q3"].legend, {0: "低", 1: "高"})
+            self.assertEqual(result.metadata["usage"], {"input_tokens": 20, "output_tokens": 4})
+            client = backend._client
+            await backend.infer_batch(context, calls)
+            self.assertIs(backend._client, client)
+        finally:
+            await backend.aclose()
+
+    async def test_llm_mapping_limits_extraction_source_and_thinking(self):
+        context = InferenceContext({"text": "原文甲", "other": "独立来源广州"}, "共享政策")
+        for operation, args, options, answer in (
+            ("generate", ("简述",), {"min_length": 1, "max_length": 2, "max_num_tokens": 16}, "中文"),
+            ("generate_list", ("列出",), {"min_items": 1, "max_items": 8, "max_length_per_item": 2}, '{"items":["中文"]}'),
+            ("extract", ("抽取",), {"source_field": "other", "min_items": 1, "max_items": 8, "max_length_per_item": 58}, '{"items":["广州"]}'),
+        ):
+            with self.subTest(operation=operation):
+                async def handle(request):
+                    body = json.loads(request.content)
+                    self.assertEqual(str(request.url), "https://llm.invalid/v1/chat/completions")
+                    self.assertEqual(body["thinking"], {"type": "disabled"})
+                    self.assertTrue(body["messages"][0]["content"].startswith("共享政策\n"))
+                    payload = json.loads(body["messages"][-1]["content"])
+                    self.assertEqual(payload, {"text": "原文甲", "other": "独立来源广州"})
+                    if operation == "extract":
+                        self.assertIn('输入的顶层字段 "other"', body["messages"][0]["content"])
+                    if operation == "generate":
+                        self.assertNotIn("response_format", body)
+                        self.assertEqual(body["max_tokens"], 16)
+                    else:
+                        self.assertEqual(body["response_format"], {"type": "json_object"})
+                        self.assertGreater(body["max_tokens"], 0)
+                    return httpx.Response(200, json={"choices": [{"finish_reason": "stop", "message": {"content": answer, "reasoning_content": "never record this"}}], "usage": {"completion_tokens": 4}})
+                backend = LLMAPIBackend("https://llm.invalid/v1", "secret", "model", transport=httpx.MockTransport(handle))
+                try:
+                    result = await backend.infer(context, normalize_call("q", operation, args, options, context))
+                    self.assertNotIn("reasoning", json.dumps(result.metadata))
+                finally:
+                    await backend.aclose()
+
+    async def test_http_failures_are_sanitized_and_not_retried(self):
+        context = InferenceContext("x")
+        call = normalize_call("q", "generate", ("task",), {'max_length': 512}, context)
+        for status, error in ((401, BackendFatalError), (403, BackendFatalError), (429, InferenceError), (500, InferenceError)):
+            count = 0
+            async def handle(request):
+                nonlocal count
+                count += 1
+                return httpx.Response(status, text="credential secret, body must not escape")
+            backend = LLMAPIBackend("https://llm.invalid", "secret", "model", transport=httpx.MockTransport(handle))
+            try:
+                with self.assertRaises(error) as caught:
+                    await backend.infer(context, call)
+                self.assertNotIn("secret", str(caught.exception))
+                self.assertEqual(count, 1)
+            finally:
+                await backend.aclose()
+
+    async def test_bad_llm_results_never_become_success(self):
+        context = InferenceContext("广州")
+        call = normalize_call("q", "extract", ("地点",), {'max_items': 8, 'max_length_per_item': 58}, context)
+        for message, finish in (("{}", "stop"), ('{"items":["北京"]}', "stop"), ('{"items":[""]}', "stop"), ('{"items":[null]}', "stop"), ('{"items":[]}', "length"), ("```json\n{}\n```", "stop"), (None, "stop")):
+            backend = LLMAPIBackend("https://llm.invalid", "secret", "model", transport=httpx.MockTransport(lambda _: httpx.Response(200, json={"choices": [{"finish_reason": finish, "message": {"content": message}}]})))
+            try:
+                with self.assertRaises(InferenceError):
+                    await backend.infer(context, call)
+            finally:
+                await backend.aclose()
+
+    async def test_timeout_cancellation_and_model_default_thinking(self):
+        context = InferenceContext("x")
+        call = normalize_call("q", "generate", ("x",), {'max_length': 512}, context)
+        cancelled = asyncio.Event()
+        async def hang(request):
+            self.assertNotIn("thinking", json.loads(request.content))
+            try:
+                await asyncio.Event().wait()
+            finally:
+                cancelled.set()
+        backend = LLMAPIBackend("https://llm.invalid", "secret", "model", disable_thinking=False, timeout=0.01, transport=httpx.MockTransport(hang))
+        try:
+            with self.assertRaises(InferenceError) as caught:
+                await backend.infer(context, call)
+            self.assertEqual(caught.exception.code, "model_timeout")
+            self.assertTrue(cancelled.is_set())
+        finally:
+            await backend.aclose()
+
+    async def test_missing_decision_answers_and_wrong_types(self):
+        context = InferenceContext("x")
+        call = normalize_call("q", "choice", ("x", {"a": "A"}), {}, context)
+        for answers in ({}, {"q": {"type": "choice", "choice": "b", "confidence": 0.8, "probabilities": {"a": 1}}}, {"q": {"type": "noul", "noul": 0.5}}):
+            backend = DecisionAPIBackend("https://decision.invalid", "secret", "model", transport=httpx.MockTransport(lambda _: httpx.Response(200, json={"answers": answers})))
+            try:
+                with self.assertRaises(InferenceError):
+                    await backend.infer_batch(context, [call])
+            finally:
+                await backend.aclose()
+
+
+class ContractTests(unittest.TestCase):
+    def test_input_validation_and_payload_immutability(self):
+        context = InferenceContext({"a": [1]})
+        with self.assertRaises(TypeError):
+            context.state["b"] = 2
+        for operation, args, options in (
+            ("generate", (1,), {}), ("generate", ("x",), {"max_num_tokens": 0}),
+            ("generate", ("x",), {"min_length": 3, "max_length": 2}),
+            ("extract", ("x",), {}), ("extract", ("x",), {"source_field": "text", "max_length_per_item": 0}),
+            ("choice", ("x", {}), {}), ("score", ("x", []), {}),
+        ):
+            with self.subTest(operation=operation, options=options), self.assertRaises((ValueError, TypeError)):
+                normalize_call("q", operation, args, options, context)
+
+    def test_response_contracts(self):
+        context = InferenceContext("原文")
+        cases = [
+            ("choice", ("x", {"a": "A"}), {}, ChoiceResponse("a", float("nan"), {"a": 1})),
+            ("generate", ("x",), {"min_length":1,"max_length": 1}, GenerateResponse("")),
+            ("generate_list", ("x",), {"min_items": 1,"max_items":2,"max_length_per_item":4}, GenerateListResponse([])),
+            ("extract", ("x",), {"max_items":2,"max_length_per_item":4}, ExtractResponse(["原 文"])),
+        ]
+        for op, args, kwargs, response in cases:
+            with self.assertRaises(InferenceError):
+                validate_response(normalize_call("q", op, args, kwargs, context), response)
+
+    def test_explicit_environment_precedence_and_no_shell_execution(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "env"
+            path.write_text('\n'.join(f'export ANNO_{prefix}_{suffix}="{value}"' for prefix in ("DECISION", "GENERATE") for suffix, value in (("BASE_URL", "https://example.invalid/v1"), ("AUTH_TOKEN", "$(never-execute)"), ("MODEL", "file-model"))))
+            with patch.dict(os.environ, {"ANNO_GENERATE_MODEL": "env-model"}, clear=True):
+                decision, llm = backends_from_env(env_file=path)
+                self.assertEqual(decision.model, "file-model")
+                self.assertEqual(llm.model, "env-model")
+                self.assertEqual(llm._token, "$(never-execute)")
+            with patch.dict(os.environ, {}, clear=True), self.assertRaisesRegex(ValueError, "ANNO_DECISION_BASE_URL"):
+                backends_from_env()
+
+
+if __name__ == "__main__":
+    unittest.main()

annoscript/test_client.py

@@ -0,0 +1,349 @@
+"""Behavioral checks for result-stream ownership and terminal outcomes."""
+
+from collections.abc import Iterable
+import json
+import unittest
+
+from annoscript.client import (
+    InputValidationError, AnnoClient, Result, ResultError, ResultStream,
+    precondition, require, system_prompt,
+)
+
+
+class ScriptedStream(ResultStream[str]):
+    def __init__(
+        self,
+        events: Iterable[Result[str] | BaseException] = (),
+        *,
+        cleanup_error: Exception | None = None,
+    ) -> None:
+        super().__init__()
+        self.events = iter(events)
+        self.cleanup_error = cleanup_error
+        self.pulls = 0
+        self.cleanups = 0
+
+    def _next_result(self) -> Result[str]:
+        self.pulls += 1
+        event = next(self.events)
+        if isinstance(event, BaseException):
+            raise event
+        return event
+
+    def _close(self) -> None:
+        self.cleanups += 1
+        if self.cleanup_error is not None:
+            raise self.cleanup_error
+
+
+class ResultStreamTests(unittest.TestCase):
+    def test_exhaustion_closes_nonempty_and_empty_streams(self):
+        result = Result(index=0, status="success", value="done")
+        for events in ([], [result]):
+            with self.subTest(events=events):
+                stream = ScriptedStream(events)
+                self.assertIs(iter(stream), stream)
+                self.assertEqual(list(stream), events)
+                self.assertTrue(stream.closed)
+                self.assertEqual(stream.cleanups, 1)
+
+    def test_explicit_close_is_idempotent_and_prevents_further_pulls(self):
+        stream = ScriptedStream([Result(index=0, status="success", value="unused")])
+        stream.close()
+        stream.close()
+        self.assertEqual(list(stream), [])
+        self.assertTrue(stream.closed)
+        self.assertEqual(stream.pulls, 0)
+        self.assertEqual(stream.cleanups, 1)
+
+    def test_context_closes_after_early_break_without_consuming_remainder(self):
+        first = Result(index=0, status="success", value="first")
+        second = Result(index=1, status="success", value="second")
+        source = iter([first, second])
+        stream = ScriptedStream(source)
+        with stream as entered:
+            self.assertIs(entered, stream)
+            for result in entered:
+                self.assertIs(result, first)
+                break
+            self.assertFalse(stream.closed)
+        self.assertTrue(stream.closed)
+        self.assertEqual(stream.cleanups, 1)
+        self.assertEqual(stream.pulls, 1)
+        self.assertIs(next(source), second)
+        self.assertEqual(list(stream), [])
+
+    def test_context_exits_without_double_cleanup_after_exhaustion(self):
+        stream = ScriptedStream()
+        with stream:
+            self.assertEqual(list(stream), [])
+        self.assertEqual(stream.cleanups, 1)
+
+    def test_consumer_exception_propagates_and_closes(self):
+        error = ValueError("consumer failed")
+        stream = ScriptedStream()
+        with self.assertRaises(ValueError) as caught:
+            with stream:
+                raise error
+        self.assertIs(caught.exception, error)
+        self.assertTrue(stream.closed)
+        self.assertEqual(stream.cleanups, 1)
+
+    def test_iteration_failure_and_interrupt_propagate_and_close(self):
+        for error in (ConnectionError("connection lost"), KeyboardInterrupt()):
+            with self.subTest(error=type(error).__name__):
+                stream = ScriptedStream([error])
+                with self.assertRaises(type(error)) as caught:
+                    next(stream)
+                self.assertIs(caught.exception, error)
+                self.assertTrue(stream.closed)
+                self.assertEqual(stream.cleanups, 1)
+                self.assertEqual(list(stream), [])
+                self.assertEqual(stream.pulls, 1)
+
+    def test_per_input_error_does_not_stop_following_results(self):
+        failed = Result[str](
+            index=0,
+            status="error",
+            error=ResultError(code="constraint_unsatisfied", message="No valid label"),
+        )
+        succeeded = Result(index=1, status="success", value="done")
+        stream = ScriptedStream([failed, succeeded])
+        with stream:
+            self.assertIs(next(stream), failed)
+            self.assertFalse(stream.closed)
+            self.assertIs(next(stream), succeeded)
+        self.assertEqual(stream.cleanups, 1)
+
+    def test_cleanup_failure_still_leaves_stream_closed(self):
+        error = OSError("cleanup failed")
+        stream = ScriptedStream(cleanup_error=error)
+        with self.assertRaises(OSError) as caught:
+            stream.close()
+        self.assertIs(caught.exception, error)
+        self.assertTrue(stream.closed)
+        stream.close()
+        self.assertEqual(list(stream), [])
+        self.assertEqual(stream.cleanups, 1)
+
+    def test_closed_stream_cannot_be_reentered(self):
+        stream = ScriptedStream()
+        stream.close()
+        with self.assertRaises(RuntimeError):
+            with stream:
+                self.fail("A closed stream must not enter the context body")
+        self.assertEqual(stream.cleanups, 1)
+
+
+class ResultTests(unittest.TestCase):
+    def test_success_preserves_none_and_list_values(self):
+        null_result = Result(index=0, status="success", value=None)
+        self.assertEqual(null_result.status, "success")
+        self.assertIsNone(null_result.error)
+        value = ["a", "b"]
+        list_result = Result(index=1, status="success", value=value)
+        self.assertIs(list_result.value, value)
+
+    def test_rejects_invalid_indices_and_contradictory_outcomes(self):
+        error = ResultError(code="failed", message="Failed")
+        cases = [
+            {"index": -1, "status": "success"},
+            {"index": True, "status": "success"},
+            {"index": 0, "status": "pending"},
+            {"index": 0, "status": "success", "error": error},
+            {"index": 0, "status": "error"},
+            {"index": 0, "status": "error", "error": error, "value": "unexpected"},
+        ]
+        for options in cases:
+            with self.subTest(options=options):
+                with self.assertRaises(ValueError):
+                    Result(**options)
+
+
+class SystemPromptTests(unittest.TestCase):
+    def test_registration_preserves_function_and_prompt_text(self):
+        calls = []
+
+        def program(anno):
+            calls.append(anno)
+            return "done"
+
+        original_code = program.__code__
+        original_attributes = vars(program).copy()
+        prompt = '  公共规则\n保留 "原文"。  '
+        decorated = system_prompt(prompt)(program)
+        self.assertIs(decorated, program)
+        self.assertIs(decorated.__code__, original_code)
+        self.assertEqual(vars(decorated), original_attributes)
+        self.assertEqual(AnnoClient._get_program_config(decorated), {"system_prompt": prompt})
+        self.assertEqual(calls, [])
+        self.assertEqual(decorated(None), "done")
+        self.assertEqual(calls, [None])
+
+    def test_duplicate_declarations_fail_without_replacing_original(self):
+        for prompt in ("rules", ""):
+            with self.subTest(prompt=prompt):
+                @system_prompt(prompt)
+                def program(anno):
+                    return "unused"
+
+                for repeated in (prompt, "replacement"):
+                    with self.assertRaisesRegex(ValueError, "only one"):
+                        system_prompt(repeated)(program)
+                self.assertEqual(AnnoClient._get_program_config(program), {"system_prompt": prompt})
+
+    def test_both_decorator_orders_export_prompt_and_keep_checks_local(self):
+        for prompt_outermost in (True, False):
+            with self.subTest(prompt_outermost=prompt_outermost):
+                checked = []
+
+                def check(state):
+                    checked.append(state)
+                    require(isinstance(state, str), message="expected text")
+
+                def program(anno):
+                    self.fail("Metadata and validation must not execute the program")
+
+                if prompt_outermost:
+                    decorated = system_prompt("rules")(precondition(check)(program))
+                else:
+                    decorated = precondition(check)(system_prompt("rules")(program))
+                config = AnnoClient._get_program_config(decorated)
+                self.assertEqual(json.loads(json.dumps(config)), {"system_prompt": "rules"})
+                self.assertEqual(checked, [])
+                self.assertIs(decorated, program)
+                errors = AnnoClient._validate_inputs(decorated, ["valid", {}])
+                self.assertEqual(checked, ["valid", {}])
+                self.assertEqual(set(errors), {1})
+                self.assertEqual(errors[1].code, "invalid_input")
+
+    def test_configuration_is_isolated_between_programs_and_reads(self):
+        @system_prompt("first rules")
+        def first(anno):
+            return "unused"
+
+        @system_prompt("second rules")
+        def second(anno):
+            return "unused"
+
+        def undecorated(anno):
+            return "unused"
+
+        config = AnnoClient._get_program_config(first)
+        config["system_prompt"] = "changed"
+        self.assertEqual(AnnoClient._get_program_config(first), {"system_prompt": "first rules"})
+        self.assertEqual(AnnoClient._get_program_config(second), {"system_prompt": "second rules"})
+        self.assertEqual(AnnoClient._get_program_config(undecorated), {})
+
+    def test_prompt_must_be_text(self):
+        for prompt in (None, 1, [], {}):
+            with self.subTest(prompt=prompt):
+                with self.assertRaisesRegex(TypeError, "requires a string"):
+                    system_prompt(prompt)
+
+
+class PreconditionTests(unittest.TestCase):
+    def test_require_reports_invalid_input(self):
+        self.assertIsNone(require(True, message="unused"))
+        with self.assertRaisesRegex(InputValidationError, "text is required"):
+            require(False, message="text is required")
+
+    def test_registration_preserves_function_and_does_not_run_checks(self):
+        checked = []
+
+        def check(state):
+            checked.append(state)
+
+        def program(anno):
+            return "done"
+
+        original_attributes = vars(program).copy()
+        original_code = program.__code__
+        decorated = precondition(check)(program)
+        self.assertIs(decorated, program)
+        self.assertIs(decorated.__code__, original_code)
+        self.assertEqual(vars(decorated), original_attributes)
+        self.assertEqual(decorated(None), "done")
+        self.assertEqual(checked, [])
+        self.assertEqual(AnnoClient._validate_inputs(decorated, ["record"]), {})
+        self.assertEqual(checked, ["record"])
+
+    def test_local_batch_check_preserves_indices_and_never_runs_program(self):
+        checked = []
+
+        def check(state):
+            checked.append(state)
+            require(isinstance(state, str), message="expected text")
+
+        @precondition(check)
+        def program(anno):
+            self.fail("Preconditions must not execute the program")
+
+        inputs = [{}, "valid", []]
+        errors = AnnoClient._validate_inputs(program, inputs)
+        self.assertEqual(checked, inputs)
+        self.assertEqual(errors, {
+            0: ResultError(code="invalid_input", message="expected text"),
+            2: ResultError(code="invalid_input", message="expected text"),
+        })
+
+    def test_stacked_checks_run_in_source_order_and_stop_on_invalid_input(self):
+        checked = []
+
+        def check_object(state):
+            checked.append("object")
+            require(isinstance(state, dict), message="expected object")
+
+        def check_text(state):
+            checked.append("text")
+            require(isinstance(state.get("text"), str), message="expected text")
+
+        @precondition(check_object)
+        @precondition(check_text)
+        def program(anno):
+            return "unused"
+
+        errors = AnnoClient._validate_inputs(program, ["wrong", {}, {"text": "valid"}])
+        self.assertEqual(set(errors), {0, 1})
+        self.assertEqual(checked, ["object", "object", "text", "object", "text"])
+
+    def test_unexpected_checker_errors_abort_validation(self):
+        for error in (ValueError("checker bug"), KeyError("missing")):
+            with self.subTest(error=type(error).__name__):
+                checked = []
+
+                def check(state):
+                    checked.append(state)
+                    raise error
+
+                @precondition(check)
+                def program(anno):
+                    return "unused"
+
+                with self.assertRaises(type(error)) as caught:
+                    AnnoClient._validate_inputs(program, ["first", "second"])
+                self.assertIs(caught.exception, error)
+                self.assertEqual(checked, ["first"])
+
+    def test_boolean_checker_return_is_a_defect_not_a_validation_result(self):
+        @precondition(lambda state: False)
+        def program(anno):
+            return "unused"
+
+        with self.assertRaisesRegex(TypeError, "return None"):
+            AnnoClient._validate_inputs(program, ["record"])
+
+    def test_empty_batch_and_program_without_preconditions(self):
+        def check(state):
+            self.fail("An empty batch must not run checks")
+
+        def program(anno):
+            self.fail("Validation must not run the program")
+
+        self.assertEqual(AnnoClient._validate_inputs(program, ["record"]), {})
+        precondition(check)(program)
+        self.assertEqual(AnnoClient._validate_inputs(program, []), {})
+
+
+if __name__ == "__main__":
+    unittest.main()

annoscript/test_compact_batch.py

@@ -0,0 +1,95 @@
+"""Compact wire aliases and strict values, independent of fixture serialization."""
+
+import json
+import unittest
+
+import httpx
+
+from annoscript.backends import InferenceContext, LLMAPIBackend, InferenceError
+from annoscript.backends.base import normalize_call
+
+
+class CompactBatchTests(unittest.IsolatedAsyncioTestCase):
+    def setup_calls(self):
+        context = InferenceContext({"text": '甲"\\\n😀', "other": "乙"})
+        calls = [
+            normalize_call("q2", "generate", ("标题",), {"min_length": 1, "max_length": 1}, context),
+            normalize_call('run9-"\n😀', "extract", ("抽取",),
+                           {"source_field": "text", "min_items": 1, "max_items": 1, "max_length_per_item": 1}, context),
+            normalize_call("run9-q2", "generate_list", ("空列表",),
+                           {"max_items": 0, "max_length_per_item": 0}, context),
+        ]
+        return context, calls
+
+    async def invoke(self, profile, content, context, calls):
+        requests, events = [], []
+        def handle(request):
+            requests.append(json.loads(request.content))
+            return httpx.Response(200, json={"choices": [{"finish_reason": "stop", "message": {"content": content}}]})
+        backend = LLMAPIBackend("http://offline.invalid", "fixture", "fixture", profile=profile,
+                                transport=httpx.MockTransport(handle), diagnostic_observer=events.append)
+        try:
+            result = await backend.infer_batch(context, calls, max_tokens=512)
+            return result, requests, events
+        finally:
+            await backend.aclose()
+
+    async def test_aliases_restore_original_ids_and_accept_reordered_answers(self):
+        context, calls = self.setup_calls()
+        for profile in ("legacy", "qwen_vllm"):
+            content = json.dumps({"answers": {"q3": [], "q2": [context.state["text"]], "q1": "超出建议长度"}}, ensure_ascii=False)
+            result, requests, events = await self.invoke(profile, content, context, calls)
+            self.assertEqual(result.errors, {})
+            self.assertEqual(set(result.responses), {call.id for call in calls})
+            self.assertEqual(result.responses["q2"].text, "超出建议长度")
+            self.assertEqual(result.responses[calls[1].id].items, [context.state["text"]])
+            system = requests[0]["messages"][0]["content"]
+            for index in (1, 2, 3):
+                self.assertIn(f'任务 "q{index}"', system)
+            self.assertNotIn("run9", system)
+            self.assertEqual(json.loads(requests[0]["messages"][1]["content"]), dict(context.state))
+            mapping = {"q1": "q2", "q2": calls[1].id, "q3": "run9-q2"}
+            self.assertTrue(any(event.get("wire_call_ids") == mapping for event in events))
+            self.assertTrue(any(event.get("batch_response_format") == "short_ids_values_v1" for event in events))
+
+    async def test_old_wrappers_and_wrong_value_types_are_local_errors(self):
+        context, calls = self.setup_calls()
+        for profile in ("legacy", "qwen_vllm"):
+            for value in ({"type": "generate", "text": "甲"}, {"text": "甲"}, [], None, 1, True):
+                with self.subTest(profile=profile, value=value):
+                    content = json.dumps({"answers": {"q1": value, "q2": ["甲"], "q3": []}})
+                    result, _, _ = await self.invoke(profile, content, context, calls)
+                    self.assertEqual(set(result.errors), {calls[0].id})
+                    self.assertEqual(result.errors[calls[0].id].call_id, calls[0].id)
+                    self.assertEqual(set(result.responses), {calls[1].id, calls[2].id})
+            for value in ("甲", {"type": "extract", "items": ["甲"]}, [None], ["乙"], [""], ["甲", "甲"]):
+                content = json.dumps({"answers": {"q1": "标题", "q2": value, "q3": []}})
+                result, _, _ = await self.invoke(profile, content, context, calls)
+                self.assertEqual(set(result.errors), {calls[1].id})
+
+    async def test_invalid_envelope_is_not_guessed_or_partially_adopted(self):
+        context, calls = self.setup_calls()
+        bad = ['{"answers":{"q1":"a","q1":"b"}}', '{"answers":{},"answers":{}}',
+               '{"answers":{"run9-q2":[]}}', '{"answers":{"q0":[]}}',
+               '{"answers":{"q4":[]}}', '{"answers":[],"extra":0}', '[]', '{}']
+        for profile in ("legacy", "qwen_vllm"):
+            for content in bad:
+                with self.subTest(profile=profile, content=content), self.assertRaises(InferenceError) as caught:
+                    await self.invoke(profile, content, context, calls)
+                self.assertEqual(caught.exception.code, "invalid_batch_output")
+
+    async def test_subsets_restart_aliases_without_reusing_a_different_binding(self):
+        context, calls = self.setup_calls()
+        for profile in ("legacy", "qwen_vllm"):
+            backend = LLMAPIBackend("http://offline.invalid", "fixture", "fixture", profile=profile)
+            try:
+                first = backend._prepare(context, calls[:2], 512, batch=True)
+                second = backend._prepare(context, calls[1:], 512, batch=True)
+                self.assertNotEqual(first.binding, second.binding)
+                self.assertEqual(dict(first.evidence["wire_call_ids"]), {"q1": calls[0].id, "q2": calls[1].id})
+                self.assertEqual(dict(second.evidence["wire_call_ids"]), {"q1": calls[1].id, "q2": calls[2].id})
+                result, _, _ = await self.invoke(profile, '{"answers":{"q1":["甲"],"q2":[]}}', context, calls[1:])
+                self.assertEqual(set(result.responses), {calls[1].id, calls[2].id})
+                self.assertEqual(result.errors, {})
+            finally:
+                await backend.aclose()