From a84ee85a84ebb67f8f28476331eb38e8b9baff3c Mon Sep 17 00:00:00 2001 From: lyun Date: Mon, 2 Nov 2026 13:37:17 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=EF=BC=9A=E6=99=AE=E9=80=9A?= =?UTF-8?q?=E5=AF=B9=E8=AF=9D=E6=B2=BF=E7=94=A8=E6=A8=A1=E5=9E=8B=E5=8E=9F?= =?UTF-8?q?=E6=96=87=E5=B9=B6=E4=BF=9D=E7=95=99=E4=B8=9A=E5=8A=A1=E5=89=8D?= =?UTF-8?q?=E6=80=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../analysis/AnalysisDirectConversation.java | 42 +++++++++++ .../analysis/AnalysisProtocolService.java | 21 +++++- .../AnalysisDirectConversationTest.java | 45 ++++++++++++ .../AnalysisProtocolServiceMySqlTest.java | 71 +++++++++++++++++-- docs/AI智能分析要求与排查修复基准.md | 3 +- scripts/nao_agent_task.py | 16 ++++- scripts/nao_conversation.py | 6 +- scripts/nao_native_planning.py | 1 + scripts/nao_protocol_execution.py | 19 +++++ verification/test_nao_conversation.py | 36 ++++++++++ verification/test_protocol_conversation.py | 32 +++++++++ 11 files changed, 275 insertions(+), 17 deletions(-) create mode 100644 backend/src/main/java/cn/yunsheng/quality/analysis/AnalysisDirectConversation.java create mode 100644 backend/src/test/java/cn/yunsheng/quality/analysis/AnalysisDirectConversationTest.java create mode 100644 verification/test_protocol_conversation.py diff --git a/backend/src/main/java/cn/yunsheng/quality/analysis/AnalysisDirectConversation.java b/backend/src/main/java/cn/yunsheng/quality/analysis/AnalysisDirectConversation.java new file mode 100644 index 0000000..74fab2e --- /dev/null +++ b/backend/src/main/java/cn/yunsheng/quality/analysis/AnalysisDirectConversation.java @@ -0,0 +1,42 @@ +package cn.yunsheng.quality.analysis; + +import java.util.*; +import java.util.regex.Pattern; + +/** 模型选择的普通对话不产生业务事实;确认与发布使用同一份受限原文。 */ +final class AnalysisDirectConversation { + private static final Pattern FORBIDDEN=Pattern.compile( + "(?:\\d+(?:[.,]\\d+)*|[零〇一二两三四五六七八九十百千万点]+)\\s*(?:[%%]|kg\\b|公斤|千克|吨|个百分点|pp\\b)" + +"|百分之|(?:合格率|投入|报废|总重|产量|重量|数量)(?:重量|数量|总数|率)?\\s*(?:为|是|有|达到|共|合计|总计|[::])?\\s*(?:\\d|[零〇一二两三四五六七八九十百千万点])" + +"|(?:已|已经)(?:查到|查询|核实|统计|生成|保存|记住|修改|设置|完成分析)(?!的)" + +"|https?://|Q[A-F0-9]{8}|<[^>]+>|Bearer\\s+|\\bsk-[A-Za-z0-9_-]+|(?:api[_-]?key|token|password)\\s*[:=]", + Pattern.CASE_INSENSITIVE|Pattern.UNICODE_CASE); + private static final Pattern BUSINESS=Pattern.compile("合格率|报废|投入|产量|重量|分组|规格|产业部|国内|海外|产品"); + private static final Pattern CLAIM=Pattern.compile("主要是.{0,40}所致|主要来自|主要原因是|所致|远高于|远低于|确实更(?:大|小|差|好)|基本持平|(?:下降|上升|增加|减少|恶化|改善)了|明显.{0,8}(?:下降|上升|增加|减少)|导致.{0,12}(?:下降|上升)"); + static boolean applies(Map task) {return task.get("directResponse") instanceof Map;} + static void validate(Map task) { + Map reply=AnalysisProtocolService.map(task.get("directResponse")); + if(!Set.of("explain","restate").contains(Objects.toString(task.get("kind"),"")) + ||!reply.keySet().equals(Set.of("purpose","answer","requiresMemory")) + ||!Set.of("greeting","capabilities","acknowledgement").contains(Objects.toString(reply.get("purpose"),"")) + ||!Boolean.FALSE.equals(reply.get("requiresMemory")))throw invalid(); + for(String key:List.of("freshQuery","comparisonRequired","trendRequired","verifySource","fullDetails","needsClarification")) + if(!Boolean.FALSE.equals(task.get(key)))throw invalid(); + for(String key:List.of("dimensions","stages","fields"))if(!(task.get(key) instanceof List values)||!values.isEmpty())throw invalid(); + if(task.get("memberFields")!=null&&!(task.get("memberFields") instanceof List values&&values.isEmpty()))throw invalid(); + if(task.get("dimensionStages")!=null&&!(task.get("dimensionStages") instanceof Map values&&values.isEmpty()))throw invalid(); + if(task.containsKey("queryPlan")||!"none".equals(task.get("visualPreference"))||task.get("visualType")!=null + ||!"none".equals(task.getOrDefault("historyMode","none"))||"native_agent".equals(task.get("executionMode")))throw invalid(); + if(!(reply.get("answer") instanceof String text)||text.isBlank()||text.length()>1200||FORBIDDEN.matcher(text).find() + ||BUSINESS.matcher(text).find()&&CLAIM.matcher(text).find())throw invalid(); + } + static Map answer(Map task,String release,Map context) { + validate(task); + var answer=new LinkedHashMap();answer.put("answer",AnalysisProtocolService.map(task.get("directResponse")).get("answer")); + answer.put("engine","NAO");answer.put("releaseId",release);answer.put("context",context);answer.put("task",task); + answer.put("completionMethod","direct_conversation");answer.put("businessResultsSentToModel",false);answer.put("stopReason","direct_conversation"); + for(String key:List.of("results","visuals","queryEvidenceRefs","protocolQueryIds"))answer.put(key,List.of()); + answer.put("visualSchemaVersion",1);answer.put("visualState","not_requested");return answer; + } + private static IllegalArgumentException invalid(){return new IllegalArgumentException("普通对话只允许问候、能力介绍或致谢,不得替代业务查询、事实判断或记忆操作");} +} diff --git a/backend/src/main/java/cn/yunsheng/quality/analysis/AnalysisProtocolService.java b/backend/src/main/java/cn/yunsheng/quality/analysis/AnalysisProtocolService.java index 0741f7c..d5a3405 100644 --- a/backend/src/main/java/cn/yunsheng/quality/analysis/AnalysisProtocolService.java +++ b/backend/src/main/java/cn/yunsheng/quality/analysis/AnalysisProtocolService.java @@ -86,8 +86,13 @@ public class AnalysisProtocolService { var state=store.state(sessionId); Long prior="CLARIFICATION".equals(state.status()) ? state.revision() : state.confirmedRevision(); if (prior!=null) previous=read(store.revision(sessionId,prior).taskJson()); - if("report".equals(previous.get("kind"))&&!retry) { - var resumed=jdbc.query("SELECT task_json FROM analysis_protocol_revision WHERE session_id=? AND disposition='CONFIRMED' AND JSON_UNQUOTE(JSON_EXTRACT(task_json,'$.kind'))<>'report' ORDER BY revision DESC LIMIT 1", + if(AnalysisDirectConversation.applies(previous)&&!retry) { + // 取该修订首次确认前冻结的业务前态,保留待澄清任务,且不复活已取消的目标。 + var frozen=jdbc.query("SELECT input_json FROM analysis_protocol_attempt WHERE session_id=? AND revision=? AND execution_id IS NOT NULL ORDER BY created_at,attempt_id LIMIT 1", + (rs,n)->read(rs.getString(1)),sessionId,prior); + previous=frozen.isEmpty()?Map.of():map(frozen.getFirst().get("previousTask")); + } else if("report".equals(previous.get("kind"))&&!retry) { + var resumed=jdbc.query("SELECT task_json FROM analysis_protocol_revision WHERE session_id=? AND disposition='CONFIRMED' AND JSON_UNQUOTE(JSON_EXTRACT(task_json,'$.kind'))<>'report' AND (JSON_EXTRACT(task_json,'$.directResponse') IS NULL OR JSON_TYPE(JSON_EXTRACT(task_json,'$.directResponse'))='NULL') ORDER BY revision DESC LIMIT 1", (rs,n)->read(rs.getString(1)),sessionId); previous=resumed.isEmpty()?Map.of():resumed.getFirst(); } @@ -487,6 +492,7 @@ public class AnalysisProtocolService { if(!target.equals("POST /api/analysis/protocol/history")||!params.isEmpty()||nodeId!=null||scopeId!=null)throw denied("历史报告不能执行新的正式查询"); return Map.of(); } + if(AnalysisDirectConversation.applies(task))throw denied("普通对话不能执行正式业务查询"); if(target.equals("POST /api/analysis/protocol/queries")) { if(!task.containsKey("queryPlan")&&!AnalysisProtocolExploration.nativeAgent(task)||nodeId!=null||scopeId!=null)throw denied("当前任务未声明分步查询"); return Map.of(); @@ -626,7 +632,10 @@ public class AnalysisProtocolService { binding.current(a.sessionId(),a.turnId(),a.userId(),a.revision(),a.executionId()); Map task=read(store.revision(a.sessionId(),a.revision()).taskJson()); if(!Objects.equals(canonical(task),canonical(details.get("agentTask")))) throw denied("最终答复没有绑定当前任务"); - if(Set.of("COMPLETED","PARTIAL").contains(status)&&!"report".equals(task.get("kind")) + if(Set.of("COMPLETED","PARTIAL").contains(status)&&AnalysisDirectConversation.applies(task)) { + answer=AnalysisDirectConversation.answer(task,a.releaseId(),taskContext(a.releaseId(),task)); + status="COMPLETED"; + } else if(Set.of("COMPLETED","PARTIAL").contains(status)&&!"report".equals(task.get("kind")) &&!hasProtocolEvidence(details)) { status="FAILED"; String original=AnalysisProtocolExploration.nativeAgent(task)?Objects.toString(answer.get("answer"),""):null; @@ -1684,6 +1693,12 @@ public class AnalysisProtocolService { } } } + if(AnalysisDirectConversation.applies(t)) { + try {AnalysisDirectConversation.validate(t);}catch(IllegalArgumentException invalid){throw conflict(invalid.getMessage());} + if(t.get("period")!=null)period(map(t.get("period"))); + if(t.get("comparisonPeriod")!=null)period(map(t.get("comparisonPeriod"))); + return t; + } period(map(t.get("period"))); if(Boolean.TRUE.equals(t.get("needsClarification"))) { if(!(t.get("clarification") instanceof String s)||s.isBlank())throw conflict("澄清必须说明待确认对象"); diff --git a/backend/src/test/java/cn/yunsheng/quality/analysis/AnalysisDirectConversationTest.java b/backend/src/test/java/cn/yunsheng/quality/analysis/AnalysisDirectConversationTest.java new file mode 100644 index 0000000..c7f5463 --- /dev/null +++ b/backend/src/test/java/cn/yunsheng/quality/analysis/AnalysisDirectConversationTest.java @@ -0,0 +1,45 @@ +package cn.yunsheng.quality.analysis; +import java.util.*; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; +class AnalysisDirectConversationTest { + private Map task() { + var t=new LinkedHashMap();t.put("kind","explain");t.put("visualPreference","none");t.put("historyMode","none"); + for(String k:List.of("freshQuery","comparisonRequired","trendRequired","verifySource","fullDetails","needsClarification"))t.put(k,false); + for(String k:List.of("dimensions","stages","fields"))t.put(k,List.of()); + t.put("directResponse",new LinkedHashMap<>(Map.of("purpose","greeting","answer","你好!可以帮你查询质量指标,并比较期间变化。","requiresMemory",false)));return t; + } + @Test void acceptsModelSelectedConversationWithoutInventingADataPeriod() { + var t=task();assertTrue(AnalysisDirectConversation.applies(t));assertDoesNotThrow(()->AnalysisDirectConversation.validate(t)); + t.put("period",Map.of("year",2026,"month",9));assertDoesNotThrow(()->AnalysisDirectConversation.validate(t)); + AnalysisProtocolService.map(t.get("directResponse")).put("answer","我可以帮你比较不同产业部谁表现更好,并整理已核实的历史结果。"); + assertDoesNotThrow(()->AnalysisDirectConversation.validate(t)); + } + @Test void queryAndMemoryActionsCannotBypassTheEvidencePath() { + for(String k:List.of("freshQuery","comparisonRequired","trendRequired","verifySource","fullDetails","needsClarification")) { + var t=task();t.put(k,true);assertThrows(IllegalArgumentException.class,()->AnalysisDirectConversation.validate(t),k); + } + for(String k:List.of("fields","stages","dimensions","queryPlan","memberFields")) { + var t=task();t.put(k,List.of("rate"));assertThrows(IllegalArgumentException.class,()->AnalysisDirectConversation.validate(t),k); + } + for(var change:List.>of(Map.of("purpose","business_analysis"),Map.of("requiresMemory",true),Map.of("unexpected","hidden"))) { + var t=task();AnalysisProtocolService.map(t.get("directResponse")).putAll(change);assertThrows(IllegalArgumentException.class,()->AnalysisDirectConversation.validate(t)); + } + } + @Test void unqueriedFactsTrendsAndUnperformedActionsAreRejected() { + for(String s:List.of("合格率为95.5%","报废重量123","报废二十公斤","黑片合格率明显下降","黑片合格率下降了,主要原因是设备故障。","上月报废重量为一百。","国内报废主要来自设备问题","我已经保存你的偏好","已查询最新数据")) { + var t=task();AnalysisProtocolService.map(t.get("directResponse")).put("answer",s);assertThrows(IllegalArgumentException.class,()->AnalysisDirectConversation.validate(t),s); + } + } + @Test void linksCredentialsHtmlAndReferencesCannotBecomeConversationProse() { + for(String s:List.of("见https://example.test","[QABCDEF12]","你好","Bearer synthetic","token=synthetic"," ","文".repeat(1201))) { + var t=task();AnalysisProtocolService.map(t.get("directResponse")).put("answer",s);assertThrows(IllegalArgumentException.class,()->AnalysisDirectConversation.validate(t)); + } + } + @Test void theConfirmedModelTextIsPublishedOnceWithoutBusinessDataOrCharts() { + var t=task();var answer=AnalysisDirectConversation.answer(t,"release",Map.of("releaseId","release")); + assertEquals(AnalysisProtocolService.map(t.get("directResponse")).get("answer"),answer.get("answer"));assertEquals("direct_conversation",answer.get("completionMethod")); + for(String k:List.of("results","visuals","queryEvidenceRefs","protocolQueryIds"))assertEquals(List.of(),answer.get(k)); + assertEquals(false,answer.get("businessResultsSentToModel")); + } +} diff --git a/backend/src/test/java/cn/yunsheng/quality/analysis/AnalysisProtocolServiceMySqlTest.java b/backend/src/test/java/cn/yunsheng/quality/analysis/AnalysisProtocolServiceMySqlTest.java index 0dfe451..d9e85ba 100644 --- a/backend/src/test/java/cn/yunsheng/quality/analysis/AnalysisProtocolServiceMySqlTest.java +++ b/backend/src/test/java/cn/yunsheng/quality/analysis/AnalysisProtocolServiceMySqlTest.java @@ -1153,6 +1153,62 @@ class AnalysisProtocolServiceMySqlTest { assertEquals("本轮分析未完成,请重试",jdbc.queryForObject("SELECT stop_reason FROM analysis_turn WHERE id=?",String.class,turn)); assertEquals(false,AnalysisProtocolService.map(saved.get("completion")).get("completed")); } + @Test void ordinaryConversationCompletesWithoutPeriodOrFormalQueriesAndUsesConfirmedModelReply() throws Exception { + enableAutonomous();String turn=newTurn("你好");var a=claim(turn,false);var proposal=task(turn,Map.of("columnFilters",List.of()),false); + proposal.put("kind","explain");proposal.put("period",null);proposal.put("fields",List.of());proposal.put("trendRequired",false); + for(String key:List.of("freshQuery","comparisonRequired","verifySource","fullDetails"))proposal.put(key,false); + proposal.put("visualPreference","none");proposal.put("historyMode","none"); + String original="您好!我可以协助您查询质量指标、比较期间变化。"; + proposal.put("directResponse",Map.of("purpose","greeting","answer",original,"requiresMemory",false)); + var confirmed=AnalysisProtocolService.map(tx.execute(s->service.confirm(a.attemptId(),proposal,actor)).get("task")); + assertThrows(RuntimeException.class,()->tx.executeWithoutResult(s->service.checkTarget(a.attemptId(),"GET","/api/metrics",params(null),actor))); + tx.executeWithoutResult(s->service.finish(a.attemptId(),"COMPLETED",Map.of("answer","不能替换已确认的原文","visuals",List.of(Map.of("id","forged"))),Map.of("agentTask",confirmed,"protocolEvidence",List.of()),actor)); + var saved=json.readValue(jdbc.queryForObject("SELECT answer_json FROM analysis_turn WHERE id=?",String.class,turn),Map.class); + assertEquals("COMPLETED",turnStatus(turn));assertEquals(original,saved.get("answer"));assertEquals("direct_conversation",saved.get("completionMethod")); + assertEquals(List.of(),saved.get("visuals"));assertEquals(0,jdbc.queryForObject("SELECT COUNT(*) FROM analysis_protocol_query",Integer.class)); + String next=newTurn("继续分析");var nextAttempt=claim(next,false);assertEquals(Map.of(),nextAttempt.input().get("previousTask")); + } + @Test void thanksDoesNotReplaceTheBusinessGoalOrBecomeAHistoryReportSource() throws Exception { + enableAutonomous();String business=completedHistoryMetric("18X15X4+T",9,"35.055"); + var before=AnalysisProtocolService.map(json.readValue(jdbc.queryForObject("SELECT plan_json FROM analysis_turn WHERE id=?",String.class,business),Map.class).get("task")); + String turn=newTurn("谢谢");var a=claim(turn,false);var proposal=new LinkedHashMap<>(before);proposal.put("question","谢谢");proposal.put("goal","回应致谢");proposal.put("kind","explain"); + proposal.put("fields",List.of());proposal.put("stages",List.of());proposal.put("dimensions",List.of());proposal.put("historyMode","none"); + for(String key:List.of("freshQuery","comparisonRequired","trendRequired","verifySource","fullDetails","needsClarification"))proposal.put(key,false); + proposal.put("directResponse",Map.of("purpose","acknowledgement","answer","不客气,可以继续提问。","requiresMemory",false)); + var confirmed=AnalysisProtocolService.map(tx.execute(s->service.confirm(a.attemptId(),proposal,actor)).get("task")); + tx.executeWithoutResult(s->service.finish(a.attemptId(),"COMPLETED",Map.of(),Map.of("agentTask",confirmed),actor)); + String report=newTurn("整理历史结果");var next=claim(report,false);assertEquals(before,next.input().get("previousTask")); + var reportTask=historyTask(next,report,"all");assertEquals(List.of(business),reportTask.get("historySourceTurnIds")); + } + @Test void consecutiveConversationAndRetryPreserveThePendingClarificationGoal() { + enableAutonomous();String business=newTurn("今年18×15×4综合率趋势");var a=claim(business,false); + var pending=AnalysisProtocolService.map(tx.execute(s->service.confirm(a.attemptId(),task(business,Map.of(),true),actor)).get("task")); + tx.executeWithoutResult(s->service.finish(a.attemptId(),"NEEDS_CLARIFICATION",answer(),Map.of("agentTask",pending),actor)); + for(String question:List.of("谢谢","你好")) { + String turn=newTurn(question);var b=claim(turn,false);assertEquals(pending,b.input().get("previousTask")); + var confirmed=AnalysisProtocolService.map(tx.execute(s->service.confirm(b.attemptId(),ordinaryTask(turn),actor)).get("task")); + tx.executeWithoutResult(s->service.finish(b.attemptId(),"COMPLETED",Map.of(),Map.of("agentTask",confirmed),actor)); + jdbc.update("UPDATE analysis_turn SET status='QUEUED' WHERE id=?",turn); + var retried=claim(turn,true);var again=AnalysisProtocolService.map(tx.execute(s->service.confirm(retried.attemptId(),confirmed,actor)).get("task")); + tx.executeWithoutResult(s->service.finish(retried.attemptId(),"COMPLETED",Map.of(),Map.of("agentTask",again),actor)); + } + var next=claim(newTurn("选+T"),false);assertEquals(pending,next.input().get("previousTask")); + } + @Test void conversationDoesNotReviveACancelledBusinessGoal() { + enableAutonomous();String business=newTurn("取消这个分析目标");var a=claim(business,false); + tx.execute(s->service.confirm(a.attemptId(),task(business,Map.of("product","18X15X4+T"),false),actor)); + tx.executeWithoutResult(s->service.cancel(business,actor,"用户取消")); + String greeting=newTurn("你好");var b=claim(greeting,false);assertEquals(Map.of(),b.input().get("previousTask")); + var confirmed=AnalysisProtocolService.map(tx.execute(s->service.confirm(b.attemptId(),ordinaryTask(greeting),actor)).get("task")); + tx.executeWithoutResult(s->service.finish(b.attemptId(),"COMPLETED",Map.of(),Map.of("agentTask",confirmed),actor)); + assertEquals(Map.of(),claim(newTurn("重新开始"),false).input().get("previousTask")); + } + private Map ordinaryTask(String turn) { + var result=task(turn,Map.of(),false);result.put("kind","explain");result.put("goal","回应普通对话");result.put("period",null);result.put("fields",List.of()); + for(String key:List.of("freshQuery","comparisonRequired","trendRequired","verifySource","fullDetails","needsClarification"))result.put(key,false); + result.put("visualPreference","none");result.put("historyMode","none"); + result.put("directResponse",Map.of("purpose","greeting","answer","你好,可以继续提问。","requiresMemory",false));return result; + } @Test void autonomousReadBudgetAndFinishRequireRealRootEvidence() { enableAutonomous();String turn=newTurn("检查根任务证据");var a=claim(turn,false);var confirmed=AnalysisProtocolService.map(tx.execute(s->service.confirm(a.attemptId(),nativeTask(turn,Map.of()),actor)).get("task")); var registered=step(a,"read",Map.of("kind","base"),List.of());var scope=AnalysisProtocolService.map(registered.get("scope"));var p=scopeParams(scope);var proofs=new ArrayList>(); @@ -1183,7 +1239,7 @@ class AnalysisProtocolServiceMySqlTest { assertThrows(RuntimeException.class,()->tx.executeWithoutResult(s->service.finish(a.attemptId(),"COMPLETED",answer(),details,actor))); details.put("conclusionProtocolQueryIds",citeFailed?List.of(rootProof.get("queryId"),failedProof.get("queryId")):List.of(rootProof.get("queryId"))); tx.executeWithoutResult(s->service.finish(a.attemptId(),"COMPLETED",answer(),details,actor));assertEquals(citeFailed?"PARTIAL":"COMPLETED",turnStatus(turn)); - var saved=json.readValue(jdbc.queryForObject("SELECT answer_json FROM analysis_turn WHERE id=?",String.class,turn),Map.class);assertEquals(details.get("conclusionProtocolQueryIds"),saved.get("conclusionProtocolQueryIds"));assertFalse(AnalysisProtocolService.list(saved.get("explorationWarnings")).isEmpty());assertEquals(citeFailed,saved.get("answer").toString().contains("18X15X4+T"));assertFalse(saved.containsKey("readingSummary"));assertEquals(!citeFailed,AnalysisProtocolService.map(saved.get("factCoverage")).get("complete")); + var saved=json.readValue(jdbc.queryForObject("SELECT answer_json FROM analysis_turn WHERE id=?",String.class,turn),Map.class);assertEquals(details.get("conclusionProtocolQueryIds"),saved.get("conclusionProtocolQueryIds"));assertFalse(AnalysisProtocolService.list(saved.get("explorationWarnings")).isEmpty());assertEquals(answer().get("answer"),saved.get("answer"));assertEquals(citeFailed,AnalysisProtocolService.list(AnalysisProtocolService.map(saved.get("answerQuality")).get("missingEvidence")).stream().anyMatch(gap->gap.toString().contains("18X15X4+T")));assertFalse(saved.containsKey("readingSummary"));assertEquals(!citeFailed,AnalysisProtocolService.map(saved.get("factCoverage")).get("complete")); if(!citeFailed) { assertEquals(List.of(rootProof.get("queryId")),saved.get("protocolQueryIds"));assertEquals(2,jdbc.queryForObject("SELECT COUNT(*) FROM analysis_protocol_query",Integer.class)); String report=newTurn("汇总刚完成的质量解释");var reportAttempt=claim(report,false);var reportTask=historyTask(reportAttempt,report,"all");var imported=tx.execute(s->service.history(reportAttempt.attemptId(),actor));assertEquals(true,AnalysisProtocolService.map(imported.get("historyCoverage")).get("complete"),imported.toString()); @@ -1240,11 +1296,12 @@ class AnalysisProtocolServiceMySqlTest { var result=answer();String fullAnswer="已核实的业务解释。\n\n## 完整附录\n自动图表未生成,详细范围保留在此。";result.put("answer",fullAnswer);result.put("reportMarkdown",fullAnswer);result.put("visualState",preference.equals("required")?"ready":"failed");result.put("visuals",List.of()); if(preference.equals("required"))result.put("visuals",List.of(Map.of("metric","composite_rate","type","bar","period",Map.of("year",2026),"scope",Map.of("releaseId",release)))); if(withSummary)result.put("readingSummary",Map.of("version",1,"lead","业务概括","evidence",List.of("核心业务依据"),"notices",List.of("Python已归并的业务局限"),"evidenceRefs",List.of()));tx.executeWithoutResult(s->service.finish(a.attemptId(),"COMPLETED",result,Map.of("agentTask",task,"protocolEvidence",List.of(rootProof,rankProof),"conclusionProtocolQueryIds",List.of(rootProof.get("queryId"),rankProof.get("queryId")),"evidenceCompletion",Map.of("serverCoverageSufficient",true)),actor));assertEquals("PARTIAL",turnStatus(turn));var saved=json.readValue(jdbc.queryForObject("SELECT answer_json FROM analysis_turn WHERE id=?",String.class,turn),Map.class);assertEquals(true,AnalysisProtocolService.map(saved.get("factCoverage")).get("complete"));assertFalse(AnalysisProtocolService.list(saved.get("explorationWarnings")).isEmpty());assertEquals(fullAnswer,saved.get("reportMarkdown")); - if(withSummary) { - var notices=AnalysisProtocolService.list(AnalysisProtocolService.map(saved.get("readingSummary")).get("notices"));assertTrue(notices.contains("Python已归并的业务局限")); - if(preference.equals("auto")){assertTrue(notices.contains("Python已归并的业务局限"));assertTrue(notices.stream().anyMatch(notice->notice.toString().contains("图表尚未完整生成")));assertTrue(saved.get("answer").toString().contains("图表尚未完整生成"));} - else {assertTrue(notices.contains("用户要求的图表尚未完整生成"));assertTrue(saved.get("answer").toString().contains("用户要求的图表尚未完整生成"));assertTrue(notices.stream().noneMatch(n->n.toString().contains("可独立恢复图表")));} - } else {assertFalse(saved.containsKey("readingSummary"));if(preference.equals("auto"))assertTrue(saved.get("answer").toString().contains("图表尚未完整生成"));} + assertEquals(fullAnswer,saved.get("answer")); + var gaps=AnalysisProtocolService.list(AnalysisProtocolService.map(saved.get("answerQuality")).get("missingEvidence")); + assertTrue(gaps.stream().anyMatch(gap->gap.toString().contains("图表尚未完整生成"))); + if(preference.equals("required"))assertTrue(gaps.contains("用户要求的图表尚未完整生成")); + if(withSummary)assertEquals(result.get("readingSummary"),saved.get("readingSummary")); + else assertFalse(saved.containsKey("readingSummary")); } } @Test void nativeRecordsAppendixRetainsLegalPagesAtReadCapWithoutAcceptingIncompleteScope() { @@ -1255,7 +1312,7 @@ class AnalysisProtocolServiceMySqlTest { var result=answer();result.put("recordList",Map.of("queryComplete",true,"rows",List.of("invented"))); tx.executeWithoutResult(s->service.finish(a.attemptId(),"COMPLETED",result,Map.of("agentTask",task,"protocolEvidence",proofs,"conclusionProtocolQueryIds",List.of(),"evidenceCompletion",Map.of("serverCoverageSufficient",false)),actor));assertEquals("PARTIAL",turnStatus(turn));var saved=json.readValue(jdbc.queryForObject("SELECT answer_json FROM analysis_turn WHERE id=?",String.class,turn),Map.class);var listing=AnalysisProtocolService.map(saved.get("recordList")); assertEquals(false,listing.get("queryComplete"));assertEquals(4001,listing.get("totalRows"));assertEquals(4000,listing.get("loadedRows"));var set=AnalysisProtocolService.map(AnalysisProtocolService.list(listing.get("sets")).getFirst());assertEquals(false,set.get("complete"));assertEquals("001",AnalysisProtocolService.map(AnalysisProtocolService.map(AnalysisProtocolService.list(set.get("rows")).getFirst()).get("values")).get("委托单"));assertEquals("4000",AnalysisProtocolService.map(AnalysisProtocolService.map(AnalysisProtocolService.list(set.get("rows")).getLast()).get("values")).get("委托单")); - assertEquals(List.of(),saved.get("protocolQueryIds"));assertEquals(List.of(),saved.get("conclusionProtocolQueryIds"));assertEquals(40,AnalysisProtocolService.list(saved.get("attemptProtocolQueryIds")).size());assertEquals(false,AnalysisProtocolService.map(AnalysisProtocolService.list(saved.get("scopeCoverage")).getFirst()).get("complete"));assertTrue(saved.get("answer").toString().contains("尚未查全")); + assertEquals(List.of(),saved.get("protocolQueryIds"));assertEquals(List.of(),saved.get("conclusionProtocolQueryIds"));assertEquals(40,AnalysisProtocolService.list(saved.get("attemptProtocolQueryIds")).size());assertEquals(false,AnalysisProtocolService.map(AnalysisProtocolService.list(saved.get("scopeCoverage")).getFirst()).get("complete"));assertEquals(result.get("answer"),saved.get("answer"));assertFalse(AnalysisProtocolService.list(AnalysisProtocolService.map(saved.get("answerQuality")).get("missingEvidence")).isEmpty()); } @Test void explicitRawRootCannotCompleteByIgnoringAnUnreadRawScope() { enableAutonomous();String turn=newTurn("逐条读取全部黑片记录");var a=claim(turn,false);var proposal=rawTask(turn,"records");var rawNode=AnalysisProtocolService.map(AnalysisProtocolService.list(proposal.remove("queryPlan")).getFirst());proposal.put("executionMode","native_agent");var task=AnalysisProtocolService.map(tx.execute(s->service.confirm(a.attemptId(),proposal,actor)).get("task"));tx.execute(s->service.explorationStep(a.attemptId(),Map.of("requestKey","raw","node",rawNode),actor)); diff --git a/docs/AI智能分析要求与排查修复基准.md b/docs/AI智能分析要求与排查修复基准.md index 6c09290..1c59550 100644 --- a/docs/AI智能分析要求与排查修复基准.md +++ b/docs/AI智能分析要求与排查修复基准.md @@ -1,6 +1,6 @@ # AI 智能分析当前要求与排查修复基准 -适用项目:质量数据分析平台。更新日期:2026-10-31。 +适用项目:质量数据分析平台。更新日期:2026-11-02。 本文只列当前有效要求与对应验收标准,供智能分析排查、修复和交付时使用。 @@ -11,6 +11,7 @@ - AI 负责理解自然语言、选择查询、分析和表达;正式指标由现有业务服务、已发布规则和映射计算。 - 保留可靠的数据底座、正式口径、权限和数据快照约束。系统规则、模型行为、结果校验及页面展示必须一致。 - 用户最终看到清晰的结论、重点表格和重点图表,分析过程与最终结果对题、可信、可读。 +- 模型识别的一般问候、能力介绍和致谢直接保留其回复原文,不要求数据期间,不触发正式查询或二次生成;仍核验会话权限及取消状态。该路径不能输出未查询业务数值、趋势因果或声称已执行的操作,也不能代替记忆、报告或数据分析。后续业务目标与筛选保持原有效计划,普通对话不充当报告事实来源。 ## 2. 默认业务口径 diff --git a/scripts/nao_agent_task.py b/scripts/nao_agent_task.py index d90e592..7f38923 100644 --- a/scripts/nao_agent_task.py +++ b/scripts/nao_agent_task.py @@ -1480,6 +1480,11 @@ kind=members仅用于列出有哪些委托单/批号/规格等唯一成员,不 value = candidate recovery_repairs.extend(changes) protocol_context = (context or {}).get('_protocol') if isinstance(context, dict) else None + if (isinstance(protocol_context, dict) and protocol_context.get('version') == 1 + and task['kind'] in ('explain', 'restate') and not task.get('directResponse') + and not task['needsClarification']): + raise TaskUnavailable('当前协议的普通对话须提供directResponse;业务解释须选择正式分析或历史报告任务。', + field='kind.protocol', expected='supported business task or reviewed directResponse') if autonomous_session: from nao_native_planning import history_only_requested if (history_only_requested(question) and not task['needsClarification'] @@ -1572,7 +1577,7 @@ kind=members仅用于列出有哪些委托单/批号/规格等唯一成员,不 or _source_column_intent(question, (context or {}).get('_businessCatalog', {})))) member_list_review_required = task['kind'] == 'members' if ((task.get('directResponse') or (semantic_review and payload['previousUserQuestions']) or review_read_requirements) - and not autonomous_session + and (not autonomous_session or task.get('directResponse')) and (task['kind'] in ('analysis','metrics','members','explain','restate','source_verify','details') or review_read_requirements and task['kind'] == 'report')): review_system = ('你是只读任务计划的语义核对员。依据前序用户问题与最新问题核对计划是否真正回答最新意图,' @@ -1585,6 +1590,7 @@ kind=members仅用于列出有哪些委托单/批号/规格等唯一成员,不 '若用户要求报废率的分子分母或计算基数,实际fields须同时包含scrapRate、scrapWeight、totalWeight,不能只有goal提及;缺少任一应aligned=false。' '前序未完成的问题只提供语义,不是已核实结果;truncated的问题不完整,不推断省略内容。' 'directResponse仅用于一般问候、能力介绍或致谢;业务趋势、比较和原因判断即使没有数字也不能直答。' + '同时核对directResponse.answer正文;即使用户仅问候,只要回复夹带未查询业务事实或因果,必须判aligned=false或requiresEvidence=true。' '历史报告kind=report与复述不同:报告来源由服务端在任务确认后冻结和导入,规划上下文不会包含历史来源正文;' 'previousVerifiedTurns为空、缺失或没有来源摘要不能据此判断历史数据不存在,也不能把用户明确的报告意图改成explain/restate或要求用户证明历史来源存在。' '应按用户范围保留kind=report、historyMode=first/last/all、freshQuery=false及空root指标条件;来源可用性/缺口交由服务端导入结果决定。' @@ -1992,8 +1998,12 @@ kind=members仅用于列出有哪些委托单/批号/规格等唯一成员,不 if error.field: payload['validationFeedback'] = error.field + ': ' + str(error) payload['repairInstructions'] = '根据错误和上一份计划修正协议格式,保留原业务目标、期间及范围,返回完整JSON计划,不输出解释。' - if error.field == 'directResponse.business': - payload['repairInstructions'] = '当前问题涉及业务事实,禁止directResponse;保留用户最新问题及前文目标,返回完整业务分析或指标计划。' + if error.field == 'kind.protocol': + payload['repairInstructions'] = ('重新核对最新意图:一般问候、能力介绍或致谢必须返回kind=explain及directResponse的模型回复;' + '涉及业务事实则选择现有analysis/metrics/report等正式任务,不能用普通explain/restate绕过查询。记忆或操作要求不得伪装普通对话。') + elif error.field == 'directResponse.business': + payload['repairInstructions'] = ('上次回复夹带未经查询的业务判断,请重新核对最新用户意图:问候或能力介绍仍使用directResponse,仅介绍能做什么,不断言实际业务结果;' + '只有用户确实要求业务事实、比较或原因解释时,才改为完整业务分析或指标计划。保留原问题,不因上次错误回复改写用户目标。') elif error.field and error.field.startswith('directResponse'): payload['repairInstructions'] = '保持最小一般对话JSON,仅修复错误字段,保留kind、goal、directResponse;无需补全业务计划字段。answer只写一般回复,列表用项目符号,不写业务数值。' elif error.field and (error.field == 'queryPlan' or error.field.startswith('queryPlan.')): diff --git a/scripts/nao_conversation.py b/scripts/nao_conversation.py index 2d90f53..dc1fda8 100644 --- a/scripts/nao_conversation.py +++ b/scripts/nao_conversation.py @@ -33,10 +33,10 @@ def direct_plan(value): # Convert their prefixes to bullets; any remaining value still fails. text = re.sub(r'(?m)^[ \t]*[1-9]\d?[.、)][ \t]*(?!\d)', '- ', text) quantified_fact = (r'(?:\d+(?:[.,]\d+)*|[零〇一二两三四五六七八九十百千万点]+)\s*(?:[%%]|kg\b|公斤|千克|吨|个百分点|pp\b)' - r'|百分之|(?:合格率|投入|报废|总重|产量|重量|数量)(?:重量|数量|总数|率)?\s*(?:为|是|有|达到|共|合计|总计|[::])?\s*\d') - unperformed_action = r'(?:已|已经)(?:查到|查询|核实|统计|生成|保存|记住|修改|设置|完成分析)' + r'|百分之|(?:合格率|投入|报废|总重|产量|重量|数量)(?:重量|数量|总数|率)?\s*(?:为|是|有|达到|共|合计|总计|[::])?\s*(?:\d|[零〇一二两三四五六七八九十百千万点])') + unperformed_action = r'(?:已|已经)(?:查到|查询|核实|统计|生成|保存|记住|修改|设置|完成分析)(?!的)' if (isinstance(text,str) and re.search(r'合格率|报废|投入|产量|重量|分组|规格|产业部|国内|海外|产品',text) - and re.search(r'主要是.{0,40}所致|主要来自|所致|远高于|远低于|更大|更小|更差|更好|基本持平|明显.{0,8}(?:下降|上升|增加|减少)|导致.{0,12}(?:下降|上升)',text)): + and re.search(r'主要是.{0,40}所致|主要来自|主要原因是|所致|远高于|远低于|确实更(?:大|小|差|好)|基本持平|(?:下降|上升|增加|减少|恶化|改善)了|明显.{0,8}(?:下降|上升|增加|减少)|导致.{0,12}(?:下降|上升)',text)): invalid('当前答复包含未经查询的业务趋势或因果判断,请返回完整分析计划', 'directResponse.business') if (not isinstance(text, str) or not text.strip() or len(text) > 1200 or re.search(quantified_fact + '|' + unperformed_action + r'|https?://|Q[A-F0-9]{8}|<[^>]+>|Bearer\s+|\bsk-[A-Za-z0-9_-]+|(?:api[_-]?key|token|password)\s*[:=]',text,re.I)): diff --git a/scripts/nao_native_planning.py b/scripts/nao_native_planning.py index c8aab61..1ea7ae3 100644 --- a/scripts/nao_native_planning.py +++ b/scripts/nao_native_planning.py @@ -135,6 +135,7 @@ NATIVE_ROOT_PROMPT = '''你是质量数据分析平台的任务理解器,只 沿用previousTask中未取消的条件,以最新明确修改为准;previousUserQuestions和lastVisibleAnswer只是理解指代的资料,不能恢复已取消条件。 返回JSON:goal、kind、executionMode、filterUpdates、period、comparisonPeriod、comparisonRequired、trendRequired、dimensions、stages、fields、dimensionStages、memberFields、freshQuery、verifySource、fullDetails、needsClarification、clarification、visualPreference、responseStyle、historyMode。clarification始终是字符串,无澄清用空字符串,不能写对象;候选另放clarificationRequest。period年份和月份均为JSON整数,如{\"year\":2026,\"month\":9},不可只输出月份或字符串日期。 kind仅analysis/metrics/members/explain/restate/report/source_verify/details;visualPreference仅auto/required/none;responseStyle仅brief/standard/detailed(默认standard);historyMode仅none/first/last/all(默认none)。比较、趋势、freshQuery、verifySource、fullDetails、needsClarification均使用JSON布尔值,不写null。dimensions/stages/fields是数组,dimensionStages是对象,filterUpdates无变化时{}。 +一般问候、能力介绍和致谢必须返回kind=explain及directResponse={purpose:greeting/capabilities/acknowledgement,answer:你的完整简短回复,requiresMemory:false};仅声明explain/restate却不给出directResponse不受当前协议支持。业务解释仍使用正式analysis/metrics或历史report,不能改为普通对话。 为什么、原因定位、深入调查、解释多种变化及其续问使用kind=analysis、executionMode=native_agent,不写queryPlan。dimensions只填用户明确必须覆盖的维度,不预列所有调查方向;一般原因问题dimensions=[]、fields=[rate]。智能体之后根据实际结果决定查哪些组织、产品及缺陷。 简单单值/趋势用metrics;明确排序用原静态analysis及queryPlan;清单members、原表source_verify、记录details和历史report沿用原能力。非自主任务省略executionMode。kind=members只表示唯一成员清单,不是原始行读取;memberFields必须是当前businessCatalog.sourceFields中1到5个授权key,stages必须明确选一个或两个阶段,期间及普通filters照常保留,dimensions=[]、fields=[]、verifySource=false、fullDetails=false、freshQuery=true。kind=members时memberFields必须按当前businessCatalog.sourceFields字段label的语义选择,不能猜key或把筛选字段当输出成员。用户只说“有哪些规格”时按产品规格理解,选择真实“产品规格/成品规格/规格型号”目录列;不能用“产品图号/图纸号”或“客户代码”代替。“客户都有哪些规格”中的客户是筛选对象,输出仍是产品规格;明确问图号才选图号列,明确问“客户规格”才选客户规格列。用户明确说“成品规格”等具体目录label时,优先精确匹配该label;裸“规格”有多个可用产品规格候选或目标没有可用字段时,needsClarification=true、memberFields=[],保留原目标并请用户明确字段,不擅选近似列。并列、否定或复合字段意图保留模型确认的正向成员,不能补入用户已取消的字段。 静态合格率排名必须输出queryPlan,使用一个批量changes节点,禁止逐对象查询。root的dimensions、fields、stages、dimensionStages与节点联合需求一致;changes必须comparisonRequired=true并给出前一个同长度完整comparisonPeriod,即使按本期率排序也使用该两期批量接口。sort=current_rate按本期率升序;rate_drop按降幅降序;current_scrap/scrap_delta用于报废规模与不良影响。用户说“表现较差/最差”未指定指标时按黑片+亮片报废总重及综合合格率判断优先级,不只按极小批量最低率排序;比较分析用sort=current_scrap或scrap_delta。仅明确要求最低率时sort=current_rate。只问“哪个”limit=1,明确数量以用户为准,未指定通常3,最大10。fields按问题保留rate/totalWeight/scrapWeight;综合率stages=[]、dimensionStages={\"product\":[]}。明确按一个阶段的totalWeight或scrapWeight选产品Top N并显示这批对象的同阶段rate时,仍用静态analysis/queryPlan:先用base产品ranking按该阶段重量取Top N,再用metrics节点fields=[rate]、stages=[同阶段]和ranking_top selector绑定前置排名、同阶段、同重量指标及count=N。重量和对象选择来自排名,rate单独查询;不要把rate改为排序指标、对全体产品另查rate、加入比较或转成原因/缺陷调查。 diff --git a/scripts/nao_protocol_execution.py b/scripts/nao_protocol_execution.py index c83a70d..0e37d6a 100644 --- a/scripts/nao_protocol_execution.py +++ b/scripts/nao_protocol_execution.py @@ -1770,6 +1770,25 @@ def execute(*, request, task, authority, actor_root, delegated, connection, canc return result if cancel_event.is_set(): raise RuntimeError('cancelled') + if isinstance(task.get('directResponse'), dict): + from nao_quality_runtime import ConversationAccumulator, _atomic_json, _record_non_query_turn, public_progress_text + answer = task['directResponse']['answer'] + conversation = ConversationAccumulator() + conversation.record_event('assistant', text=public_progress_text(answer)) + _atomic_json(actor_root / 'private' / 'last-conversation-answer.json', { + 'turnId': request['turnId'], 'goal': task['goal'], + 'purpose': task['directResponse']['purpose'], 'answer': answer}) + _record_non_query_turn(actor_root, request) + result = {'type': 'result', 'engine': 'NAO', 'status': 'COMPLETED', 'answer': answer, + 'agentTask': task, 'protocol': identity, 'completionMethod': 'direct_conversation', + 'agentContext': {key: value for key, value in context.items() + if key in ('releaseId', 'period', 'comparisonPeriod', 'filters')}, + 'toolCalls': [], 'timeline': conversation.timeline, 'protocolEvidence': [], + 'queryEvidenceRefs': [], 'visualSchemaVersion': 1, 'visualState': 'not_requested', + 'visuals': [], 'stopReason': 'direct_conversation', 'finishReason': 'stop', + 'actualModel': connection[2], 'phaseTimingsMs': timings} + emit(result) + return result if task.get('kind') == 'report': from nao_history_report import execute_history_report return execute_history_report(request=request, task=task, authority=authority, diff --git a/verification/test_nao_conversation.py b/verification/test_nao_conversation.py index f4910b7..139079b 100644 --- a/verification/test_nao_conversation.py +++ b/verification/test_nao_conversation.py @@ -99,4 +99,40 @@ class ConversationTests(unittest.TestCase): for sanitizer in (public_progress_text,public_thinking_text): output=sanitizer(text);self.assertNotIn('quality-turn:',output);self.assertIn('继续答复',output) + +class AutonomousConversationReviewTests(unittest.TestCase): + def test_capability_descriptions_do_not_claim_to_have_run_a_query(self): + value=direct();value['directResponse']['answer']='我可以帮你比较不同产业部谁表现更好,并整理已核实的历史结果。' + self.assertEqual(normalize_task(value,'你能做什么')['directResponse']['answer'],value['directResponse']['answer']) + def test_unsupported_bare_explain_is_repaired_before_protocol_confirmation(self): + from test_nao_agent_task import task_value + replies=[task_value(kind='explain',freshQuery=False,fields=[],stages=[],dimensions=[],dimensionStages={}),direct(),{'aligned':True,'requiresEvidence':False}] + calls=[] + def opener(request,timeout): + calls.append(json.loads(request.data));reply=replies.pop(0) + return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(reply)}}]}).encode()) + task=plan_task(base_url='https://offline.invalid',api_key='synthetic',model='m',question='介绍一下能做哪些事',context={'_protocol':{'version':1,'autonomousEnabled':True}},cancel_event=threading.Event(),opener=opener) + self.assertIn('directResponse',task);self.assertEqual(len(calls),3);self.assertEqual(task['planRecovery']['errors'][0]['field'],'kind.protocol') + def test_autonomous_greeting_still_receives_independent_semantic_review(self): + bodies=[] + def opener(request,timeout): + bodies.append(json.loads(request.data));reply=direct() if len(bodies)==1 else {'aligned':True,'requiresEvidence':False} + return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(reply)}}]}).encode()) + task=plan_task(base_url='https://offline.invalid',api_key='synthetic',model='m',question='你好',context={'_protocol':{'version':1,'autonomousEnabled':True}},cancel_event=threading.Event(),opener=opener) + self.assertIn('directResponse',task);self.assertEqual(len(bodies),2);self.assertIn('plannedTask',json.loads(bodies[1]['messages'][1]['content'])) + def test_autonomous_business_answer_mislabelled_as_conversation_cannot_skip_evidence_review(self): + calls=[] + def opener(request,timeout): + body=json.loads(request.data);calls.append(body) + if 'plannedTask' in json.loads(body['messages'][1]['content']):reply={'aligned':True,'requiresEvidence':True} + else: + reply=direct();reply['directResponse']['answer']='这批比之前差,得调整设备。' + return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(reply)}}]}).encode()) + with self.assertRaises(TaskUnavailable):plan_task(base_url='https://offline.invalid',api_key='synthetic',model='m',question='解释这批次质量问题',context={'_protocol':{'version':1,'autonomousEnabled':True}},cancel_event=threading.Event(),opener=opener) + self.assertTrue(any('plannedTask' in json.loads(body['messages'][1]['content']) for body in calls)) + def test_unqueried_chinese_values_and_plain_causal_assertions_are_rejected(self): + for text in ['黑片合格率下降了,主要原因是设备故障。','上月报废重量为一百。']: + value=direct();value['directResponse']['answer']=text + with self.subTest(text=text),self.assertRaises(TaskUnavailable):normalize_task(value,'你好') + if __name__=='__main__':unittest.main() diff --git a/verification/test_protocol_conversation.py b/verification/test_protocol_conversation.py new file mode 100644 index 0000000..bb7ee95 --- /dev/null +++ b/verification/test_protocol_conversation.py @@ -0,0 +1,32 @@ +"""普通对话通过真实协议执行入口,不启动数据查询或二次模型生成。""" +import json,sys,tempfile,threading,unittest,uuid +from pathlib import Path +from unittest.mock import Mock,patch +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts')) +from nao_agent_task import normalize_task +from nao_protocol_execution import execute +class ProtocolConversationTests(unittest.TestCase): + def invoke(self,cancel=False,context=None): + with tempfile.TemporaryDirectory() as temp: + root=Path(temp);(root/'private').mkdir();(root/'evidence').mkdir();prior=root/'private/last-agent-task.json';prior.write_text('{"task":"prior business"}');before=prior.read_bytes() + raw={'kind':'explain','goal':'回应问候','directResponse':{'purpose':'greeting','answer':'你好!我可以协助你查询质量指标并比较期间变化。','requiresMemory':False}} + task=normalize_task(raw,'你好',context) + request={key:str(uuid.uuid4()) for key in ['turnId','sessionId','releaseId','actorId']};request['question']='你好';request['context']=context or {} + authority={key:request[key] for key in ['turnId','sessionId']};authority.update(attemptId=str(uuid.uuid4()),executionId=str(uuid.uuid4()),revision=1) + delegated=Mock();delegated.call.side_effect=AssertionError('ordinary conversation cannot read business data');events=[];event=threading.Event() + if cancel:event.set() + with patch('nao_evidence_finalizer.synthesize',side_effect=AssertionError('must keep the confirmed model reply')),patch('analysis_visual_evidence.visual_result',side_effect=AssertionError('no charts for a greeting')): + if cancel: + with self.assertRaises(RuntimeError):execute(request=request,task=task,authority=authority,actor_root=root,delegated=delegated,connection=('https://offline.invalid','synthetic','fixture'),cancel_event=event,emit=events.append) + self.assertEqual(events,[]) + else: + result=execute(request=request,task=task,authority=authority,actor_root=root,delegated=delegated,connection=('https://offline.invalid','synthetic','fixture'),cancel_event=event,emit=events.append) + self.assertEqual(result['status'],'COMPLETED');self.assertEqual(result['answer'],raw['directResponse']['answer']);self.assertEqual(result['completionMethod'],'direct_conversation') + self.assertEqual(result['protocol'],authority);self.assertEqual(result['protocolEvidence'],[]);self.assertEqual(result['queryEvidenceRefs'],[]);self.assertEqual(result['visuals'],[]) + self.assertTrue((root/'private/non-query-turns'/(request['turnId']+'.json')).exists()) + self.assertEqual(result['agentContext'],{key:value for key,value in request['context'].items() if key in ('releaseId','period','comparisonPeriod','filters')}) + delegated.call.assert_not_called();self.assertEqual(prior.read_bytes(),before) + def test_greeting_keeps_the_model_reply_without_period_or_queries(self):self.invoke() + def test_acknowledgement_keeps_the_existing_business_frame(self):self.invoke(context={'period':{'year':2026,'month':9},'filters':{'group':'G'}}) + def test_cancelled_conversation_does_not_publish(self):self.invoke(cancel=True) +if __name__=='__main__':unittest.main()