修复:完整展示AI原文并穿插图表,统一运行反馈与变化符号

This commit is contained in:
2026-11-02 12:03:37 +08:00
parent cf8e25a30d
commit 903fa94c00
35 changed files with 1016 additions and 172 deletions
+9 -3
View File
@@ -316,14 +316,18 @@ class AnalysisVisualsTest(unittest.TestCase):
def test_rate_drop_is_signed_and_converted_to_percentage_points(self):
result = changes_result(sort="rate_drop", rows=[
{"rank": 1, "key": "p-1", "label": "规格一", "rateDrop": -0.025},
{"rank": 2, "key": "p-2", "label": "规格二", "rateDrop": 0.04},
{"rank": 1, "key": "p-1", "label": "规格一", "rateDrop": 0.025},
{"rank": 2, "key": "p-2", "label": "规格二", "rateDrop": -0.04},
])
chart = build_visuals([evidence(result)], "画图比较产品合格率降幅", "turn-03")["visuals"][0]
self.assertEqual(chart["metric"], "rate_drop_pp")
self.assertEqual(chart["unit"], "pp")
self.assertEqual(chart["series"][0]["values"], [-2.5, 4.0])
self.assertEqual([row["key"] for row in result["rows"]], ["p-1", "p-2"])
self.assertEqual([item["key"] for item in chart["categories"]], ["p-1", "p-2"])
self.assertIn("率降幅线索", chart["title"])
self.assertIn("本期减比较期", chart["note"])
self.assertIn("仍按率降幅排序", chart["note"])
self.assertIn("未纳入投入规模", chart["note"])
def test_broad_product_focus_omits_rate_only_ranking_chart(self):
@@ -377,7 +381,9 @@ class AnalysisVisualsTest(unittest.TestCase):
self.assertEqual(chart["requiredFields"], [
"black_good_weight", "black_total_weight", "bright_good_weight", "bright_total_weight"
])
self.assertEqual(chart["series"][0]["values"], [2.0, -1.0])
self.assertEqual(chart["series"][0]["values"], [-2.0, 1.0])
self.assertIn("负值为下降,正值为上升", chart["note"])
self.assertIn("本期减比较期", chart["note"])
def test_quality_top_uses_ranked_weights_and_never_share(self):
result = {
+313
View File
@@ -0,0 +1,313 @@
"""Regression tests for the isolated native-agent original-body runtime copy."""
import copy
import importlib.util
import json
import os
import sys
import tempfile
import threading
import unittest
from pathlib import Path
from types import ModuleType, SimpleNamespace
from unittest.mock import Mock, patch
PROJECT = Path(__file__).resolve().parents[1]
RUNTIME_COPY = Path(os.environ.get('NAO_ORIGINAL_BODY_PATH',
str(PROJECT / 'scripts/nao_native_run.py'))).expanduser().resolve()
SPEC = importlib.util.spec_from_file_location('nao_native_run_original_body', RUNTIME_COPY)
NATIVE_RUN = importlib.util.module_from_spec(SPEC)
sys.modules[SPEC.name] = NATIVE_RUN
SPEC.loader.exec_module(NATIVE_RUN)
IDENTITY = {'attemptId': 'attempt-current', 'sessionId': 'session-current',
'turnId': 'turn-current', 'revision': 3, 'executionId': 'execution-current'}
def proof(query_id='query-current'):
return {**IDENTITY, 'queryId': query_id, 'nodeId': 'root', 'scopeId': 'scope-root',
'responseHash': 'a' * 64}
def document(ref='Q00000001', evidence_proof=None):
return {'evidenceRef': ref, 'result': {'protocolEvidence': evidence_proof or proof()}}
def task():
return {'version': 1, 'goal': '解释下降并根据实际结果调查', 'question': '本期下降原因',
'executionMode': 'native_agent', 'kind': 'analysis',
'period': {'year': 2026, 'month': 9}, 'comparisonPeriod': {'year': 2026, 'month': 8},
'filters': {'department': '当前产业部'}, 'fields': ['rate'], 'stages': [],
'dimensions': [], 'dimensionStages': {}, 'visualPreference': 'auto',
'comparisonRequired': True, 'trendRequired': False,
'verifySource': False, 'fullDetails': False}
class NativeOriginalBodyTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.actor_root = Path(self.temp.name)
(self.actor_root / 'private').mkdir()
(self.actor_root / 'evidence').mkdir()
self.cancel_event = threading.Event()
self.task = task()
self.request = {'sessionId': IDENTITY['sessionId'], 'turnId': IDENTITY['turnId'],
'actorId': 'actor-current', 'releaseId': 'release-current',
'question': self.task['question'],
'context': {'_serverHistory': [], '_serverQuestions': [], '_protocol': {}}}
self.current_proof = proof()
self.documents = [document(evidence_proof=self.current_proof)]
self.snapshot = {'scopes': [{'nodeId': 'root', 'scopeId': 'scope-root', 'task': self.task}],
'queries': [{'proof': self.current_proof}],
'scopeCoverage': [{'nodeId': 'root', 'scopeId': 'scope-root', 'complete': True}],
'rootGoalGaps': [], 'gaps': [], 'pending': [], 'explorationWarnings': []}
self.accumulator = SimpleNamespace(answer='原始回答 [Q00000001]', finish_reasons=['stop'],
tool_calls=[{'tool': 'quality_data', 'status': 'completed', 'input': {'mode': 'compare'}}],
timeline=[{'kind': 'assistant', 'text': '原始回答'}])
self.native_status, self.native_reason, self.stop_succeeded = 'COMPLETED', 'stop', None
self.events = []
self.manager = Mock()
self.manager.ensure_instance.return_value = (None, None, 'fixture-model', 'http://native.invalid')
self.delegated = Mock()
self.delegated.call.side_effect = lambda *args, **kwargs: copy.deepcopy(self.snapshot)
self.synthetic_writer = Mock(side_effect=AssertionError('native original-body path must not synthesize text'))
quality_runtime = ModuleType('nao_quality_runtime')
quality_runtime._atomic_json = self.atomic_json
quality_runtime._authenticate = Mock(return_value=object())
quality_runtime._sse_request = self.native
quality_runtime._read_json = self.read_json
agent_task = ModuleType('nao_agent_task')
agent_task.bind_task = lambda seed, current_task: {**copy.deepcopy(current_task), **copy.deepcopy(seed)}
protocol_execution = ModuleType('nao_protocol_execution')
protocol_execution._identity = lambda authority: copy.deepcopy(IDENTITY)
protocol_execution._platform_visual_context = lambda visuals: {'visualState': visuals.get('visualState')}
protocol_execution.query_evidence_bindings = lambda docs, receipts: [
{'evidenceRef': item['evidenceRef'], 'proofs': item['result'].get('protocolEvidence')}
for item in docs]
evidence_finalizer = ModuleType('nao_evidence_finalizer')
evidence_finalizer.evidence_summaries = lambda *args, **kwargs: copy.deepcopy(self.documents)
evidence_finalizer.synthesize_native = self.synthetic_writer
visual_evidence = ModuleType('analysis_visual_evidence')
visual_evidence.protocol_visual_result = self.visual_result
runtime_policy = ModuleType('nao_runtime_policy')
runtime_policy.native_timeout = lambda: 30
native_exploration = ModuleType('nao_native_exploration')
native_exploration._proofs = lambda result: ([result['protocolEvidence']]
if isinstance(result, dict) and isinstance(result.get('protocolEvidence'), dict) else [])
self.modules = {'nao_quality_runtime': quality_runtime, 'nao_agent_task': agent_task,
'nao_protocol_execution': protocol_execution,
'nao_evidence_finalizer': evidence_finalizer,
'analysis_visual_evidence': visual_evidence,
'nao_runtime_policy': runtime_policy,
'nao_native_exploration': native_exploration}
self.module_patch = patch.dict(sys.modules, self.modules)
self.module_patch.start()
self.addCleanup(self.module_patch.stop)
def atomic_json(self, path, payload):
path = Path(path)
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
@staticmethod
def read_json(path):
return json.loads(Path(path).read_text(encoding='utf-8'))
def native(self, **kwargs):
return self.accumulator, self.native_status, self.native_reason, self.stop_succeeded
def visual_result(self, documents, scopes, question, turn_id, **kwargs):
return {'visualState': 'ready', 'visuals': [{'id': 'formal-query-chart',
'evidenceRefs': [item['evidenceRef'] for item in documents]}], 'missingEvidence': []}
def invoke(self):
return NATIVE_RUN.run_native_exploration(request=copy.deepcopy(self.request),
task=copy.deepcopy(self.task), authority=copy.deepcopy(IDENTITY),
actor_root=self.actor_root, delegated=self.delegated,
connection=('https://model.invalid/v1', 'synthetic-fixture-key', 'fixture-model'),
manager=self.manager, state={}, cancel_event=self.cancel_event,
emit=self.events.append, prior_evidence_files={'prior-evidence.json'},
phase_timings={'planningAndReview': 10, 'taskConfirmation': 20})
def test_persists_the_complete_original_body_and_keeps_formal_charts(self):
body = '原生回答第一行\n' + ('原生正文' * 1800) + '\n[Q00000001]'
self.accumulator.answer = body
self.accumulator.timeline = [{'kind': 'assistant', 'text': 'x' * 8000}]
result = self.invoke()
self.assertEqual(result['status'], 'COMPLETED')
self.assertEqual(result['answer'], body)
self.assertIsNone(result['readingSummary'])
self.assertEqual(result['visuals'][0]['id'], 'formal-query-chart')
self.assertEqual(result['queryEvidenceRefs'], ['Q00000001'])
self.assertEqual(result['conclusionProtocolQueryIds'], ['query-current'])
self.assertEqual(result['answerQuality']['narrativeFactBinding'], 'not_assessed')
self.assertEqual(result['answerQuality']['backgroundEvidenceQueryIds'], [])
self.assertIsNone(result['factsComplete'])
self.assertEqual(self.read_json(self.actor_root / 'private/native-draft.json')['answer'], body)
self.assertEqual(self.read_json(self.actor_root / 'private/native-completion.json')['answer'], body)
self.assertEqual(self.read_json(self.actor_root / 'private/native-original-body-diagnostics.json')
['originalBodyCharacters'], len(body))
self.synthetic_writer.assert_not_called()
def test_empty_native_body_stays_empty_and_cannot_be_completed(self):
self.accumulator.answer = ''
result = self.invoke()
self.assertEqual(result['answer'], '')
self.assertEqual(result['status'], 'PARTIAL')
self.assertFalse(result['answerQuality']['narrativeComplete'])
self.assertIn('自主分析未生成正文。', result['answerQuality']['missingEvidence'])
self.synthetic_writer.assert_not_called()
def test_missing_formal_evidence_is_metadata_and_does_not_rewrite_the_body(self):
self.documents = []
body = '原始正文照常保留。'
self.accumulator.answer = body
result = self.invoke()
self.assertEqual(result['answer'], body)
self.assertEqual(result['status'], 'PARTIAL')
self.assertFalse(result['answerQuality']['dataComplete'])
self.assertIn('本轮未取得当前执行的可核验查询证据。', result['answerQuality']['missingEvidence'])
self.assertNotIn('尚未解决', result['answer'])
self.synthetic_writer.assert_not_called()
def test_partial_or_interrupted_generation_is_not_rewritten_or_marked_complete(self):
self.native_status, self.native_reason = 'PARTIAL', 'length'
self.accumulator.finish_reasons = ['length']
body = '模型已输出的局限与正文。'
self.accumulator.answer = body
result = self.invoke()
self.assertEqual(result['answer'], body)
self.assertEqual(result['status'], 'PARTIAL')
self.assertFalse(result['answerQuality']['narrativeComplete'])
self.assertEqual(result['finishReason'], 'length')
self.synthetic_writer.assert_not_called()
def test_completed_status_without_natural_stop_remains_partial(self):
body = '原生回答保留,结束信号不足。'
self.accumulator.answer = body
cases = (
('missing_stop_finish_reason', [], None),
('stop_control_failed', ['stop'], False),
)
for label, finish_reasons, stop_succeeded in cases:
with self.subTest(label=label):
self.accumulator.finish_reasons = finish_reasons
self.stop_succeeded = stop_succeeded
result = self.invoke()
self.assertEqual(result['answer'], body)
self.assertEqual(result['status'], 'PARTIAL')
self.assertFalse(result['answerQuality']['narrativeComplete'])
self.assertEqual(result['finishReason'], 'incomplete')
self.assertIn('自主调查未收到有效的正常结束信号。',
result['answerQuality']['missingEvidence'])
self.synthetic_writer.assert_not_called()
def test_recovered_tool_error_keeps_natural_stop_completion_without_fact_binding(self):
self.native_status, self.native_reason = 'PARTIAL', 'mcp_error'
body = '原生回答保留自己的局限。'
self.accumulator.answer = body
result = self.invoke()
self.assertEqual(result['status'], 'COMPLETED')
self.assertEqual(result['answer'], body)
self.assertEqual(result['conclusionProtocolQueryIds'], ['query-current'])
self.assertEqual(result['answerQuality']['backgroundEvidenceQueryIds'], ['query-current'])
self.assertTrue(result['answerQuality']['narrativeComplete'])
self.assertEqual(result['answerQuality']['narrativeFactBinding'], 'not_assessed')
self.assertIsNone(result['factsComplete'])
self.synthetic_writer.assert_not_called()
def test_no_explicit_refs_cannot_use_docs_without_verified_complete_scope_receipts(self):
self.snapshot['scopeCoverage'] = None
body = '正常原生正文不写证据编号。'
self.accumulator.answer = body
result = self.invoke()
self.assertEqual(result['answer'], body)
self.assertEqual(result['status'], 'PARTIAL')
self.assertEqual(result['conclusionProtocolQueryIds'], [])
self.assertEqual(result['answerQuality']['backgroundEvidenceQueryIds'], [])
self.assertFalse(result['answerQuality']['dataComplete'])
self.assertIn('本轮没有可关联的完整scope正式查询证明。',
result['answerQuality']['missingEvidence'])
self.synthetic_writer.assert_not_called()
def test_unbound_original_citation_is_a_gap_without_rewriting_the_body(self):
body = '原生回答里保留未绑定的引用。[QABCDEF99]'
self.accumulator.answer = body
result = self.invoke()
self.assertEqual(result['status'], 'PARTIAL')
self.assertEqual(result['answer'], body)
self.assertFalse(result['answerQuality']['dataComplete'])
self.assertEqual(result['answerQuality']['unresolvedEvidenceRefs'], ['QABCDEF99'])
self.assertIn('原文引用未关联本轮完整scope正式查询证据:QABCDEF99。',
result['answerQuality']['missingEvidence'])
self.assertNotIn('QABCDEF99', result['conclusionProtocolQueryIds'])
self.synthetic_writer.assert_not_called()
def test_explicit_hexadecimal_query_reference_maps_only_its_receipt(self):
hex_proof = proof('query-hex')
self.snapshot['queries'].append({'proof': hex_proof})
self.documents.append(document('QABCDEF12', hex_proof))
body = '原文引用正式查询[QABCDEF12]。'
self.accumulator.answer = body
result = self.invoke()
self.assertEqual(result['status'], 'COMPLETED')
self.assertEqual(result['answer'], body)
self.assertEqual(result['answerQuality']['citedEvidenceRefs'], ['QABCDEF12'])
self.assertEqual(result['conclusionProtocolQueryIds'], ['query-hex'])
self.synthetic_writer.assert_not_called()
def test_cancelled_turn_remains_cancelled_and_does_not_read_or_synthesize(self):
for cancellation in ('event', 'native_status'):
with self.subTest(cancellation=cancellation):
self.cancel_event.clear()
self.native_status, self.native_reason = 'COMPLETED', 'stop'
if cancellation == 'event':
self.cancel_event.set()
else:
self.native_status = 'CANCELLED'
self.accumulator.answer = '中断前的草稿'
result = self.invoke()
self.assertEqual(result['status'], 'CANCELLED')
self.assertEqual(result['answer'], '')
self.delegated.call.assert_not_called()
self.synthetic_writer.assert_not_called()
def test_server_coverage_gap_keeps_body_and_prevents_completed_status(self):
self.snapshot['rootGoalGaps'] = ['亮片必答阶段尚无完整两期依据。']
body = '原生结论及其局限。'
self.accumulator.answer = body
result = self.invoke()
self.assertEqual(result['answer'], body)
self.assertEqual(result['status'], 'PARTIAL')
self.assertFalse(result['answerQuality']['dataComplete'])
self.assertIn('亮片必答阶段尚无完整两期依据。', result['answerQuality']['missingEvidence'])
self.synthetic_writer.assert_not_called()
if __name__ == '__main__':
unittest.main()
+77 -51
View File
@@ -1,6 +1,8 @@
"""Exercise the native runner with isolated files and mocked upstream/bridge calls."""
import copy
import importlib.util
import json
import os
import sys
import tempfile
import threading
@@ -10,8 +12,15 @@ from pathlib import Path
from types import SimpleNamespace
from unittest.mock import Mock, patch
sys.path[:0] = [str(Path(__file__).resolve().parents[1] / 'scripts')]
from nao_native_run import run_native_exploration
PROJECT = Path(__file__).resolve().parents[1]
sys.path[:0] = [str(PROJECT / 'scripts')]
RUNTIME_PATH = Path(os.environ.get('NAO_ORIGINAL_BODY_PATH',
str(PROJECT / 'scripts/nao_native_run.py'))).expanduser().resolve()
RUNTIME_SPEC = importlib.util.spec_from_file_location('nao_native_run_integration', RUNTIME_PATH)
RUNTIME_MODULE = importlib.util.module_from_spec(RUNTIME_SPEC)
sys.modules[RUNTIME_SPEC.name] = RUNTIME_MODULE
RUNTIME_SPEC.loader.exec_module(RUNTIME_MODULE)
run_native_exploration = RUNTIME_MODULE.run_native_exploration
from nao_quality_runtime import _atomic_json
@@ -54,31 +63,25 @@ class NativeRunTests(unittest.TestCase):
'missingEvidence': ['节点bright-detail范围基础范围缺少bright来源具体缺陷重量图。']}
result = self.invoke()
self.assertEqual(result['status'], 'COMPLETED')
self.assertEqual(result['readingSummary']['notices'],
self.assertEqual(result['answerQuality']['notices'],
['亮片细分缺陷尚未完整核实:当前范围;未用于已核实结论。'])
self.assertNotIn('调查局限', result['answer'])
self.assertNotIn('bright', result['answer'])
stored = json.loads((self.actor_root / 'private/native-warning-diagnostics.json').read_text())
self.assertIn('bright', stored['visualWarnings'][0])
def test_full_facts_remain_private_instead_of_being_appended_to_the_business_answer(self):
self.final['fullEvidenceFacts'] = [{'text': '后台保留的完整统计事实', 'evidenceRef': 'Q00000001'}]
def test_original_answer_is_not_replaced_by_a_generated_report(self):
self.accumulator.answer = '原生回答原样保留,局限也照原文保留。'
result = self.invoke()
self.assertNotIn('完整统计依据', result['answer'])
self.assertNotIn('后台保留的完整统计事实', result['answer'])
stored = json.loads((self.actor_root / 'private/native-full-evidence-facts.json').read_text())
self.assertEqual(stored, self.final['fullEvidenceFacts'])
self.assertEqual(result['answer'], self.accumulator.answer)
self.assertIsNone(result['readingSummary'])
self.synthesis.assert_not_called()
def test_issued_binding_catalog_remains_private_for_exact_replay(self):
issued = {'bindingInventory': {'N17': {'factId': 'F2', 'value': '493.9966', 'unit': 'kg'}},
'facts': [{'id': 'F2', 'rawValue': '493.99660000'}]}
self.final['_privateBindingInput'] = issued
def test_no_second_composition_artifact_is_written(self):
result = self.invoke()
stored = json.loads((self.actor_root / 'private/native-composition.json').read_text())
self.assertEqual(stored['bindingInput'], issued)
self.assertNotIn('_privateBindingInput', result)
self.assertNotIn('bindingInput', result)
self.assertNotIn('bindingInventory', json.dumps(self.events, ensure_ascii=False))
self.assertEqual(result['answer'], self.accumulator.answer)
self.assertFalse((self.actor_root / 'private/native-composition.json').exists())
self.synthesis.assert_not_called()
def setUp(self):
self.folder = tempfile.TemporaryDirectory()
@@ -105,11 +108,6 @@ class NativeRunTests(unittest.TestCase):
'scopeCoverage': [{'nodeId': 'root', 'scopeId': 'scope-root', 'complete': True},
{'nodeId': 'group', 'scopeId': 'scope-group', 'complete': True}],
'rootGoalGaps': [], 'gaps': [], 'pending': [], 'explorationWarnings': []}
self.final = {'answer': '按已核实结果解释[Q00000001]', 'reportTitle': '质量数据分析',
'readingSummary': {'version': 1, 'lead': '已核实解释[Q00000001]',
'evidence': [], 'notices': [], 'evidenceRefs': ['Q00000001']},
'usedEvidenceRefs': ['Q00000001'], 'evidenceSufficient': True,
'missingEvidence': [], 'rawModelResponses': [], 'compositionDiagnostics': {}}
self.accumulator = SimpleNamespace(answer='原生草稿', finish_reasons=['stop'],
tool_calls=[{'tool': 'quality_data', 'status': 'failed', 'input': {'mode': 'compare'}},
{'tool': 'quality_data', 'status': 'completed', 'input': {'mode': 'compare'}}],
@@ -127,7 +125,7 @@ class NativeRunTests(unittest.TestCase):
self.read_evidence = stack.enter_context(patch('nao_evidence_finalizer.evidence_summaries',
side_effect=lambda *args, **kwargs: copy.deepcopy(self.documents)))
self.synthesis = stack.enter_context(patch('nao_evidence_finalizer.synthesize_native',
side_effect=lambda **kwargs: copy.deepcopy(self.final)))
side_effect=AssertionError('native-agent original body must not be synthesized')))
self.visuals = stack.enter_context(patch('analysis_visual_evidence.protocol_visual_result',
return_value={'visualState': 'not_requested', 'visuals': [], 'missingEvidence': []}))
stack.enter_context(patch('nao_runtime_policy.native_timeout', return_value=30))
@@ -161,8 +159,12 @@ class NativeRunTests(unittest.TestCase):
self.assertTrue(result['evidenceCompletion']['serverCoverageSufficient'])
self.assertEqual(result['timeline'], self.accumulator.timeline)
self.assertEqual(result['conclusionProtocolQueryIds'], ['query-current', 'query-compare'])
self.assertIn(self.snapshot['explorationWarnings'][0], result['readingSummary']['notices'])
self.assertEqual(result['conclusionProtocolQueryIds'],
['query-current', 'query-compare', 'query-group'])
self.assertEqual(result['answerQuality']['citedEvidenceRefs'], [])
self.assertEqual(result['answerQuality']['narrativeFactBinding'], 'not_assessed')
self.assertIn(self.snapshot['explorationWarnings'][0], result['answerQuality']['notices'])
self.assertEqual(result['answer'], self.accumulator.answer)
self.assertIn('firstUsefulMs', result['phaseTimingsMs'])
self.assertGreaterEqual(result['phaseTimingsMs']['firstUsefulMs'], 30)
self.delegated.call.assert_called_once_with('/api/analysis/protocol/queries', payload={}, method='POST')
@@ -172,35 +174,33 @@ class NativeRunTests(unittest.TestCase):
self.assertIsNone(self.sse.call_args.kwargs['chat_id'])
stored = json.loads((self.actor_root / 'private/native-completion.json').read_text())
self.assertEqual(stored['status'], 'COMPLETED')
self.assertEqual(stored['answer'], self.accumulator.answer)
self.assertEqual(self.events[-1], result)
def test_generated_chart_contract_is_available_before_the_single_synthesis(self):
def test_generated_chart_contract_uses_formal_query_evidence_without_rewriting_answer(self):
self.task['visualPreference']='required'
self.visuals.return_value={'visualState':'ready','missingEvidence':[], 'visuals':[{
'id':'actual-chart','type':'line','metric':'composite_rate','title':'正式趋势',
'scope':{'department':'当前产业部'},'period':{'year':2026,'month':9},
'categories':[{'key':'2026-09'}],'series':[{'values':[.95]}],
'evidenceRefs':['Q00000001']}]}
def synthesize(**kwargs):
preview=kwargs['context']['_platformVisuals']
self.assertEqual(preview['visualState'],'ready')
self.assertEqual(preview['charts'][0]['id'],'actual-chart')
self.assertEqual(preview['charts'][0]['evidenceRefs'],['Q00000001'])
self.assertEqual(preview['charts'][0]['pointCount'],1)
self.assertNotIn('series',preview['charts'][0])
return copy.deepcopy(self.final)
self.synthesis.side_effect=synthesize
result=self.invoke()
self.assertEqual(result['status'],'COMPLETED')
self.visuals.assert_called_once();self.synthesis.assert_called_once()
self.visuals.assert_called_once()
self.assertEqual(self.visuals.call_args.args[0], self.documents)
self.assertEqual(result['visuals'][0]['id'], 'actual-chart')
self.assertEqual(result['visuals'][0]['evidenceRefs'], ['Q00000001'])
self.assertEqual(result['answer'], self.accumulator.answer)
self.synthesis.assert_not_called()
def test_root_gap_remains_partial_even_with_stop_and_available_evidence(self):
self.snapshot['rootGoalGaps'] = ['亮片必答阶段尚无完整两期依据。']
result = self.invoke()
self.assertEqual(result['status'], 'PARTIAL')
self.assertFalse(result['evidenceCompletion']['serverCoverageSufficient'])
self.assertIn(self.snapshot['rootGoalGaps'][0], result['answer'])
self.assertIn(self.snapshot['rootGoalGaps'][0], result['readingSummary']['notices'])
self.assertEqual(result['answer'], self.accumulator.answer)
self.assertIn(self.snapshot['rootGoalGaps'][0], result['evidenceCompletion']['missingEvidence'])
self.assertIn(self.snapshot['rootGoalGaps'][0], result['answerQuality']['missingEvidence'])
def test_three_no_progress_attempts_remain_partial_after_natural_stop(self):
_atomic_json(self.actor_root / 'private/native-exploration-state.json',
@@ -210,7 +210,8 @@ class NativeRunTests(unittest.TestCase):
self.assertEqual(result['status'], 'PARTIAL')
self.assertTrue(any('连续三次' in gap for gap in result['evidenceCompletion']['missingEvidence']))
self.assertEqual(result['phaseTimingsMs']['formalQuery'], 1234)
self.assertTrue(any('连续三次' in notice for notice in result['readingSummary']['notices']))
self.assertTrue(any('连续三次' in gap for gap in result['answerQuality']['missingEvidence']))
self.assertEqual(result['answer'], self.accumulator.answer)
def test_controlled_no_progress_stop_does_not_add_generic_tool_failure(self):
_atomic_json(self.actor_root / 'private/native-exploration-state.json',
@@ -233,7 +234,7 @@ class NativeRunTests(unittest.TestCase):
self.assertEqual(result['status'], 'PARTIAL')
self.assertTrue(any('未正常结束' in gap for gap in result['evidenceCompletion']['missingEvidence']))
def test_only_complete_current_scope_documents_reach_synthesis(self):
def test_only_complete_current_scope_documents_reach_visual_generation_and_result(self):
self.snapshot['queries'].extend([{'proof': self.p_failed}, {'proof': self.p_old}])
self.snapshot['scopeCoverage'].append(
{'nodeId': 'failed', 'scopeId': 'scope-failed', 'complete': False})
@@ -245,27 +246,52 @@ class NativeRunTests(unittest.TestCase):
{'evidenceRef': 'Q00000007', 'result': {'summary': {'unproved': True}}},
])
result = self.invoke()
admitted = self.synthesis.call_args.kwargs['evidence']
admitted = self.visuals.call_args.args[0]
self.assertEqual([doc['evidenceRef'] for doc in admitted], ['Q00000001', 'Q00000002'])
self.assertEqual(result['queryEvidenceRefs'], ['Q00000001', 'Q00000002'])
self.assertEqual(result['conclusionProtocolQueryIds'],
['query-current', 'query-compare', 'query-group'])
self.assertNotIn('query-failed', result['conclusionProtocolQueryIds'])
self.assertNotIn('query-old', result['conclusionProtocolQueryIds'])
self.assertNotIn('query-not-in-current-receipts', result['conclusionProtocolQueryIds'])
self.assertEqual(result['answer'], self.accumulator.answer)
self.read_evidence.assert_called_once_with(self.actor_root / 'evidence', RELEASE,
exclude_files={'prior-evidence.json'}, allow_empty=True)
self.synthesis.assert_not_called()
def test_used_refs_map_only_to_actual_current_proofs_not_unused_or_foreign_documents(self):
def test_original_citations_map_only_to_actual_current_query_proofs(self):
self.snapshot['queries'].append({'proof': self.p_old})
self.documents.append(document('Q00000003', self.p_old))
self.final['usedEvidenceRefs'] = ['Q00000001', 'Q00000003', 'QDEADBEEF', 'Q00000001']
self.accumulator.answer = '原文引用当前证据[Q00000001],以及外部证据[Q00000003]。'
result = self.invoke()
self.assertEqual(result['conclusionProtocolQueryIds'], ['query-current', 'query-compare'])
self.assertEqual(result['answer'], self.accumulator.answer)
self.assertEqual(result['answerQuality']['unresolvedEvidenceRefs'], ['Q00000003'])
self.assertEqual(result['status'], 'PARTIAL')
self.assertNotIn('query-group', result['conclusionProtocolQueryIds'])
self.assertNotIn('query-old', result['conclusionProtocolQueryIds'])
def test_claimed_sufficient_answer_without_current_cited_proof_remains_partial(self):
self.final['usedEvidenceRefs'] = ['QDEADBEEF']
def test_uppercase_hexadecimal_reference_maps_to_its_actual_receipt(self):
hexadecimal = proof('query-hexadecimal')
self.snapshot['queries'].append({'proof': hexadecimal})
self.documents.append(document('QABCDEF12', hexadecimal))
self.accumulator.answer = '原文显式引用[QABCDEF12]。'
result = self.invoke()
self.assertEqual(result['status'], 'COMPLETED')
self.assertEqual(result['answer'], self.accumulator.answer)
self.assertEqual(result['conclusionProtocolQueryIds'], ['query-hexadecimal'])
self.assertEqual(result['answerQuality']['citedEvidenceRefs'], ['QABCDEF12'])
def test_unbound_original_citation_remains_a_metadata_gap(self):
self.accumulator.answer = '原生回答的引用[QABCDEF99]仍按原文保留。'
result = self.invoke()
self.assertEqual(result['status'], 'PARTIAL')
self.assertEqual(result['conclusionProtocolQueryIds'], [])
self.assertTrue(any('实际查询证明' in gap for gap in result['evidenceCompletion']['missingEvidence']))
self.assertEqual(result['answer'], self.accumulator.answer)
self.assertEqual(result['answerQuality']['unresolvedEvidenceRefs'], ['QABCDEF99'])
self.assertTrue(any('QABCDEF99' in gap for gap in result['evidenceCompletion']['missingEvidence']))
def test_cancelled_native_turn_never_reads_query_snapshot_or_synthesizes(self):
for cancellation in ('event', 'native_status'):
@@ -295,12 +321,12 @@ class NativeRunTests(unittest.TestCase):
self.assertNotIn('图表尚未完整生成,可独立恢复。', result['answer'])
self.assertNotIn('结果为部分完成', result['answer'])
self.assertNotIn('共有15张图表', result['answer'])
self.assertEqual(result['readingSummary']['notices'],
self.assertEqual(result['answerQuality']['notices'],
['部分重点图表未能完整展示;已保留核实文字和表格。'])
else:
self.assertIn('图表尚未完整生成,可独立恢复。', result['answer'])
self.assertIn('图表尚未完整生成,可独立恢复。', result['readingSummary']['notices'])
self.assertIn('结果为部分完成', result['answer'])
self.assertNotIn('图表尚未完整生成,可独立恢复。', result['answer'])
self.assertNotIn('结果为部分完成', result['answer'])
self.assertIn('图表尚未完整生成,可独立恢复。', result['answerQuality']['missingEvidence'])
if __name__ == '__main__':