统一:DSH 智能分析、Top100 与图表静默恢复

接入 DSH 专用运行时和对话界面,保留模型原始回答,支持会话分页、连续追问与显式报告。
补齐组合筛选、各维度 Top100、分组查询到排名图的转换,图表故障静默省略并基于保存数据自动恢复。
优化报告风格、图表顺序和表格换行,更新接入说明及构建输入。

验证:独立目录前后端构建通过;118 项 Java、102 项前端、102 项图表、14 项 DSH 应用和 13 项组合筛选检查通过。
仅提交相关源码、锁定依赖与测试;不包含凭据、会话、业务数据或本地产物。
This commit is contained in:
2026-11-12 11:57:41 +08:00
parent cc8832c8e5
commit f1a2fbd494
166 changed files with 26281 additions and 2248 deletions
@@ -0,0 +1,78 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import ts from 'typescript';
import React from 'react';
import { renderToStaticMarkup } from 'react-dom/server';
import { buildAgentReportLayout, agentReportPrimary, agentReportSupplementary } from '../src/agent/agentReportLayout.ts';
import { stripDuplicateFirstMarkdownH1 } from '../src/analysisReportTitle.ts';
import { tableTextAlignment } from '../src/tableTextAlignment.ts';
import { sanitizeAnalysisDisplayText } from '../src/analysisDisplayText.ts';
import { analysisEvidenceParts } from '../src/analysisEvidenceRefs.ts';
function load(file, exported, bindings) {
const source=fs.readFileSync(new URL(file,import.meta.url),'utf8').replace(/^import .*;\n/gm,'').replaceAll('export function ','function ').replaceAll('export async function ','async function ');
return new Function(...Object.keys(bindings),ts.transpileModule(source+'\nreturn '+exported+';', {compilerOptions:{target:ts.ScriptTarget.ES2022,jsx:ts.JsxEmit.React}}).outputText.replace(/^export\s*\{\s*\};?$/gm,''))(...Object.values(bindings));
}
const AiMarkdown=load('../src/AiMarkdown.tsx','AiMarkdown',{React,tableTextAlignment,sanitizeAnalysisDisplayText,analysisEvidenceParts});
const figures=[{id:'trend',title:'月度趋势',type:'line',unit:'ratio',metric:'composite_rate',sectionKey:'trend',scope:{},categories:[],series:[],evidenceRefs:[]},
{id:'scrap',title:'报废结构',type:'bar',unit:'kg',metric:'scrap_weight',sectionKey:'category',scope:{},categories:[],series:[],evidenceRefs:[]}];
let images=[];
const Empty=()=>null;
const Document=load('../src/agent/AgentDeliverable.tsx','AgentDeliverable',{
React,useLayoutEffect:()=>{},useRef:value=>({current:value}),useState:value=>[value,()=>{}],
Alert:Empty,Spin:Empty,DownloadOutlined:Empty,Button:Empty,Modal:({children})=>React.createElement('main',null,children),
AnalysisMemberListReport:Empty,AnalysisRecordListReport:Empty,AiMarkdown,
ReportVisualFigure:({visual,image})=>image?.svg?React.createElement('figure',{'data-chart':visual.id},visual.title):React.createElement('table',{'data-fallback':visual.id},React.createElement('tbody',null,React.createElement('tr',null,React.createElement('td',null,visual.title)))),
reportVisualImageSource:image=>image?.svg||'',reportVisuals:()=>figures,
useReportVisualImages:()=>({authorized:true,loading:false,images}),analysisSnapshotResult:turn=>turn.result,
reportSnapshotIdentity:()=>'',analysisScopeText:()=>'',stripDuplicateFirstMarkdownH1,buildAgentReportLayout,agentReportPrimary,agentReportSupplementary,
captureReportLongImage:()=>{},downloadAuthorizedReport:()=>{},documentCss:'',
});
const answer='# 原始报告\n\n原始导读。\n\n## 月度趋势\n\n原始分析。\n\n| 月份 | 值 |\n|---|---|\n| 10月 | 95.46% |\n\n## 报废大类\n\n原始说明。';
function render() {return renderToStaticMarkup(React.createElement(Document,{turn:{status:'COMPLETED',question:'生成报告',result:{modelAnswer:answer,answer:'此替代回答不应显示'}},onClose:()=>{}}));}
test('every report figure precedes the original detail table, appears once, and leaves the source intact',()=>{
images=figures.map(v=>({id:v.id,svg:'data:image/svg+xml,test'}));
const html=render();
for(const id of ['trend','scrap']) {
assert.equal((html.match(new RegExp('data-chart="'+id+'"','g'))||[]).length,1);
assert.ok(html.indexOf('data-chart="'+id+'"')<html.indexOf('<table>'));
}
assert.ok(html.indexOf('原始分析。')<html.indexOf('原始说明。'));
assert.equal((html.match(/原始导读。/g)||[]).length,1);
assert.match(html,/95.46%/);assert.doesNotMatch(html,/此替代回答/);
});
test('a missing image is omitted while the healthy figure and original answer remain',()=>{
images=[{id:'trend',svg:'data:image/svg+xml,test'},{id:'scrap',failed:true}];
const html=render();
assert.equal((html.match(/data-chart=/g)||[]).length,1);
assert.doesNotMatch(html,/data-fallback|重试|暂不可用/);
assert.ok(html.indexOf('data-chart="trend"')<html.indexOf('<table>'));
assert.match(html,/原始说明。/);
});
test('no image yields no empty gallery and all original data remains accessible',()=>{
images=[];const html=render();assert.doesNotMatch(html,/agent-document-overview/);assert.match(html,/95.46%/);
assert.equal((html.match(/data-fallback=/g)||[]).length,0);
});
test('the real report figure quietly omits unavailable images',()=>{
const Figure=load('../src/AnalysisReportVisuals.tsx','ReportVisualFigure',{React,visualPeriodSummary:()=>'',visualScopeSummary:()=>''});
for(const image of [undefined,{id:'trend',failed:true}]) {
assert.equal(renderToStaticMarkup(React.createElement(Figure,{visual:{...figures[0],chartable:true},image,quiet:true})), '');
}
const image={id:'trend',svg:'data:image/svg+xml;charset=utf-8,%3Csvg%2F%3E'};
const html=renderToStaticMarkup(React.createElement(Figure,{visual:{...figures[0],chartable:true,coverage:{truncated:false}},image,quiet:true}));
assert.match(html,/<figure/);assert.match(html,/<img/);assert.doesNotMatch(html,/q-partial|暂不可用/);
});
test('ordinary AI replies never become a report even when a legacy report field exists',()=>{
const authored=load('../src/agent/AgentDeliverable.tsx','authoredReport',{analysisSnapshotResult:turn=>turn.result,stripDuplicateFirstMarkdownH1});
for(const question of ['2026年8月综合合格率是多少?','一句话回答,不生成报告。','对比9月10月,简短回答,不需要生成报告。','沿用上面,只回答这两项。']) {
assert.equal(authored({status:'COMPLETED',question,result:{modelAnswer:answer,reportMarkdown:answer}}),null);
}
assert.ok(authored({status:'COMPLETED',question:'生成亮片报废结构专题报告',result:{modelAnswer:answer}}));
assert.ok(authored({status:'COMPLETED',question:'生成质量异常诊断简报',result:{modelAnswer:answer}}));
});
@@ -0,0 +1,42 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import ts from 'typescript';
import React from 'react';
import { renderToStaticMarkup } from 'react-dom/server';
import { tableTextAlignment } from '../src/tableTextAlignment.ts';
import { sanitizeAnalysisDisplayText } from '../src/analysisDisplayText.ts';
import { analysisEvidenceParts } from '../src/analysisEvidenceRefs.ts';
const source = fs.readFileSync(new URL('../src/AiMarkdown.tsx', import.meta.url), 'utf8')
.replace(/^import .*;$/gm, '').replace('export function AiMarkdown', 'function AiMarkdown');
const Markdown = new Function('React', 'tableTextAlignment', 'sanitizeAnalysisDisplayText', 'analysisEvidenceParts',
ts.transpileModule(`${source}\nreturn AiMarkdown;`, { compilerOptions: { target: ts.ScriptTarget.ES2022, jsx: ts.JsxEmit.React } }).outputText
)(React, tableTextAlignment, sanitizeAnalysisDisplayText, analysisEvidenceParts);
test('original answers preserve wording, table headers, headings and escaped markup', () => {
const answer = '## 模型原始回答\n\n数学说明保留。\n\n| 月份 | 原始值 |\n| --- | --- |\n| 8月 | 98.35% |\n\n<script>alert(1)</script>';
const html = renderToStaticMarkup(React.createElement(Markdown, { content: answer, preserveSource: true }));
assert.match(html, /<h2>模型原始回答<\/h2>/);
assert.match(html, /数学说明保留/);
assert.match(html, /&lt;script&gt;alert\(1\)&lt;\/script&gt;/);
assert.doesNotMatch(html, /<script|序号|核心结论/);
assert.equal((html.match(/<th(?:>| )/g) || []).length, 2);
});
test('report layout preserves original Markdown instead of converting bold prose into chapters', async () => {
const { buildAgentReportLayout } = await import('../src/agent/agentReportLayout.ts');
const text = '**原始小节**\n\n原始正文。\n\n1. 原始项目。';
const report = buildAgentReportLayout(text, []);
assert.equal(report.sections.map(section => section.markdown).join('\n\n'), text);
});
test('original Markdown rules and quotes render semantically without altering their words or tables', () => {
const answer = '首句。\n---\n> **范围:**2026年10月\n> 保留 <script> 原文\n\n| 对象 | 值 |\n| --- | --- |\n| 总体 | 95.46% |\n\n***\n\n末句。';
const html = renderToStaticMarkup(React.createElement(Markdown, { content: answer, preserveSource: true }));
assert.equal((html.match(/<hr\/>/g) || []).length, 2);
assert.match(html, /<blockquote><strong>范围:<\/strong>2026年10月<br\/>保留 &lt;script&gt; 原文<\/blockquote>/);
assert.equal((html.match(/<table>/g) || []).length, 1);
assert.match(html, /首句。/); assert.match(html, /末句。/);
assert.doesNotMatch(html, /<script>|序号/);
});
@@ -0,0 +1,29 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import ts from 'typescript';
const source = fs.readFileSync(new URL('../src/agent/AgentDeliverable.tsx', import.meta.url), 'utf8');
const start = source.indexOf('export function reportRequested');
const end = source.indexOf('export function AgentDeliverable(');
const code = ts.transpileModule(source.slice(start, end).replaceAll('export function', 'function'), {
compilerOptions: { target: ts.ScriptTarget.ES2022 },
}).outputText;
const authoredReport = new Function('analysisSnapshotResult', 'stripDuplicateFirstMarkdownH1', code + '\nreturn authoredReport;')(
turn => turn.result || turn, text => text,
);
test('a restored clarification answer retains the explicitly requested report and raw body', () => {
const original = '# 排名报告\n\n模型原始正文';
const turn = { status: 'COMPLETED', question: '黑片or亮片', modelAnswer: original, reportMarkdown: original,
task: { aggregateSelection: { requestQuestion: '筛选10月合格率最低Top20产品,并生成报告' } } };
assert.equal(authoredReport(turn).markdown, original);
assert.equal(authoredReport({ ...turn, result: { modelAnswer: original, reportMarkdown: original, task: turn.task } }).markdown, original);
});
test('ordinary replies and new requests without an authored report cannot inherit a report card', () => {
const turn = { status: 'COMPLETED', question: '只回答名单,不生成报告', modelAnswer: '原始回答',
task: { aggregateSelection: { requestQuestion: '此前要求生成报告' } } };
assert.equal(authoredReport(turn), null);
assert.equal(authoredReport({ ...turn, task: {}, reportMarkdown: '原始回答' }), null);
});
@@ -0,0 +1,196 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { agentReportVisuals, buildAgentReportLayout, agentReportPrimary, agentReportChartWidth, agentReportSupplementary } from '../src/agent/agentReportLayout.ts';
import { parseAnalysisVisuals } from '../src/analysisVisualsModel.ts';
const trend = (metric, scope = {}, values = [.9515, .9529, .9546]) => ({
id: metric, metric, type: 'line', unit: 'ratio', sectionKey: 'trend',
title: metric, subtitle: '', period: { year: 2026, monthStart: 8, monthEnd: 10 },
originTurnId: 'turn-layout', requiredFields: [], coverage: { totalRows: 3, returnedRows: 3, truncated: false },
scope: { year: 2026, monthStart: 8, monthEnd: 10, ...scope },
categories: ['2026-08', '2026-09', '2026-10'].map(key => ({ key, label: key })),
series: [{ key: metric, label: metric, values }], evidenceRefs: [],
});
test('an authorized period aggregate populates the header and the report keeps authored chapter order', () => {
const markdown = `9月需要关注。\n\n## 趋势与阶段对照\n\n本期走势。\n\n## 月度明细\n\n| 月份 | 综合合格率 | 黑片合格率 | 亮片合格率 |\n|---|---|---|---|\n| 2026-08 | 95.15% | 97.31% | 97.77% |\n| 期间汇总 | 95.35% | 97.57% | 97.73% |`;
const result = buildAgentReportLayout(markdown, [trend('composite_rate'), trend('black_rate', { stage: 'black' }), trend('bright_rate', { stage: 'bright' })]);
assert.equal(result.lead, '9月需要关注。');
assert.deepEqual(result.sections.map(section => section.label), ['趋势与阶段对照', '月度明细']);
assert.deepEqual(result.metrics.map(metric => metric.value), ['95.35', '97.57', '97.73']);
assert.equal(result.sections[0].charts.paired, true);
assert.equal(result.sections[0].charts.stats[0].value, '+0.31');
});
test('unmatched chart scopes cannot be paired and missing months cannot produce trend summaries', () => {
const monthly = trend('composite_rate', {}, [.9515, null, .9546]);
const result = buildAgentReportLayout('## 月度趋势\n\n按月观察。', [monthly, trend('black_rate', { department: '另一个范围' })]);
assert.equal(result.sections[0].charts.paired, false);
assert.deepEqual(result.sections[0].charts.stats, []);
assert.deepEqual(result.metrics, []);
});
test('two-month comparison uses unrounded signed values from the bound figure', () => {
const visual = { ...trend('composite_rate'), type: 'column', sectionKey: 'overview', comparisonPeriod: { year: 2026, month: 9 },
categories: [{ key: 'comparison', label: '2026-09' }, { key: 'current', label: '2026-10' }],
series: [{ key: 'composite_rate', values: [.9803797366305572, .977442975471237] }],
};
const result = buildAgentReportLayout('下降0.29个百分点。\n\n## 口径说明\n\n同范围比较。', [visual]);
assert.equal(result.lead, '下降0.29个百分点。');
assert.deepEqual(result.metrics.map(metric => metric.value), ['98.04', '97.74', '-0.29']);
});
test('a checklist keeps the requested chapters and does not acquire invented metrics or charts', () => {
const markdown = '先核对计量记录。\n\n## 现场核查\n\n1. 核对工位。\n2. 核对批次。\n\n## 待证实\n\n待核实现场。';
const result = buildAgentReportLayout(markdown, []);
assert.deepEqual(result.sections.map(section => section.label), ['现场核查', '待证实']);
assert.match(result.sections[0].markdown, /1\. 核对工位。\n2\. 核对批次。/);
assert.ok(result.sections.every(section => section.charts.figures.length === 0));
assert.deepEqual(result.metrics, []);
});
test('the live model stage-row aggregate table produces the same three header metrics without rewriting its text', () => {
const markdown = `## 二、期间汇总正式指标(公司总体,1—10月聚合值)
| 阶段 | 合格率 | 报废率 | 投入重量 |
|---|---:|---:|---:|
| 综合 | **95.35%** | — | — |
| 黑片 | 97.57% | 2.46% | 12,129,113.00 kg |
| 亮片 | 97.73% | 2.27% | 12,702,288.25 kg |`;
const result = buildAgentReportLayout(markdown, []);
assert.deepEqual(result.metrics.map(({ label, value }) => ({ label, value })), [
{ label: '综合合格率', value: '95.35' }, { label: '黑片合格率', value: '97.57' }, { label: '亮片合格率', value: '97.73' },
]);
assert.equal(result.sections.map(section => section.markdown).join(''), markdown);
});
test('a stage table for a single month cannot be mistaken for the period aggregate', () => {
const markdown = `## 5月阶段对照
| 阶段 | 合格率 |
|---|---:|
| 综合 | 95.12% |
| 黑片 | 97.31% |
| 亮片 | 97.75% |`;
assert.deepEqual(buildAgentReportLayout(markdown, []).metrics, []);
});
test('a model-authored aggregate caption binds its following indicator-value table', () => {
const markdown = '## 核心发现\n\n**期间汇总正式合格率**\n\n| 指标 | 正式值 |\n|---|---|\n| 综合合格率 | 95.35% |\n| 黑片合格率 | 97.57% |\n| 亮片合格率 | 97.73% |';
assert.deepEqual(buildAgentReportLayout(markdown, []).metrics.map(metric => metric.value), ['95.35', '97.57', '97.73']);
});
test('an explicit period lead can present all three authored rates without a duplicate table', () => {
const markdown = '2026年1—10月期间,综合合格率为 **95.35%**,黑片合格率为 **97.57%**,亮片合格率为 **97.73%**。\n\n## 趋势与阶段对照\n\n5月需要关注。';
const layout = buildAgentReportLayout(markdown, []);
assert.deepEqual(layout.metrics.map(metric => metric.value), ['95.35', '97.57', '97.73']);
assert.equal(layout.lead, markdown.split('\n\n')[0]);
});
test('the two stage trends share one report panel with their original tenors and scopes preserved', () => {
const inputs = [trend('composite_rate'), { ...trend('black_rate', { stage: 'black' }), chartable: true, requiredFields: [] },
{ ...trend('bright_rate', { stage: 'bright' }), chartable: true, requiredFields: [] }];
const before = JSON.stringify(inputs);
const panels = agentReportVisuals(inputs);
assert.equal(panels.length, 2);
assert.deepEqual(panels[1].series.map(series => series.key), ['black_rate', 'bright_rate']);
assert.deepEqual(panels[1].series[1].values, inputs[2].series[0].values);
assert.equal(parseAnalysisVisuals([panels[1]], 1).visuals[0]?.chartable, true);
assert.equal(JSON.stringify(inputs), before);
assert.equal(buildAgentReportLayout('## 趋势与阶段对照', panels).sections[0].charts.paired, true);
const mismatched = { ...inputs[2], scope: { ...inputs[2].scope, department: '其他产业部' } };
assert.equal(agentReportVisuals([inputs[1], mismatched]).length, 2);
});
test('a bold-prefixed original introduction becomes the lead exactly once', () => {
const lead = '**主要发现:**2026年10月全公司综合合格率为 **95.46%**,黑片合格率97.54%,亮片合格率97.86%;产业部差异见下表。';
const body = '## 产业部差异\n\n保留原文。\n\n---\n\n## 报废结构\n\n原始表格。';
const result = buildAgentReportLayout(`${lead}\n\n${body}`, []);
assert.equal(result.lead, lead);
assert.equal(result.sections.map(section => section.markdown.trim()).join('\n\n'), body);
assert.deepEqual(result.metrics.map(metric => metric.value), ['95.46', '97.54', '97.86']);
});
test('company headline metrics never borrow a later department or infer absent stage rates', () => {
for (const text of [
'全公司综合合格率95.46%;产业部黑片合格率97.54%,亮片合格率97.86%。',
'全公司产业部对比:综合合格率95.46%,黑片合格率97.54%,亮片合格率97.86%。',
'综合合格率95.46%,黑片合格率97.54%,亮片合格率97.86%。',
]) assert.deepEqual(buildAgentReportLayout(text, []).metrics, []);
});
test('an explicit overall stage-column table supplies cards without rewriting shorthand prose', () => {
const lead = '期间综合合格率95.35%,黑片、亮片合格率分别为97.57%和97.73%。';
const body = '## 一、总体表现\n\n综合合格率为95.35%。\n\n| 指标 | 黑片 | 亮片 |\n|---|---:|---:|\n| 合格率 | 97.57% | 97.73% |\n| 剔除本部报废后合格率 | — | 97.81% |';
const result = buildAgentReportLayout(lead + '\n\n' + body, []);
assert.deepEqual(result.metrics.map(metric => metric.value), ['95.35', '97.57', '97.73']);
assert.equal(result.lead, lead);
assert.equal(result.sections[0].markdown, body);
assert.deepEqual(buildAgentReportLayout(body.replace('总体表现', '5月对照'), []).metrics, []);
assert.deepEqual(buildAgentReportLayout(body.replace('综合合格率为95.35%。', '综合合格率为95.35%,综合合格率为95.46%。'), []).metrics, []);
});
test('the live stage-row report retains its three stated metrics and authored body', () => {
const text='**导读:**全公司综合合格率95.35%,黑片97.57%、亮片97.73%。\n\n## 一、总体表现\n\n期间正式综合合格率为95.35%。\n\n| 阶段 | 投入重量 | 合格率 |\n|---|---:|---:|\n| 黑片 | 100 | 97.57% |\n| 亮片 | 200 | 97.73% |';
const layout=buildAgentReportLayout(text,[]);
assert.deepEqual(layout.metrics.map(metric=>metric.value),['95.35','97.57','97.73']);
assert.equal(layout.lead+'\n\n'+layout.sections[0].markdown,text);
});
test('the primary chart uses an existing composite trend or the available stages without inventing a series', () => {
const stages={...trend('black_rate'),id:'stages',series:[{key:'black_rate',values:[.97,.98,.97]},{key:'bright_rate',values:[.98,.97,.98]}]};
const overall=trend('composite_rate'),before=JSON.stringify([stages,overall]);
assert.equal(agentReportPrimary([stages,overall]),overall);
assert.equal(agentReportPrimary([stages]),stages);
assert.equal(agentReportChartWidth(overall,[stages,overall]),660);
assert.equal(agentReportChartWidth(stages,[stages,overall]),500);
assert.equal(agentReportPrimary([]),undefined);
assert.equal(JSON.stringify([stages,overall]),before);
});
test('supplementary trends remain primary content when the question requests them', () => {
const overall=trend('composite_rate'),scrap=trend('black_scrap_rate'),volume=trend('black_total_weight');
const inputs=[overall,scrap,volume];
assert.equal(agentReportSupplementary(scrap,inputs,'总体质量报告'),true);
assert.equal(agentReportSupplementary(volume,inputs,'总体质量报告'),true);
assert.equal(agentReportSupplementary(scrap,inputs,'分析报废率变化'),false);
assert.equal(agentReportSupplementary(volume,inputs,'分析投入重量变化'),false);
assert.equal(agentReportSupplementary(scrap,[scrap],'总体质量报告'),false);
});
test('structure reports use formal composition before a monthly weight trend', () => {
const monthly = { ...trend('current_scrap_weight'), unit: 'kg' };
const composition = { ...monthly, id: 'categories', type: 'donut', dimension: 'category', sectionKey: 'composition', metric: 'source_defect_weight' };
assert.equal(agentReportPrimary([monthly, composition], '亮片报废结构专题报告'), composition);
assert.equal(agentReportSupplementary(monthly, [monthly, composition], '亮片报废结构专题报告'), true);
});
test('repeated rankings preserve the requested Top and keep distinct metrics and scopes', () => {
const ranking = { ...trend('bright_scrap_weight'), type: 'bar', unit: 'kg', dimension: 'group', sectionKey: 'group',
categories: ['a','b','c','d','e'].map(key=>({key,label:key})), series: [{key:'bright_scrap_weight',values:[5,4,3,2,1]}] };
const expanded = { ...ranking, id: 'expanded', categories: [...ranking.categories,{key:'f',label:'f'}], series:[{key:'bright_scrap_weight',values:[5,4,3,2,1,.5]}] };
const copy = { ...ranking, id:'duplicate', evidenceRefs:['another-read'] };
const another = { ...ranking, id:'another-scope',scope:{department:'other'} };
const original = JSON.stringify([ranking,expanded,copy,another]);
const figures=agentReportVisuals([ranking,expanded,copy,another], '业务分组Top5对比简报');
assert.deepEqual(figures.map(v=>v.id),[ranking.id,another.id]);
assert.equal(JSON.stringify([ranking,expanded,copy,another]),original);
});
test('a saved structure report without a formal composition image prefers its actual defect ranking over a trend',()=>{
const monthly={...trend('current_scrap_weight'),unit:'kg'};
const defects={...monthly,id:'defect-bars',type:'bar',dimension:'defect',metric:'source_defect_weight'};
assert.equal(agentReportPrimary([monthly,defects],'亮片报废结构专题报告'),defects);
});
test('an available Top10 snapshot displays the requested Top5 without changing saved data or composition',()=>{
const ten={...trend('source_defect_weight'),unit:'kg',type:'bar',dimension:'defect',
categories:Array.from({length:10},(_,i)=>({key:String(i),label:'项目'+i})),
series:[{key:'source_defect_weight',label:'来源细分重量',values:[10,9,8,7,6,5,4,3,2,1]}],coverage:{totalRows:21,returnedRows:10,truncated:true}};
const pie={...ten,id:'composition',dimension:'category',type:'donut',categories:ten.categories.slice(0,4),series:[{key:'source_defect_weight',label:'正式类别重量',values:[4,3,2,1]}]};
const before=JSON.stringify([ten,pie]);const figures=agentReportVisuals([ten,pie],'亮片报废结构,具体缺陷Top5');
assert.equal(figures[0].categories.length,5);assert.deepEqual(figures[0].series[0].values,[10,9,8,7,6]);
assert.equal(figures[0].coverage.returnedRows,5);assert.equal(figures[0].coverage.totalRows,21);
assert.equal(figures[1].categories.length,4);assert.equal(JSON.stringify([ten,pie]),before);
assert.equal(parseAnalysisVisuals([figures[0]],1).visuals[0]?.chartable,true,'the cropped visual must remain renderable by the export parser');
});
@@ -83,20 +83,18 @@ test('a refreshed question clears prior selections; disabled views cannot submit
ui.choose('18X15X4+T'); ui.props.disabled = true; ui.render(); ui.confirm(); assert.deepEqual(calls, []);
});
test('current page wires clarification only to the latest editable turn through normal submission', () => {
const source = fs.readFileSync(new URL('../src/ManagementPages.tsx', import.meta.url), 'utf8');
const historical = source.slice(source.indexOf('{turns.map((turn, index)'), source.indexOf('{lastTurn && <AnalysisTurn'));
assert.doesNotMatch(historical, /onClarify=/);
assert.match(source, /onClarify=\{sessionReadOnly \? undefined : question => submit\(question\)\}/);
test('the DSH workspace wires clarification only for the latest turn and editable sessions', () => {
const workspace = fs.readFileSync(new URL('../src/agent/AgentWorkspace.tsx', import.meta.url), 'utf8');
const conversation = fs.readFileSync(new URL('../src/agent/AgentConversation.tsx', import.meta.url), 'utf8');
assert.match(workspace, /canAct=\{!state\.readOnly && !state\.busy && !state\.historyLoading\} latest=\{turn === lastTurn\}/);
assert.match(workspace, /onPrompt=\{prompt\}/);
assert.match(conversation, /status === 'NEEDS_CLARIFICATION' && latest && <AnalysisClarification turn=\{turn\} disabled=\{!canAct\} onContinue=\{onPrompt\}/);
});
test('reopened conversations restore only the newest unanswered clarification to the current turn', () => {
test('reopened conversations can identify the newest unanswered clarification', () => {
const waiting = turn();
assert.equal(pendingClarificationTurnId([]), '');
assert.equal(pendingClarificationTurnId([{id:'old', status:'COMPLETED'}, waiting]), waiting.id);
assert.equal(pendingClarificationTurnId([waiting, {id:'answered',status:'COMPLETED'}]), '');
assert.equal(pendingClarificationTurnId([{id:'failed', status:'FAILED'}]), '');
const source = fs.readFileSync(new URL('../src/ManagementPages.tsx', import.meta.url), 'utf8');
assert.match(source, /focusTurnId \|\| \(active \? String\(active.id \|\| ''\) : pendingClarificationTurnId\(historyTurns\)\)/);
});
+114 -53
View File
@@ -3,60 +3,121 @@ import assert from 'node:assert/strict';
import fs from 'node:fs';
import ts from 'typescript';
import React from 'react';
import {renderToStaticMarkup} from 'react-dom/server';
import {analysisStreamStatus,analysisIsRunning,acceptAnalysisEvent,settledAnalysisTurn} from '../src/analysisConversationState.ts';
const source=fs.readFileSync(new URL('../src/ManagementPages.tsx',import.meta.url),'utf8');
const compile=code=>ts.transpileModule(code,{fileName:'status.tsx',compilerOptions:{target:ts.ScriptTarget.ES2022,jsx:ts.JsxEmit.React}}).outputText;
const tick=()=>new Promise(resolve=>setImmediate(resolve));
const deferred=()=>{let resolve;const promise=new Promise(r=>resolve=r);return{promise,resolve};};
const isObjectRecord=v=>!!v&&typeof v==='object'&&!Array.isArray(v);
const finalStatuses=new Set(['COMPLETED','PARTIAL','FAILED','CANCELLED','NEEDS_CLARIFICATION']);
function fixture(){
let lastTurn={id:'t1',question:'q',status:'QUEUED',createdAt:'2026-11-02T01:00:00Z'},onEvent,reads=0;
const stream=deferred(),firstRead=deferred(),secondRead=deferred();
const env={mounted:{current:true},streamController:{current:null},subscriptionGeneration:{current:0},sessionId:'s1',eventCursors:{current:{}},ANALYSIS_FINAL_STATUSES:finalStatuses,
setLastTurn:next=>lastTurn=typeof next==='function'?next(lastTurn):next,writeAnalysisLocation(){},setActiveTurnId(){},setBusy(){},setRetryQuestion(){},setTurns(){},setError(){},loadSessions:async()=>{},onUnauthorized:()=>false,apiMessage:e=>e.message,
isObjectRecord,analysisStreamStatus,analysisIsRunning,acceptAnalysisEvent,settledAnalysisTurn,collectionItems:value=>value.items||[],modelThinkingEntries:()=>[],mergeModelThinking:()=>[]};
const api={analysisTurnEvents:async(_id,options)=>{onEvent=options.onEvent;return stream.promise;},analysisSessionTurns:()=>{reads++;return reads===1?firstRead.promise:secondRead.promise;}};
const code=source.slice(source.indexOf(' const followTurn = async'),source.indexOf('\n useEffect(() => {\n if (!active || restoreStarted.current)'));
const follow=new Function('api',...Object.keys(env),compile(code+'\nreturn followTurn;'))(api,...Object.values(env));
const work=follow('t1','q','s1');
return{get:()=>lastTurn,reads:()=>reads,switchTurn(){env.subscriptionGeneration.current++;lastTurn={id:'other',status:'RUNNING'};},emit(event,data){onEvent({id:String(Math.random()),event,data});},firstRead,secondRead,async close(){env.streamController.current?.abort();stream.resolve();await work;}};
import { renderToStaticMarkup } from 'react-dom/server';
import { analysisStreamStatus, analysisIsRunning } from '../src/analysisConversationState.ts';
import { sanitizeAnalysisDisplayText } from '../src/analysisDisplayText.ts';
import { createAnalysisSessionClient } from '../src/agent/sessionClient.ts';
const CREATED_AT = '2026-11-02T01:00:00Z';
const STARTED_AT = '2026-11-02T01:00:05Z';
const initialTurn = { id: 't1', question: '质量查询', status: 'QUEUED', createdAt: CREATED_AT, eventCursor: '10' };
const page = (id, turn, activeTurnId = turn.id) => ({ id, activeTurnId, turns: [turn] });
function fixture(t) {
const connections = [];
const pages = { s1: page('s1', initialTurn), s2: page('s2', { id: 'other', status: 'RUNNING' }) };
let auxiliaryReads = 0;
const unexpectedRead = async () => { auxiliaryReads++; throw new Error('Unexpected auxiliary read'); };
const client = createAnalysisSessionClient({
userId: 'status-fixture',
transport: {
analysisSessions: async () => ({ items: [] }),
analysisSessionPage: unexpectedRead,
analysisTurn: unexpectedRead,
analysisTurnEvents: unexpectedRead,
analysisSessionTurns: unexpectedRead,
analysisSessionFollow: (id, { signal, onEvent }) => new Promise(resolve => {
connections.push({ id, signal, emit: onEvent, close: resolve });
signal.addEventListener('abort', resolve, { once: true });
onEvent({ event: 'snapshot', data: pages[id] });
}),
},
});
t.after(client.dispose);
return { client, connections, pages, auxiliaryReads: () => auxiliaryReads };
}
test('tool step events keep the whole turn running and terminal status does not regress',()=>{
assert.equal(analysisStreamStatus('RUNNING','tool_started',undefined),'RUNNING');
assert.equal(analysisStreamStatus('RUNNING','tool_completed','completed'),'RUNNING');
assert.equal(analysisStreamStatus('RUNNING','completed','COMPLETED'),'COMPLETED');
assert.equal(analysisStreamStatus('COMPLETED','progress','RUNNING'),'COMPLETED');
});
test('actual event subscriber keeps status live and fills the server clock without re-entering',async()=>{
const ui=fixture();assert.equal(ui.reads(),1);
ui.emit('progress',{status:'RUNNING'});
ui.firstRead.resolve({items:[{id:'t1',createdAt:'2026-11-02T01:00:00Z',startedAt:''}]});await tick();
assert.equal(ui.reads(),2,'a running event during an initial queued timing read schedules one non-overlapping follow-up');
ui.secondRead.resolve({items:[{id:'t1',startedAt:'2026-11-02T01:00:05Z'}]});await tick();
ui.emit('tool_started',{step:{status:'running'}});
assert.equal(ui.get().status,'RUNNING');assert.equal(ui.get().startedAt,'2026-11-02T01:00:05Z');
ui.emit('tool_completed',{step:{status:'completed'}});assert.equal(ui.get().status,'RUNNING');
assert.equal(ui.reads(),2);await ui.close();
});
test('late timing metadata cannot update a different selected turn',async()=>{
const ui=fixture();ui.switchTurn();await ui.close();ui.firstRead.resolve({items:[{id:'t1',startedAt:'2026-11-02T01:00:05Z'}]});await tick();
assert.equal(ui.get().startedAt,undefined);
});
test('metadata renders a waiting clock immediately and a spinning running clock after server start',()=>{
const code=source.slice(source.indexOf('function AnalysisTurnMetadata('),source.indexOf('\nfunction isObjectRecord('));
const Metadata=new Function('React','useState','useEffect','analysisIsRunning','isObjectRecord','LoadingOutlined',compile(code+'\nreturn AnalysisTurnMetadata;'))(React,initial=>[initial,()=>{}],()=>{},analysisIsRunning,isObjectRecord,props=>React.createElement('i',props));
const now=Date.now();
const waiting=renderToStaticMarkup(React.createElement(Metadata,{turn:{_uiSubmittedAt:new Date(now-30000).toISOString()},status:'SUBMITTING',compact:true}));
assert.match(waiting,/提交中/);assert.match(waiting,/已等待 30秒/);
const running=renderToStaticMarkup(React.createElement(Metadata,{turn:{startedAt:new Date(now-10000).toISOString()},status:'RUNNING',compact:true}));
assert.match(running,/已运行 10秒/);assert.match(running,/analysis-runtime-spinner/);
const currentTurn = client => client.getSnapshot().turns.at(-1);
const tick = () => new Promise(resolve => setImmediate(resolve));
test('tool status is independent of the turn status and terminal status stays settled', () => {
assert.equal(analysisStreamStatus('RUNNING', 'tool_started', undefined), 'RUNNING');
assert.equal(analysisStreamStatus('RUNNING', 'tool_completed', 'completed'), 'RUNNING');
assert.equal(analysisStreamStatus('RUNNING', 'completed', 'COMPLETED'), 'COMPLETED');
assert.equal(analysisStreamStatus('COMPLETED', 'progress', 'RUNNING'), 'COMPLETED');
});
test('partial remains a backend state without an extra partial label in conversation metadata',()=>{
const code=source.slice(source.indexOf('function AnalysisTurnMetadata('),source.indexOf('\nfunction isObjectRecord('));
const Metadata=new Function('React','useState','useEffect','analysisIsRunning','isObjectRecord','LoadingOutlined',compile(code+'\nreturn AnalysisTurnMetadata;'))(React,initial=>[initial,()=>{}],()=>{},analysisIsRunning,isObjectRecord,()=>null);
const html=renderToStaticMarkup(React.createElement(Metadata,{turn:{durationMs:6000},status:'PARTIAL',compact:true}));
assert.doesNotMatch(html,/部分完成/);assert.match(html,/运行时长 6秒/);
test('the follow connection supplies the server start time without an auxiliary read', async t => {
const { client, connections, auxiliaryReads } = fixture(t);
assert.equal(await client.openSession('s1'), true);
assert.equal(currentTurn(client).status, 'QUEUED');
assert.equal(currentTurn(client).createdAt, CREATED_AT);
assert.equal(currentTurn(client).startedAt, undefined);
const { emit } = connections[0];
emit({ id: '11', event: 'progress', data: { turnId: 't1', status: 'RUNNING', startedAt: STARTED_AT } });
emit({ id: '12', event: 'tool_started', data: { turnId: 't1', step: { status: 'running' } } });
emit({ id: '13', event: 'tool_completed', data: { turnId: 't1', status: 'completed' } });
assert.equal(currentTurn(client).status, 'RUNNING');
assert.equal(currentTurn(client).startedAt, STARTED_AT);
assert.equal(client.getSnapshot().busy, true);
assert.equal(auxiliaryReads(), 0);
assert.equal(connections.length, 1);
});
test('late server clock events from an aborted connection cannot update the newly selected turn', async t => {
const { client, connections } = fixture(t);
await client.openSession('s1');
await client.openSession('s2');
assert.equal(connections[0].signal.aborted, true);
connections[0].emit({ id: '11', event: 'progress', data: { turnId: 't1', status: 'RUNNING', startedAt: STARTED_AT } });
assert.equal(currentTurn(client).id, 'other');
assert.equal(currentTurn(client).startedAt, undefined);
});
test('the terminal event settles immediately and the replacement snapshot supplies the saved duration', async t => {
const { client, connections, pages, auxiliaryReads } = fixture(t);
await client.openSession('s1');
const { emit, close } = connections[0];
emit({ id: '11', event: 'completed', data: { turnId: 't1', status: 'COMPLETED', result: { answer: '已核验答复' } } });
assert.equal(currentTurn(client).status, 'COMPLETED');
assert.equal(currentTurn(client).answer, '已核验答复');
assert.equal(client.getSnapshot().busy, false);
pages.s1 = page('s1', { ...initialTurn, status: 'COMPLETED', eventCursor: '11', durationMs: 6000, result: { answer: '已核验答复' } }, '');
close();
await tick();
assert.equal(connections.length, 2);
assert.equal(currentTurn(client).durationMs, 6000);
assert.equal(auxiliaryReads(), 0);
});
const source = fs.readFileSync(new URL('../src/agent/AgentConversation.tsx', import.meta.url), 'utf8');
const statusSource = source.slice(source.indexOf('function RunStatus('), source.indexOf('\nfunction ExecutionEvents('));
const statusJavaScript = ts.transpileModule(`${statusSource}\nreturn RunStatus;`, {
fileName: 'status.tsx', compilerOptions: { target: ts.ScriptTarget.ES2022, jsx: ts.JsxEmit.React },
}).outputText;
const fixedClock = class extends Date { static now() { return Date.parse('2026-11-02T01:00:15Z'); } };
const record = value => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
const string = value => typeof value === 'string' ? value : '';
const LoadingOutlined = () => React.createElement('i', { className: 'test-loading-icon' });
const RunStatus = new Function('React', 'useState', 'useEffect', 'analysisIsRunning', 'sanitizeAnalysisDisplayText',
'record', 'string', 'LoadingOutlined', 'Date', statusJavaScript)(React, React.useState, React.useEffect,
analysisIsRunning, sanitizeAnalysisDisplayText, record, string, LoadingOutlined, fixedClock);
const renderStatus = turn => renderToStaticMarkup(React.createElement(RunStatus, { turn }));
test('run status renders a submission clock and prefers the actual server start time while running', () => {
const waiting = renderStatus({ _uiSubmittedAt: '2026-11-02T00:59:45Z', status: 'SUBMITTING' });
assert.match(waiting, /提交中/);
assert.match(waiting, /<time>30 秒<\/time>/);
const running = renderStatus({ createdAt: CREATED_AT, startedAt: STARTED_AT, status: 'RUNNING' });
assert.match(running, /分析中/);
assert.match(running, /agent-run-status is-running/);
assert.match(running, /test-loading-icon/);
assert.match(running, /<time>10 秒<\/time>/);
});
test('a partial result renders its status once and shows the saved duration', () => {
const html = renderStatus({ durationMs: 6000, status: 'PARTIAL' });
assert.equal(html.match(/部分完成/g)?.length, 1);
assert.match(html, /<time>6 秒<\/time>/);
assert.doesNotMatch(html, /is-running|test-loading-icon/);
});
+176 -65
View File
@@ -1,77 +1,188 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import ts from 'typescript';
import {analysisComposerState} from '../src/analysisScope.ts';
const source=fs.readFileSync(new URL('../src/ManagementPages.tsx',import.meta.url),'utf8');
const tick=()=>new Promise(resolve=>setImmediate(resolve));
const deferred=()=>{let resolve;const promise=new Promise(r=>resolve=r);return{promise,resolve};};
function restoreFixture({sessionId='',turnId='',link=false}={}){
const list=deferred(),opens=[];let effect,loading=true;
const env={active:true,restoreStarted:{current:false},mounted:{current:true},navigationGeneration:{current:0},initialSessionId:sessionId,initialTurnId:turnId,initialLink:{present:link},user:{id:'u'},
useEffect:fn=>{effect=fn;},setHistoryLoading:v=>{loading=v;},setSessions(){},setSessionsLoaded(){},setSessionsLoading(){},collectionItems:v=>v.items||[],
loadSessions:async()=>(await list.promise).items,api:{analysisSessions:()=>list.promise,analysisTurn:async()=>({sessionId:'linked-session'})},defaultAnalysisSession:(_u,items)=>items[0]?.id,
openSession:async(...args)=>{opens.push(args);loading=false;return true;},onUnauthorized:()=>false,setError(){},apiMessage:e=>e.message};
const marker=' useEffect(() => {\n if (!active || restoreStarted.current)';const start=source.indexOf(marker);const end=source.indexOf('\n useEffect(() => {',start+marker.length);
const code=ts.transpileModule(source.slice(start,end),{compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText;
new Function(...Object.keys(env),code)(...Object.values(env));effect();
return{list,opens,get loading(){return loading;}};
import { createAnalysisSessionClient } from '../src/agent/sessionClient.ts';
const tick = () => new Promise(resolve => setImmediate(resolve));
const deferred = () => {
let resolve, reject;
const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
return { promise, resolve, reject };
};
function fixture(t, overrides = {}) {
const calls = { lists: 0, followed: [], details: [], options: 0, submissions: 0 };
const transport = {
analysisSessions: async () => { calls.lists++; return { items: [] }; },
analysisTurn: async id => {
calls.details.push(id);
return { id, sessionId: 'linked-session', status: 'COMPLETED' };
},
analysisSessionFollow: async (id, { onEvent }) => {
calls.followed.push(id);
onEvent({ event: 'snapshot', data: {
id, title: '授权会话', turns: [{ id: 'requested-turn', status: 'COMPLETED', result: { answer: '已保存答复' } }],
} });
},
options: async () => { calls.options++; return {}; },
createAnalysisSession: async () => { calls.submissions++; throw new Error('Unexpected submission'); },
startAnalysisTurn: async () => { calls.submissions++; throw new Error('Unexpected submission'); },
...overrides,
};
const client = createAnalysisSessionClient({ userId: 'loading-fixture', transport });
t.after(client.dispose);
return { client, calls };
}
test('an explicit history link loads its body without waiting for the unrelated session list',async()=>{
const ui=restoreFixture({sessionId:'requested-session'});await tick();assert.deepEqual(ui.opens,[['requested-session',undefined]]);
ui.list.resolve({items:[]});await tick();
});
test('a turn link can resolve its session while the session list is still pending',async()=>{
const ui=restoreFixture({turnId:'requested-turn'});await tick();assert.deepEqual(ui.opens,[['linked-session','requested-turn']]);
ui.list.resolve({items:[]});await tick();
});
test('default history selection still waits for the list before choosing a session',async()=>{
const ui=restoreFixture();await tick();assert.equal(ui.opens.length,0);ui.list.resolve({items:[{id:'recent'}]});await tick();assert.deepEqual(ui.opens,[['recent',undefined]]);
test('an explicit session opens its saved answer while the session list is still pending', async t => {
const list = deferred();
const { client, calls } = fixture(t, { analysisSessions: () => list.promise });
assert.equal(await client.openInitial({ sessionId: 'requested-session' }), true);
assert.deepEqual(calls.followed, ['requested-session']);
assert.equal(client.getSnapshot().turns[0].answer, '已保存答复');
assert.equal(client.getSnapshot().historyLoading, false);
assert.equal(client.getSnapshot().sessionsLoading, true);
list.reject(new Error('list unavailable'));
await tick();
assert.equal(client.getSnapshot().sessionsError, 'list unavailable');
assert.equal(client.getSnapshot().historyError, '');
assert.equal(client.getSnapshot().turns[0].answer, '已保存答复');
});
function listFixture(){
const read=deferred();let reads=0,state={busy:false,loaded:false,items:[],error:''};
const env={mounted:{current:true},active:true,sessionReadRequest:{current:null},setSessionsLoading:v=>{state.busy=v;},setSessions:v=>{state.items=v;},setSessionsLoaded:v=>{state.loaded=v;},setSessionsError:v=>{state.error=v;},onUnauthorized:()=>false,apiMessage:e=>e.message,collectionItems:v=>v.items||[],api:{analysisSessions:()=>{reads++;return read.promise;}}};
const start=source.indexOf(' const loadSessions = async');const end=source.indexOf('\n const retrySessions =',start);
const code=ts.transpileModule(source.slice(start,end)+'\nreturn loadSessions;',{compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText;
return{read,state,reads:()=>reads,load:new Function(...Object.keys(env),code)(...Object.values(env))};
}
test('session-list reads are shared, and failure stays within the list resource',async()=>{
const ui=listFixture();const a=ui.load(),b=ui.load();assert.equal(ui.reads(),1);assert.equal(ui.state.busy,true);
ui.read.resolve({items:[{id:'recent'}]});assert.deepEqual(await a,[{id:'recent'}]);await b;assert.equal(ui.state.loaded,true);assert.equal(ui.state.busy,false);
ui.read.resolve({items:[]});
});
test('a failed list read ends its own loading state and cannot masquerade as an empty successful list',async()=>{
const ui=listFixture();const work=ui.load();ui.read.resolve(Promise.reject(new Error('list unavailable')));assert.equal(await work,undefined);
assert.equal(ui.state.busy,false);assert.equal(ui.state.loaded,false);assert.equal(ui.state.error,'list unavailable');
});
test('ordinary and explicit historical conversations never download the unused options resource',()=>{
const start=source.indexOf(' useEffect(() => {\n if (!active || !initialLink.present');assert.notEqual(start,-1);
const end=source.indexOf('\n\n',start);const code=ts.transpileModule(source.slice(start,end),{compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText;
for(const [present,session,turn] of [[false,'',''],[false,'s',''],[true,'s',''],[true,'','t']]){
let reads=0;const env={useEffect:fn=>fn(),active:true,initialLink:{present},initialSessionId:session,initialTurnId:turn,optionsRequestStarted:{current:false},optionsRead:{run:()=>{reads++;}},onUnauthorized:()=>false};
new Function(...Object.keys(env),code)(...Object.values(env));assert.equal(reads,0);
}
test('a turn-only link resolves and focuses its session while the list is pending', async t => {
const list = deferred();
const { client, calls } = fixture(t, { analysisSessions: () => list.promise });
assert.equal(await client.openInitial({ turnId: 'requested-turn' }), true);
assert.deepEqual(calls.details, ['requested-turn']);
assert.deepEqual(calls.followed, ['linked-session']);
assert.equal(client.getSnapshot().focusTurnId, 'requested-turn');
assert.equal(client.getSnapshot().sessionsLoading, true);
list.resolve({ items: [] });
});
function retryFixture(sessionId='',turnId=''){
const list=deferred(),opens=[],navigationGeneration={current:0},state={historyLoading:false};
const env={sessionId,navigationGeneration,pendingTurnLink:{current:turnId},mounted:{current:true},initialLink:{present:false},user:{id:'u'},setHistoryLoading:v=>{state.historyLoading=v;},loadSessions:()=>list.promise,api:{analysisTurn:async()=>({sessionId:'target-session'})},openSession:async(id,focus)=>opens.push([id,focus]),defaultAnalysisSession:(_u,items)=>items[0]?.id,onUnauthorized:()=>false,setError(){},apiMessage:e=>e.message};
const start=source.indexOf(' const retrySessions = async');const end=source.indexOf('\n useEffect(',start);
const code=ts.transpileModule(source.slice(start,end)+'\nreturn retrySessions;',{compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText;
return{list,opens,state,navigationGeneration,retry:new Function(...Object.keys(env),code)(...Object.values(env))};
}
test('retrying a linked history does not wait for a slow list',async()=>{
const ui=retryFixture('selected');await ui.retry();assert.deepEqual(ui.opens,[['selected',undefined]]);ui.list.resolve([]);
test('default restoration waits for the recent session list', async t => {
const list = deferred();
const { client, calls } = fixture(t, { analysisSessions: () => list.promise });
const opening = client.openInitial();
await tick();
assert.deepEqual(calls.followed, []);
assert.equal(client.getSnapshot().historyLoading, true);
list.resolve({ items: [{ id: 'recent' }] });
assert.equal(await opening, true);
assert.deepEqual(calls.followed, ['recent']);
assert.equal(client.getSnapshot().historyLoading, false);
});
test('default-list retry cannot navigate over a newer user selection',async()=>{
const ui=retryFixture();const work=ui.retry();ui.navigationGeneration.current++;ui.list.resolve([{id:'old-default'}]);await work;assert.deepEqual(ui.opens,[]);
test('concurrent sidebar refreshes share a single list request', async t => {
const list = deferred();
let reads = 0;
const { client } = fixture(t, { analysisSessions: () => { reads++; return list.promise; } });
const first = client.refreshSessions();
const second = client.refreshSessions();
assert.equal(first, second);
await tick();
assert.equal(reads, 1);
assert.equal(client.getSnapshot().sessionsLoading, true);
list.resolve({ items: [{ id: 'recent' }] });
assert.deepEqual(await first, [{ id: 'recent' }]);
assert.deepEqual(client.getSnapshot().sessions, [{ id: 'recent' }]);
assert.equal(client.getSnapshot().sessionsLoading, false);
assert.equal(client.getSnapshot().sessionsError, '');
});
test('retry of a turn-only link re-resolves the requested turn instead of opening an unrelated default',async()=>{
const ui=retryFixture('','requested-turn');ui.list.resolve([{id:'unrelated-default'}]);await ui.retry();assert.deepEqual(ui.opens,[['target-session','requested-turn']]);
test('a failed list request exposes its own error and permits retry', async t => {
let reads = 0;
const { client } = fixture(t, { analysisSessions: async () => {
if (++reads === 1) throw new Error('list unavailable');
return { items: [{ id: 'restored' }] };
} });
await client.refreshSessions();
assert.equal(client.getSnapshot().sessionsLoading, false);
assert.equal(client.getSnapshot().sessionsError, 'list unavailable');
assert.equal(client.getSnapshot().historyError, '');
await client.refreshSessions();
assert.equal(client.getSnapshot().sessionsError, '');
assert.deepEqual(client.getSnapshot().sessions, [{ id: 'restored' }]);
});
test('default-history retry locks sending until its target resolves, so a late list cannot replace a new submission',async()=>{
const ui=retryFixture();const work=ui.retry();assert.equal(ui.state.historyLoading,true);
assert.equal(analysisComposerState(false,false,ui.state.historyLoading,'新问题').sendDisabled,true);
ui.list.resolve([{id:'default'}]);await work;assert.equal(ui.state.historyLoading,false);
test('ordinary and linked history restoration do not request analysis options', async t => {
for (const initial of [{}, { sessionId: 'selected' }, { turnId: 'requested-turn' }, { selectRecent: false }]) {
const { client, calls } = fixture(t);
assert.equal(await client.openInitial(initial), true);
assert.equal(calls.lists, 1);
assert.equal(calls.options, 0);
}
const workspace = fs.readFileSync(new URL('../src/agent/AgentWorkspace.tsx', import.meta.url), 'utf8');
assert.doesNotMatch(workspace, /\b(?:optionsRead|analysisOptions)\b|\bapi\.options\s*\(/);
});
test('retrying an explicitly selected history opens its snapshot while the list is slow', async t => {
const list = deferred();
const reads = [];
const { client } = fixture(t, {
analysisSessions: () => list.promise,
analysisSessionFollow: async (id, { onEvent }) => {
reads.push(id);
if (reads.length === 1) throw new Error('history unavailable');
onEvent({ event: 'snapshot', data: { id, turns: [] } });
},
});
assert.equal(await client.openInitial({ sessionId: 'selected' }), false);
const failed = client.getSnapshot();
assert.equal(failed.historyError, 'history unavailable');
assert.equal(await client.openSession(failed.sessionId, failed.focusTurnId), true);
assert.deepEqual(reads, ['selected', 'selected']);
assert.equal(client.getSnapshot().sessionsLoading, true);
list.resolve({ items: [] });
});
test('a late default-list retry cannot navigate over a newer user selection', async t => {
const retry = deferred();
let reads = 0;
const { client, calls } = fixture(t, { analysisSessions: async () => {
if (++reads === 1) throw new Error('list unavailable');
return retry.promise;
} });
assert.equal(await client.openInitial(), false);
const retrying = client.openInitial();
assert.equal(await client.openSession('selected'), true);
retry.resolve({ items: [{ id: 'old-default' }] });
assert.equal(await retrying, false);
assert.deepEqual(calls.followed, ['selected']);
assert.equal(client.getSnapshot().sessionId, 'selected');
});
test('retrying an unresolved turn link resolves the same turn before choosing any default', async t => {
const reads = [];
const { client, calls } = fixture(t, {
analysisSessions: async () => ({ items: [{ id: 'unrelated-default' }] }),
analysisTurn: async id => {
reads.push(id);
if (reads.length === 1) throw new Error('turn unavailable');
return { id, sessionId: 'linked-session', status: 'COMPLETED' };
},
});
const initial = { turnId: 'requested-turn' };
assert.equal(await client.openInitial(initial), false);
assert.equal(await client.openInitial(initial), true);
assert.deepEqual(reads, ['requested-turn', 'requested-turn']);
assert.deepEqual(calls.followed, ['linked-session']);
assert.equal(client.getSnapshot().focusTurnId, 'requested-turn');
});
test('retrying default restoration keeps submission locked until its target resolves', async t => {
const retry = deferred();
let reads = 0;
const { client, calls } = fixture(t, { analysisSessions: async () => {
if (++reads === 1) throw new Error('list unavailable');
return retry.promise;
} });
assert.equal(await client.openInitial(), false);
const retrying = client.openInitial();
assert.equal(client.getSnapshot().historyLoading, true);
assert.equal(await client.submit('新问题'), false);
assert.equal(calls.submissions, 0);
retry.resolve({ items: [{ id: 'default' }] });
assert.equal(await retrying, true);
assert.equal(client.getSnapshot().historyLoading, false);
});
+30 -15
View File
@@ -5,6 +5,7 @@ import ts from 'typescript';
import React from 'react';
import { renderToStaticMarkup } from 'react-dom/server';
import { emptyAnalysisNotice } from '../src/analysisConversationState.ts';
import { sanitizeAnalysisDisplayText } from '../src/analysisDisplayText.ts';
import {
analysisMemberListFullyRead,
analysisMemberListPage,
@@ -110,21 +111,35 @@ test('the chat table renders raw member values as escaped text, not HTML or link
assert.doesNotMatch(html, /<img|<a\b/);
});
test('member-list display is opt-in, keeping earlier Markdown answers on their existing path', () => {
const source = fs.readFileSync(new URL('../src/ManagementPages.tsx', import.meta.url), 'utf8');
const turn = source.slice(source.indexOf('function AnalysisTurn('), source.indexOf('function AnalysisTurnMetadata('))
.replace('function AnalysisTurn(', 'function AnalysisTurn(');
const component = new Function('React', 'useAnalysisVisualRecovery', 'partialAnswerIsOnlyProgress', 'analysisScopeText', 'isObjectRecord', 'AnalysisProcess', 'AnalysisTurnMetadata', 'AiMarkdown', 'AnalysisNarrative', 'NativeAnalysisReport', 'AnalysisReportExport', 'Button', 'AnalysisMemberListPanel', 'emptyAnalysisNotice',
ts.transpileModule(`${turn}\nreturn AnalysisTurn;`, { fileName: 'analysis-turn.tsx', compilerOptions: { target: ts.ScriptTarget.ES2022, jsx: ts.JsxEmit.React } }).outputText
)(React, turn => ({turn,available:false,recovering:false,error:turn.recoveryError||''}), () => false, () => '', value => Boolean(value) && typeof value === 'object' && !Array.isArray(value), () => null, () => null, ({ content }) => React.createElement('p', null, content),
({ answer }) => React.createElement('div', { className: 'legacy-markdown' }, answer), () => null, () => null, ({ children }) => React.createElement('button', null, children), () => null, emptyAnalysisNotice);
const html = renderToStaticMarkup(React.createElement(component, { turn: { id: 'old-turn', status: 'COMPLETED', answer: '| old | Markdown table |' }, onUnauthorized: () => false }));
assert.match(html, /legacy-markdown/);
test('member-list display is opt-in and historical plain answers do not acquire report actions', () => {
const source = fs.readFileSync(new URL('../src/agent/AgentConversation.tsx', import.meta.url), 'utf8');
const start = source.indexOf('export const AgentConversationTurn');
const code = source.slice(start).replace('export const AgentConversationTurn', 'const AgentConversationTurn');
const view = {
React, memo: value => value, useMemo: callback => callback(), useState: value => [value, () => {}], useEffect: () => {},
useAnalysisVisualRecovery: turn => ({ turn, available: false, recovering: false, error: turn.recoveryError || '' }),
analysisSnapshotResult: turn => turn.result || turn, partialAnswerIsOnlyProgress: () => false, analysisIsRunning: () => false,
executionEvents: () => [], RunStatus: () => null, authoredReport: () => null, analysisScopeText: () => '', emptyAnalysisNotice,
string: value => typeof value === 'string' ? value : '', record: value => value || {}, sanitizeAnalysisDisplayText,
AiMarkdown: ({ content }) => React.createElement('div', { className: 'model-original' }, content),
AnalysisMemberListPanel: () => React.createElement('div', { className: 'analysis-member-list' }),
Button: ({ children }) => React.createElement('button', null, children),
};
const component = new Function(...Object.keys(view), ts.transpileModule(`${code}
return AgentConversationTurn;`, {
fileName: 'agent-turn.tsx', compilerOptions: { target: ts.ScriptTarget.ES2022, jsx: ts.JsxEmit.React }
}).outputText)(...Object.values(view));
const render = turn => renderToStaticMarkup(React.createElement(component, { turn, canAct: true, latest: true }));
const html = render({ id: 'old-turn', status: 'COMPLETED', answer: '| old | Markdown table |' });
assert.match(html, /model-original/);
assert.match(html, /\| old \| Markdown table \|/);
assert.doesNotMatch(html, /analysis-member-list/);
const empty = renderToStaticMarkup(React.createElement(component, { turn: { id: 'empty-turn', status: 'PARTIAL', answer: '', answerQuality: { dataComplete: true, narrativeComplete: false } }, onUnauthorized: () => false, onRetry: () => {} }));
assert.match(empty, /role="status">数据查询已完成,但未生成分析正文。请重新分析。/);
assert.doesNotMatch(html, /analysis-member-list|生成报告|查看报告/);
assert.match(render({ id: 'members', status: 'COMPLETED', result: { memberList: fixture() } }), /analysis-member-list/);
const empty = render({ id: 'empty-turn', status: 'PARTIAL', answer: '', answerQuality: { dataComplete: true, narrativeComplete: false } });
assert.doesNotMatch(empty, /数据查询已完成|核心结论/);
assert.match(empty, /<button>重新分析<\/button>/);
const failedRecovery=renderToStaticMarkup(React.createElement(component,{turn:{id:'old-turn',status:'PARTIAL',answer:'原答案',recoveryError:'图表恢复暂不可用'},onUnauthorized:()=>false}));
assert.match(failedRecovery,/role="alert">图表恢复暂不可用/);assert.match(failedRecovery,/原答案/);
assert.match(render({id:'failed-turn',status:'FAILED',answer:'',completion:{reason:'任务理解未完成,请重试'}}), /任务理解未完成,请重试/);
const recovery = render({ id: 'old-turn', status: 'PARTIAL', answer: '原答案', recoveryError: '图表恢复暂不可用' });
assert.match(recovery, /role="alert">图表恢复暂不可用/);
assert.match(recovery, /原答案/);
});
@@ -5,29 +5,22 @@ import fs from 'node:fs';
import ts from 'typescript';
import React from 'react';
import { renderToStaticMarkup } from 'react-dom/server';
import { parseServerReadingSummary } from '../src/analysisReadingModel.ts';
import {
analysisMemberListFullyRead,
analysisMemberListPeriod,
parseAnalysisMemberList,
} from '../src/analysisMembersModel.ts';
const exportSource = fs.readFileSync(new URL('../src/AnalysisReportExport.tsx', import.meta.url), 'utf8');
const reportDocumentSource = exportSource.slice(exportSource.indexOf('function ReportDocument('), exportSource.indexOf('\nfunction reportHtmlFromElement('));
const node = (tag, props) => React.createElement(tag, props, props?.children);
const ReportDocument = new Function('tableTextAlignment', 'React', 'reportCss', 'record', 'text', 'buildAnalysisNarrative', 'analysisScopeText',
'parseServerReadingSummary', 'resolveAnalysisReportTitle', 'sanitizeAnalysisDisplayText', 'stripDuplicateFirstMarkdownH1', 'AnalysisReportNarrative',
'AnalysisLegacyResults', 'AnalysisRecordListReport', 'analysisMemberListFullyRead', 'analysisMemberListPeriod', 'parseAnalysisMemberList',
ts.transpileModule(`${reportDocumentSource}\nreturn ReportDocument;`, {
fileName: 'analysis-report-document.tsx',
const source = fs.readFileSync(new URL('../src/AnalysisMemberListReport.tsx', import.meta.url), 'utf8');
const script = source.replace(/^import .+;\n/gm, '').replace('export function ', 'function ');
const ReportDocument = new Function('tableTextAlignment', 'React',
'analysisMemberListFullyRead', 'analysisMemberListPeriod', 'parseAnalysisMemberList',
ts.transpileModule(`${script}
return AnalysisMemberListReport;`, {
fileName: 'analysis-member-report.tsx',
compilerOptions: { target: ts.ScriptTarget.ES2022, jsx: ts.JsxEmit.React },
}).outputText
)(tableTextAlignment, React, '', value => value && typeof value === 'object' && !Array.isArray(value) ? value : {},
value => value === null || value === undefined || value === '' ? '—' : String(value),
() => ({ period: '2026年9月' }), () => '', parseServerReadingSummary, () => '分析报告', value => value, value => value,
({ answer }) => node('div', { className: 'report-summary', children: answer }), () => null, () => null,
analysisMemberListFullyRead, analysisMemberListPeriod, parseAnalysisMemberList);
)(tableTextAlignment, React, analysisMemberListFullyRead, analysisMemberListPeriod, parseAnalysisMemberList);
function memberListFixture() {
return {
schemaVersion: 1,
@@ -46,8 +39,7 @@ function memberListFixture() {
test('the report includes every member row beyond the former 150-row limit as a static escaped table', () => {
const html = renderToStaticMarkup(React.createElement(ReportDocument, {
turn: { id: 'turn-1', status: 'COMPLETED', result: { answer: '摘要内容', memberList: memberListFixture() } },
stamp: '2026-10-27 12:00:00', visualImages: [],
value: memberListFixture(),
}));
assert.match(html, /<h2>成员清单<\/h2>/);
@@ -71,8 +63,7 @@ test('the report accepts a root memberList and labels incomplete coverage', () =
source.rowsReturned = 160;
source.queryComplete = false;
const html = renderToStaticMarkup(React.createElement(ReportDocument, {
turn: { id: 'turn-2', status: 'PARTIAL', answer: '摘要', memberList: source },
stamp: '2026-10-27 12:00:00', visualImages: [],
value: source,
}));
assert.equal((html.match(/<tr/g) || []).length, 161);
assert.match(html, /读取未完成 160 \/ 181 条/);
@@ -37,6 +37,15 @@ test('figures are inserted after the associated complete chapter without removin
test('alternate historical evidence fallback also recovers native prose',()=>{
const data=legacy();data.result.readingSummary.lead='现有证据不足以支持本轮完整分析,已保留可核验统计结果。';assert.equal(originalAnalysisBody(data).answer,original);
});
test('DSH never restores an unverified investigation draft over a checked partial result',()=>{
const data=legacy();data.result.engine='DSH';
data.result.answer='已取得本轮统计结果,答案整理尚未完整完成。';
data.plan.timeline.at(-1).text='TOP5全部属于缺角。';
const body=originalAnalysisBody(data);
assert.equal(body.source,'saved');assert.equal(body.answer,data.result.answer);
assert.doesNotMatch(body.answer,/全部属于缺角/);
data.result.answer='';assert.deepEqual(originalAnalysisBody(data),{answer:'',source:'unavailable'});
});
test('black and bright figures cannot be attached to the opposite stage chapter',()=>{
const body='## 黑片阶段\n\n黑片完整解释。\n\n## 亮片阶段\n\n亮片完整解释。';
const figures=[{id:'black',type:'column',stage:'black',metric:'black_rate',evidenceRefs:[]},{id:'bright',type:'column',stage:'bright',metric:'bright_rate',evidenceRefs:[]}];
@@ -72,6 +72,20 @@ const ReadingSummary = component(readingSource, 'ReadingSummary', { AiMarkdown }
const hooks = { useMemo: fn => fn(), useState: initial => [initial, () => {}], useRef: initial => ({ current: initial }), useEffect: () => {} };
const conclusionSource = readFileSync(new URL('../src/AnalysisConclusion.tsx', import.meta.url), 'utf8');
const AnalysisConclusion = component(conclusionSource, 'AnalysisConclusion', { AiMarkdown, buildConclusionDocument });
test('explicit report chapters do not gain an extra generic conclusion heading', () => {
const reading = { ...summary(), evidence: [], notices: [], evidenceRefs: [],
lead: '已核实的范围如下。\n\n## 一、已确认事实\n\n合成产品06报废36.00 kg。\n\n## 二、数据局限\n\n现场原因尚未验证。\n\n## 三、下一步核查\n\n按原范围核对生产记录。' };
reading.fullAnswer = reading.lead;
const html = renderToStaticMarkup(React.createElement(AnalysisConclusion, {
reading, visuals: [], renderVisuals: () => null,
}));
const headings = [...html.matchAll(/<h3[^>]*>(.*?)<\/h3>/g)].map(match => match[1]);
assert.deepEqual(headings, ['一、已确认事实', '二、数据局限', '三、下一步核查']);
assert.match(html, /已核实的范围如下。/);
assert.match(html, /合成产品06报废36.00 kg。/);
});
const common = { ...hooks, AiMarkdown, AnalysisConclusion, ReadingSummary, buildAnalysisReadingModel, buildAnalysisNarrative, conclusionMarkdown,
AnalysisVisuals: ({ visuals = [] }) => React.createElement('div', null, visuals.map(visual => React.createElement('figure', { key: visual.id, 'data-chat-visual-id': visual.id }, React.createElement('h3', { className: 'analysis-visual-heading-copy' }, visual.title), React.createElement('p', null, visual.subtitle)))), NarrativeEvidence: () => null, FocusProductTable: () => null,
useCompactRateComparison: () => false, AnalysisProductDrilldown: () => null, resolveProductDrilldown: () => ({ reason: 'test' }) };
@@ -20,6 +20,14 @@ test('fallback title comes from the period and scope, never the user question',
assert.notEqual(title, question);
});
test('generic titles use the topic of a verified figure while specific generated titles retain priority', () => {
assert.equal(resolveAnalysisReportTitle('质量数据分析', '', '', '2026年10月', '', '产品规格报废总重排名'),
'2026年10月 产品规格报废总重排名');
assert.equal(resolveAnalysisReportTitle('质量数据分析', '产品报废核查', '', '2026年10月', '', '产品规格报废总重排名'),
'产品报废核查');
assert.equal(resolveAnalysisReportTitle('质量数据分析', '', '', '2026年10月', ''), '2026年10月质量分析报告');
});
test('a matching Markdown H1 is removed from the body without dropping detailed report content', () => {
const markdown = '# AI生成标题\n\n## 执行摘要\n综合合格率下降。\n\n## 重点产品\n完整投入、报废重量与率变化明细。';
const body = stripDuplicateFirstMarkdownH1(markdown, 'AI生成标题');
@@ -41,8 +49,8 @@ test('download names stay concise and use a single report suffix', () => {
});
test('the complete long report retains its dimensions beyond the old canvas auto-scale limit', () => {
assert.deepEqual(longReportImageSize(900, 11912), { width: 900, height: 11912, pixelRatio: 1.5 });
assert.equal(longReportImageSize(900, 11912).height * 1.5, 17868);
assert.deepEqual(longReportImageSize(900, 11912), { width: 900, height: 11912, pixelRatio: 2 });
assert.equal(longReportImageSize(900, 11912).height * 2, 23824);
});
test('very long reports fit one bounded canvas by scaling the entire image without dropping content', () => {
@@ -54,7 +62,7 @@ test('very long reports fit one bounded canvas by scaling the entire image witho
assert.ok(height * result.pixelRatio <= 30000);
assert.ok(width * height * result.pixelRatio ** 2 <= 48000001);
}
assert.deepEqual(longReportImageSize(900, 830.2), { width: 900, height: 831, pixelRatio: 1.5 });
assert.deepEqual(longReportImageSize(900, 830.2), { width: 900, height: 831, pixelRatio: 2 });
assert.throws(() => longReportImageSize(900, NaN), /尺寸无效/);
});
@@ -0,0 +1,109 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { createAnalysisSessionClient } from '../src/agent/sessionClient.ts';
const tick = () => new Promise(resolve => setImmediate(resolve));
const deferred = () => {
let resolve, reject;
const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
return { promise, resolve, reject };
};
function restoreFixture({ readList = async () => ({ items: [] }), readTurn } = {}) {
const opened = [];
const authorizationChecks = [];
const client = createAnalysisSessionClient({
userId: 'restore-fixture',
onUnauthorized: error => { authorizationChecks.push(error); return false; },
transport: {
analysisSessions: readList,
analysisTurn: readTurn,
analysisSessionFollow: async (id, { onEvent }) => {
opened.push(id);
onEvent({ event: 'snapshot', data: { id, turns: [{ id: 'requested-turn', status: 'COMPLETED' }] } });
},
},
});
return { client, opened, authorizationChecks };
}
test('replaying mount discards a stale turn lookup even before the replacement resolves', async t => {
const oldTurn = deferred();
const currentTurn = deferred();
let requests = 0;
const { client, opened, authorizationChecks } = restoreFixture({
readTurn: () => (++requests === 1 ? oldTurn.promise : currentTurn.promise),
});
t.after(client.dispose);
client.resume();
const first = client.openInitial({ turnId: 'requested-turn' });
client.suspend();
client.resume();
await tick();
assert.equal(requests, 2);
oldTurn.reject(Object.assign(new Error('old request unavailable'), { status: 503 }));
assert.equal(await first, false);
assert.equal(client.getSnapshot().historyLoading, true);
assert.equal(client.getSnapshot().historyError, '');
assert.deepEqual(authorizationChecks, []);
currentTurn.resolve({ sessionId: 'current-session' });
await tick();
assert.equal(client.getSnapshot().historyLoading, false);
assert.equal(client.getSnapshot().focusTurnId, 'requested-turn');
assert.deepEqual(opened, ['current-session']);
});
test('replaying mount shares a list read and finishes loading an empty history', async t => {
const list = deferred();
let requests = 0;
const { client, opened } = restoreFixture({ readList: () => { requests++; return list.promise; } });
t.after(client.dispose);
client.resume();
const first = client.openInitial();
client.suspend();
client.resume();
assert.equal(client.getSnapshot().historyLoading, true);
assert.equal(await client.submit('must wait for selection'), false);
list.resolve({ items: [] });
assert.equal(await first, false);
await tick();
assert.equal(requests, 1);
assert.equal(client.getSnapshot().historyLoading, false);
assert.equal(client.getSnapshot().historyError, '');
assert.deepEqual(opened, []);
});
test('a failed recent-session lookup can be retried without creating a conversation', async t => {
let requests = 0;
const { client, opened } = restoreFixture({
readList: async () => {
if (++requests === 1) throw new Error('session list unavailable');
return { items: [{ id: 'recent' }] };
},
});
t.after(client.dispose);
assert.equal(await client.openInitial(), false);
assert.equal(client.getSnapshot().historyLoading, false);
assert.equal(client.getSnapshot().historyError, 'session list unavailable');
assert.equal(await client.openInitial(), true);
assert.equal(client.getSnapshot().historyError, '');
assert.equal(client.getSnapshot().sessionId, 'recent');
assert.deepEqual(opened, ['recent']);
});
test('starting a new conversation invalidates a pending automatic selection', async t => {
const list = deferred();
const { client, opened } = restoreFixture({ readList: () => list.promise });
t.after(client.dispose);
const opening = client.openInitial();
client.newSession();
list.resolve({ items: [{ id: 'recent' }] });
assert.equal(await opening, false);
assert.equal(client.getSnapshot().historyLoading, false);
assert.equal(client.getSnapshot().sessionId, '');
assert.deepEqual(opened, []);
});
+24 -114
View File
@@ -6,6 +6,7 @@ import React from 'react';
import { renderToStaticMarkup } from 'react-dom/server';
import { analysisScopeText, analysisComposerState, restoredAnalysisDraft, analysisFollowRequestReady } from '../src/analysisScope.ts';
import { analysisIsRunning, analysisScrollFollows, compactAnalysisTimeline, duplicatesFinalAnalysisAnswer } from '../src/analysisConversationState.ts';
import { scrollTopFromVisualOffset, transcriptFollowState } from '../src/agent/transcriptScroll.ts';
import { sanitizeAnalysisDisplayText } from '../src/analysisDisplayText.ts';
import { modelThinkingEntries, thinkingStatus, orderedAnalysisProcess, groupAdjacentThinking } from '../src/analysisModelThinking.ts';
@@ -180,126 +181,35 @@ test('manual downward movement near the bottom resumes follow, while layout scro
assert.equal(analysisScrollFollows(0,true,'up'),false);
});
// Exercise the component's scrolling and update effect, including the browser's
// scroll-range clamp. Rectangles are zoomed, while scrollTop stays in layout units.
const pageSource=fs.readFileSync(new URL('../src/ManagementPages.tsx',import.meta.url),'utf8');
const scrollSource=pageSource.slice(pageSource.indexOf(' const scrollToLatest ='),pageSource.indexOf('\n useEffect(() => {\n if (!busy)'));
const updateStart=pageSource.indexOf(' useEffect(() => {\n if (analysisFollowRequestReady');
const updateSource=pageSource.slice(updateStart,pageSource.indexOf('\n\n const loadSessions',updateStart));
function scrollFixture({scale=.8,turnOffset=1200,maxScroll=2000,following=true}={}){
const body=`
let lastTurn=null,busy=true,active=true,turns=[],sessionId='session-a',hasNewContent=false;
const followOutput={current:following},explicitlyFollowing={current:false},followRequest={current:null},seenConclusion={current:null};
const previousScrollTop={current:0},readingPosition={current:0};
const ANALYSIS_FINAL_STATUSES=new Set(['COMPLETED','PARTIAL','FAILED','CANCELLED','NEEDS_CLARIFICATION']);
const setHasNewContent=value=>{hasNewContent=value;};
let position=0,updateEffect;
const latest={dataset:{},getBoundingClientRect:()=>({top:56.5+(turnOffset-position)*scale})};
const element={
offsetHeight:600,clientTop:0,scrollHeight:maxScroll+600,
get scrollTop(){return position;},set scrollTop(value){position=Math.max(0,Math.min(value,maxScroll));},
getBoundingClientRect:()=>({top:56.5,height:600*scale}),querySelector:()=>latest,
};
const conversation={current:element},useEffect=callback=>{updateEffect=callback;};
${scrollSource}
${updateSource}
return {
update(turn,running=true){lastTurn=turn;busy=running;latest.dataset={analysisStatus:turn.status,analysisTurnId:turn.id};updateEffect();},
scroll(top,intent='up'){
element.scrollTop=top;
const distance=maxScroll-position;
followOutput.current=analysisScrollFollows(distance,followOutput.current,intent);
if(intent==='up') explicitlyFollowing.current=false;
else if(intent==='down'&&followOutput.current) explicitlyFollowing.current=true;
if(followOutput.current) hasNewContent=false;
previousScrollTop.current=position;readingPosition.current=position;
},
programmaticScroll(top){
element.scrollTop=top;previousScrollTop.current=position;readingPosition.current=position;
followOutput.current=analysisScrollFollows(maxScroll-position,followOutput.current,null);
},
returnToLatest(){
followOutput.current=true;explicitlyFollowing.current=true;hasNewContent=false;
element.scrollTop=element.scrollHeight;previousScrollTop.current=position;readingPosition.current=position;
},
submit(key){followRequest.current=key;},
get:()=>({position,hasNewContent,following:followOutput.current,seen:seenConclusion.current}),
};
`;
return new Function('analysisFollowRequestReady','analysisScrollFollows','scale','turnOffset','maxScroll','following',
ts.transpileModule(body,{compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText
)(analysisFollowRequestReady,analysisScrollFollows,scale,turnOffset,maxScroll,following);
}
const viewport = (scrollTop, zoom = 1, scrollHeight = 2600) => ({
scrollTop, scrollHeight, clientHeight: 600, offsetHeight: 600,
getBoundingClientRect: () => ({ height: 600 * zoom }),
});
test('completion anchors the same layout position at workspace zoom levels',()=>{
for(const scale of [.8,1,1.25]){
const ui=scrollFixture({scale});
ui.update({id:'turn-a',status:'COMPLETED'});
assert.equal(ui.get().position,1200);
assert.equal(ui.get().seen,'turn-a');
test('focusing and prepending history convert visual positions to layout pixels at each zoom', () => {
for (const zoom of [.8, 1, 1.25]) {
assert.equal(scrollTopFromVisualOffset(viewport(500, zoom), 316 * zoom, 16), 800);
assert.equal(scrollTopFromVisualOffset(viewport(500, zoom), 240 * zoom), 740);
}
});
test('short conclusions safely clamp at the end of the conversation',()=>{
const ui=scrollFixture({maxScroll:1150});
ui.update({id:'turn-a',status:'COMPLETED'});
assert.equal(ui.get().position,1150);
assert.equal(ui.get().hasNewContent,false);
test('follow remains active through new output when the reader stayed at the bottom', () => {
assert.deepEqual(transcriptFollowState(viewport(2000, 1, 2600), true, null), { follows: true, showLatest: false });
assert.deepEqual(transcriptFollowState(viewport(2000, 1, 3200), true, null), { follows: true, showLatest: false });
});
test('terminal detail and history refreshes cannot resurrect the unread indicator',()=>{
const ui=scrollFixture();
ui.update({id:'turn-a',status:'RUNNING'});
ui.update({id:'turn-a',status:'COMPLETED'}); // Terminal SSE, busy remains true.
assert.equal(ui.get().following,false);
ui.update({id:'turn-a',status:'COMPLETED',answer:'saved answer'}); // Durable detail.
ui.update({id:'turn-a',status:'COMPLETED',answer:'saved answer'}); // History refresh.
ui.update({id:'turn-a',status:'COMPLETED',answer:'saved answer'},false);
assert.equal(ui.get().hasNewContent,false);
assert.equal(ui.get().position,1200);
test('scrolling up keeps the reader in history as live output arrives', () => {
assert.deepEqual(transcriptFollowState(viewport(1000), true, 'up'), { follows: false, showLatest: true });
assert.deepEqual(transcriptFollowState(viewport(1000, 1, 3200), false, null), { follows: false, showLatest: true });
});
test('completion still signals unread output when the reader stayed on an older turn',()=>{
const ui=scrollFixture({following:false});
ui.update({id:'turn-a',status:'RUNNING'});
ui.update({id:'turn-a',status:'COMPLETED'});
ui.update({id:'turn-a',status:'COMPLETED'},false);
assert.equal(ui.get().hasNewContent,true);
assert.equal(ui.get().position,0);
test('layout clamp cannot restore follow after the reader moved up', () => {
assert.deepEqual(transcriptFollowState(viewport(500, 1, 1100), false, null), { follows: false, showLatest: false });
});
test('scrolling up pauses, returning near the bottom resumes, and completed output stays followed after an explicit return',()=>{
const ui=scrollFixture();
ui.update({id:'turn-a',status:'RUNNING'});
ui.scroll(1500,'up');
ui.update({id:'turn-a',status:'RUNNING',answer:'streaming update'});
assert.equal(ui.get().position,1500);
assert.equal(ui.get().following,false);
ui.scroll(1990,'down');
assert.equal(ui.get().following,true);
assert.equal(ui.get().hasNewContent,false);
ui.update({id:'turn-a',status:'COMPLETED'});
assert.equal(ui.get().position,2000);
assert.equal(ui.get().following,true);
ui.returnToLatest();
ui.update({id:'turn-a',status:'COMPLETED',answer:'final durable answer'});
assert.equal(ui.get().following,true);
assert.equal(ui.get().position,2000);
});
test('layout-driven movement to the bottom does not rearm a reader who moved up',()=>{
const ui=scrollFixture({following:false});
ui.programmaticScroll(2000);
assert.equal(ui.get().position,2000);
assert.equal(ui.get().following,false);
});
test('a fresh request resets the seen conclusion and follows its own output',()=>{
const ui=scrollFixture();
ui.update({id:'old-turn',status:'COMPLETED'},false);
ui.submit('new-request');
ui.update({id:'new-turn',status:'RUNNING',_uiFollowKey:'new-request'});
assert.equal(ui.get().following,true);
assert.equal(ui.get().seen,null);
assert.equal(ui.get().position,2000);
ui.scroll(300);
ui.update({id:'new-turn',status:'COMPLETED'});
assert.equal(ui.get().hasNewContent,true);
assert.equal(ui.get().position,300);
test('returning downward near the end re-arms follow and clears the latest button', () => {
assert.deepEqual(transcriptFollowState(viewport(1960), false, 'down'), { follows: false, showLatest: true });
assert.deepEqual(transcriptFollowState(viewport(1980), false, 'down'), { follows: true, showLatest: false });
});
test('provider thinking is complete, escaped and separate from conclusions',()=>{
@@ -0,0 +1,339 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { createAnalysisSessionClient } from '../src/agent/sessionClient.ts';
function deferred() {
let resolve, reject;
const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
return { promise, resolve, reject };
}
async function until(condition, description) {
for (let i = 0; i < 100; i++) {
if (condition()) return;
await new Promise(resolve => setImmediate(resolve));
}
assert.fail(description || 'The expected session state was not reached');
}
const turn = (id, status = 'COMPLETED', extras = {}) => ({
id, status, question: 'Question ' + id, createdAt: '2026-11-11T04:05:06.001234Z', ...extras,
});
const snapshot = (id, turns, before = '', activeTurnId = '') => ({
id, title: id, turns, before, activeTurnId, context: { releaseId: 'release' },
});
function host(pages, overrides = {}) {
const connections = [];
const calls = { pages: [], cancels: [], starts: [], creates: [] };
const transport = {
analysisSessions: async () => ({ items: Object.keys(pages).map(id => ({ id, title: id })) }),
analysisSessionFollow: (id, { signal, onEvent }) => {
const stream = deferred();
const entry = { id, signal, emit: onEvent, close: stream.resolve, fail: stream.reject };
connections.push(entry);
signal.addEventListener('abort', () => stream.resolve(), { once: true });
if (pages[id]) onEvent({ event: 'snapshot', data: pages[id] });
return stream.promise;
},
analysisSessionPage: async (id, before) => {
calls.pages.push([id, before]);
return pages[id];
},
analysisTurn: async () => { throw new Error('Unexpected standalone turn request'); },
analysisTurnEvents: async () => { throw new Error('Unexpected fallback stream'); },
createAnalysisSession: async body => {
calls.creates.push(body);
return { session: { id: 'new', releaseId: 'release' } };
},
startAnalysisTurn: async (id, body) => {
calls.starts.push([id, body]);
return { turn: { id: 'new-turn', sessionId: id, status: 'QUEUED' } };
},
cancelAnalysisTurn: async id => {
calls.cancels.push(id);
return { turnId: id, status: 'CANCELLED', cancelRequested: true };
},
...overrides,
};
const client = createAnalysisSessionClient({ userId: 'actor', transport });
return { client, connections, calls };
}
test('the follow stream opens the tail in one snapshot and older pages cannot duplicate a focused turn', async t => {
const pages = { A: snapshot('A', [turn('5'), turn('6')], '5') };
let fullHistoryRequests = 0;
const detail = { ...turn('2'), sessionId: 'A', answer: 'historical' };
const { client } = host(pages, {
analysisTurn: async id => { assert.equal(id, '2'); return detail; },
analysisSessionPage: async (id, before) => {
fullHistoryRequests++;
assert.deepEqual([id, before], ['A', '5']);
return snapshot('A', [turn('1'), turn('2', 'COMPLETED', { result: { answer: 'refreshed history' } }), turn('3'), turn('4')]);
},
});
t.after(() => client.dispose());
assert.equal(await client.openSession('A', '2'), true);
const initial = client.getSnapshot();
assert.equal(client.getSnapshot(), initial);
assert.equal(fullHistoryRequests, 0);
assert.equal(initial.historyLoading, false);
assert.equal(initial.focusTurnId, '2');
assert.deepEqual(initial.turns.map(row => row.id), ['2', '5', '6']);
assert.equal(await client.loadOlder(), true);
const expanded = client.getSnapshot();
assert.equal(expanded.olderCursor, '');
assert.deepEqual(expanded.turns.map(row => row.id), ['1', '2', '3', '4', '5', '6']);
assert.equal(expanded.turns[1].answer, 'refreshed history');
});
test('draft replacements remain ephemeral and large durable cursors reject old events', async t => {
const pages = { A: snapshot('A', [turn('1', 'RUNNING', { eventCursor: '9007199254740994' })], '', '1') };
const { client, connections } = host(pages);
t.after(() => client.dispose());
await client.openSession('A');
const { emit } = connections[0];
emit({ event: 'draft', data: { turnId: '1', attemptId: 'p', text: 'unverified draft' } });
const draft = client.getSnapshot().turns[0];
assert.equal(draft.dshDraft, 'unverified draft');
assert.equal(draft.answer, undefined);
emit({ id: '9007199254740993', event: 'progress', data: { turnId: '1', message: 'stale event' } });
assert.equal(client.getSnapshot().turns[0], draft);
emit({ id: '9007199254740995', event: 'tool_result', data: { turnId: '1', status: 'COMPLETED', steps: [{ name: 'metric' }] } });
assert.equal(client.getSnapshot().busy, true);
assert.equal(client.getSnapshot().turns[0].eventCursor, '9007199254740995');
assert.equal(client.getSnapshot().turns[0].dshDraft, 'unverified draft');
emit({ id: '9007199254740996', event: 'completed', data: { turnId: '1', result: { answer: 'checked answer' } } });
emit({ event: 'draft', data: { turnId: '1', attemptId: 'p', text: 'late draft' } });
const result = client.getSnapshot().turns[0];
assert.equal(result.dshDraft, undefined);
assert.equal(result.result.answer, 'checked answer');
assert.equal(result.status, 'COMPLETED');
assert.equal(client.getSnapshot().busy, false);
});
test('switching and suspending abort reads without stopping a turn or accepting stale data', async t => {
const older = deferred();
const pages = { A: snapshot('A', [turn('4', 'RUNNING')], '4', '4'), B: snapshot('B', [turn('10')]) };
const { client, connections, calls } = host(pages, { analysisSessionPage: async () => older.promise });
t.after(() => client.dispose());
await client.openSession('A');
const loading = client.loadOlder();
await client.openSession('B');
const replacement = client.getSnapshot();
assert.equal(connections[0].signal.aborted, true);
older.resolve(snapshot('A', [turn('1'), turn('2'), turn('3')]));
assert.equal(await loading, false);
connections[0].emit({ event: 'draft', data: { turnId: '4', attemptId: 'a', text: 'unselected draft' } });
assert.equal(client.getSnapshot(), replacement);
client.suspend();
assert.equal(connections[1].signal.aborted, true);
assert.deepEqual(calls.cancels, []);
client.resume();
await until(() => connections.length === 3);
assert.equal(connections[2].id, 'B');
});
test('an uncertain submission reuses its receipt even after the server assigns the release', async t => {
const bodies = [];
const pages = { new: snapshot('new', []) };
const { client, calls } = host(pages, {
startAnalysisTurn: async (id, body) => {
assert.equal(id, 'new');
bodies.push(body);
if (bodies.length === 1) throw new Error('Connection ended before receipt');
pages.new = snapshot('new', [turn('new-turn', 'QUEUED')], '', 'new-turn');
return { turn: { id: 'new-turn', sessionId: id, status: 'QUEUED' } };
},
});
t.after(() => client.dispose());
assert.equal(await client.submit('同一个问题'), false);
assert.equal(client.getSnapshot().retryQuestion, '同一个问题');
assert.equal(client.getSnapshot().releaseId, 'release');
assert.equal(await client.submit('同一个问题', { releaseId: client.getSnapshot().releaseId }), true);
assert.deepEqual(bodies[0], bodies[1]);
assert.equal(calls.creates.length, 1);
});
test('a pending stop follows the accepted receipt across navigation and does not cancel the new session', async t => {
const receipt = deferred();
let posting = false;
const pages = { A: snapshot('A', []), B: snapshot('B', [turn('b', 'RUNNING')], '', 'b') };
const { client, calls } = host(pages, {
startAnalysisTurn: () => { posting = true; return receipt.promise; },
});
t.after(() => client.dispose());
await client.openSession('A');
const sending = client.submit('first');
await until(() => posting);
assert.equal(await client.cancel(), true);
await client.openSession('B');
receipt.resolve({ turn: { id: 'a', sessionId: 'A', status: 'RUNNING' } });
assert.equal(await sending, true);
assert.deepEqual(calls.cancels, ['a']);
assert.equal(client.getSnapshot().activeTurnId, 'b');
assert.equal(client.getSnapshot().sessionId, 'B');
});
test('the queued prompt waits for the durable completion and is submitted once with the new baseline context', async t => {
const pages = { A: snapshot('A', [turn('1', 'RUNNING', { eventCursor: '10' })], '', '1') };
const { client, connections, calls } = host(pages);
t.after(() => client.dispose());
await client.openSession('A');
assert.equal(await client.submit('next'), true);
assert.equal(client.getSnapshot().queuedQuestion, 'next');
assert.equal(calls.starts.length, 0);
const first = connections[0];
pages.A = { ...snapshot('A', [turn('1', 'COMPLETED')]), context: { releaseId: 'release', stage: 'black' } };
first.emit({ id: '11', event: 'completed', data: { turnId: '1', result: { answer: 'checked' } } });
first.close();
await until(() => connections.length >= 2);
connections[1].close();
await until(() => calls.starts.length === 1);
assert.equal(calls.starts[0][1].question, 'next');
assert.equal(calls.starts[0][1].context.stage, 'black');
assert.equal(client.getSnapshot().queuedQuestion, '');
});
test('restarting a saved turn drops the previous stream before reusing the same turn ID', async t => {
const receipt = deferred();
const pages = { A: snapshot('A', [turn('1', 'FAILED')]) };
const { client, connections } = host(pages, { retryAnalysisTurn: () => receipt.promise });
t.after(() => client.dispose());
await client.openSession('A');
const pending = client.retry('1');
assert.equal(connections[0].signal.aborted, true);
connections[0].emit({ id: '100', event: 'completed', data: { turnId: '1', result: { answer: 'old attempt' } } });
assert.equal(client.getSnapshot().turns[0].status, 'SUBMITTING');
pages.A = snapshot('A', [turn('1', 'QUEUED', { eventCursor: '110' })], '', '1');
receipt.resolve({ turn: { id: '1', sessionId: 'A', status: 'QUEUED' } });
assert.equal(await pending, true);
await until(() => connections.length === 2);
assert.equal(client.getSnapshot().turns[0].answer, undefined);
assert.equal(client.getSnapshot().turns[0].status, 'QUEUED');
});
test('the full original model answer survives summaries, draft clearing, and replacement snapshots', async t => {
const original = ' # 模型原文\n\n' + '完整分析内容。'.repeat(900) + '\n';
const pages = { A: snapshot('A', [turn('1', 'RUNNING', { eventCursor: '1' })], '', '1') };
const { client, connections } = host(pages);
t.after(() => client.dispose());
await client.openSession('A');
const { emit } = connections[0];
emit({ id: '2', event: 'progress', data: { turnId: '1', modelAnswer: original } });
emit({ event: 'draft', data: { turnId: '1', attemptId: 'attempt', text: 'temporary draft' } });
emit({ event: 'draft', data: { turnId: '1', attemptId: 'attempt', text: '' } });
assert.equal(client.getSnapshot().turns[0].modelAnswer, original);
assert.equal(client.getSnapshot().turns[0].dshDraft, undefined);
emit({ id: '3', event: 'completed', data: { turnId: '1', result: { answer: 'fixed summary' } } });
assert.equal(client.getSnapshot().turns[0].modelAnswer, original);
emit({ event: 'snapshot', data: snapshot('A', [turn('1', 'COMPLETED', { answer: 'another summary', eventCursor: '3' })]) });
const persisted = client.getSnapshot().turns[0];
assert.equal(persisted.modelAnswer, original);
assert.equal(persisted.status, 'COMPLETED');
});
test('cancelled and failed tasks retain the latest prose and accept a later full original', async t => {
for (const status of ['CANCELLED', 'FAILED', 'PARTIAL']) {
const pages = { A: snapshot('A', [turn('1', 'RUNNING', { eventCursor: '1' })], '', '1') };
const { client, connections } = host(pages);
t.after(() => client.dispose());
await client.openSession('A');
const { emit } = connections[0];
emit({ event: 'draft', data: { turnId: '1', attemptId: 'attempt', text: '模型已输出的原文' } });
emit({ id: '2', event: status.toLowerCase(), data: { turnId: '1', status, result: { answer: 'lifecycle message' } } });
let row = client.getSnapshot().turns[0];
assert.equal(row.modelAnswer, '模型已输出的原文');
assert.equal(row.dshDraft, undefined);
assert.equal(row.status, status);
emit({ id: '3', event: status.toLowerCase(), data: {
turnId: '1', status, result: { modelAnswer: '模型已输出的完整原文\n包含末尾文本', answer: 'summary' },
} });
row = client.getSnapshot().turns[0];
assert.equal(row.modelAnswer, '模型已输出的完整原文\n包含末尾文本');
assert.equal(row.eventCursor, '3');
assert.equal(row.status, status);
}
});
test('history and older-page refresh preserve explicit raw originals independently of summary answers', async t => {
const pages = { A: snapshot('A', [
turn('1', 'COMPLETED', { result: { modelAnswer: ' 已保存原文\n', answer: 'summary' } }),
turn('2'),
], '2') };
const { client } = host(pages, {
analysisSessionPage: async () => snapshot('A', [turn('1', 'COMPLETED', { result: { answer: 'updated summary', modelAnswer: '' } })]),
});
t.after(() => client.dispose());
await client.openSession('A');
assert.equal(client.getSnapshot().turns[0].modelAnswer, ' 已保存原文\n');
await client.loadOlder();
assert.equal(client.getSnapshot().turns[0].modelAnswer, ' 已保存原文\n');
});
test('retry clears the previous attempt original before the new attempt starts', async t => {
const receipt = deferred();
const pages = { A: snapshot('A', [turn('1', 'FAILED', { modelAnswer: 'previous attempt', dshDraft: 'old intermediate' })]) };
const { client } = host(pages, { retryAnalysisTurn: () => receipt.promise });
t.after(() => client.dispose());
await client.openSession('A');
const pending = client.retry('1');
assert.equal(client.getSnapshot().turns[0].modelAnswer, undefined);
assert.equal(client.getSnapshot().turns[0].dshDraft, undefined);
pages.A = snapshot('A', [turn('1', 'QUEUED')], '', '1');
receipt.resolve({ turn: { id: '1', sessionId: 'A', status: 'QUEUED' } });
await pending;
assert.equal(client.getSnapshot().turns[0].modelAnswer, undefined);
});
test('cancel refreshes the bounded final original tail after the terminal follow closes', async t => {
const original = 'original before cancellation';
const pages = { A: snapshot('A', [turn('1', 'RUNNING', { modelAnswer: original, attemptId: 'attempt' })], '', '1') };
let reads = 0;
const { client } = host(pages, {
cancelAnalysisTurn: async () => {
pages.A = snapshot('A', [turn('1', 'CANCELLED', { modelAnswer: original, attemptId: 'attempt' })]);
return { status: 'CANCELLED' };
},
analysisTurn: async () => {
reads++;
return { ...turn('1', 'CANCELLED', { attemptId: 'attempt', modelAnswer: reads === 1 ? original : original + '\nfinal 250ms tail' }), sessionId: 'A' };
},
});
t.after(() => client.dispose());
await client.openSession('A');
await client.cancel();
await new Promise(resolve => setTimeout(resolve, 1100));
assert.equal(reads, 2);
assert.equal(client.getSnapshot().turns[0].modelAnswer, original + '\nfinal 250ms tail');
});
test('a cancel-tail detail already in flight cannot overwrite a retried attempt', async t => {
const detail = deferred();
const pages = { A: snapshot('A', [turn('1', 'RUNNING', { attemptId: 'old' })], '', '1') };
let reads = 0;
const { client } = host(pages, {
cancelAnalysisTurn: async () => {
pages.A = snapshot('A', [turn('1', 'CANCELLED', { attemptId: 'old' })]);
return { status: 'CANCELLED' };
},
analysisTurn: () => { reads++; return detail.promise; },
retryAnalysisTurn: async () => {
const next = turn('1', 'QUEUED', { attemptId: 'new' });
pages.A = snapshot('A', [next], '', '1');
return { turn: next };
},
});
t.after(() => client.dispose());
await client.openSession('A');
await client.cancel();
await new Promise(resolve => setTimeout(resolve, 400));
assert.equal(reads, 1);
await client.retry('1');
detail.resolve({ ...turn('1', 'CANCELLED', { attemptId: 'old', modelAnswer: 'stale old tail' }), sessionId: 'A' });
await new Promise(resolve => setImmediate(resolve));
assert.equal(client.getSnapshot().turns[0].modelAnswer, undefined);
assert.equal(client.getSnapshot().turns[0].status, 'QUEUED');
});
+278 -171
View File
@@ -1,214 +1,321 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import ts from 'typescript';
import React from 'react';
import { renderToStaticMarkup } from 'react-dom/server';
import * as helpers from '../src/analysisSubmission.ts';
import { restoredAnalysisDraft } from '../src/analysisScope.ts';
import { beginAnalysisSubmission, submissionOutcomeUnknown } from '../src/analysisSubmission.ts';
import { createAnalysisSessionClient } from '../src/agent/sessionClient.ts';
const deferred = () => { let resolve, reject; const promise = new Promise((r,j) => { resolve = r; reject = j; }); return { promise, resolve, reject }; };
const tick = () => new Promise(resolve => setImmediate(resolve));
const source = fs.readFileSync(new URL('../src/ManagementPages.tsx', import.meta.url), 'utf8');
const page = source.slice(source.indexOf('function AnalysisPage('));
const closures = page.slice(page.indexOf(' const cancelAcceptedTurn = async'), page.indexOf('\n useEffect(() => { void sendQueuedFollowup(); }'));
const turnComponent = source.slice(source.indexOf('function AnalysisTurn('), source.indexOf('function AnalysisTurnMetadata('));
const renderDraft = turn => {
const component = new Function('React', 'useAnalysisVisualRecovery', ts.transpileModule(`${turnComponent}\nreturn AnalysisTurn;`, {
fileName: 'submission-render.tsx', compilerOptions: {target:ts.ScriptTarget.ES2022,jsx:ts.JsxEmit.React},
}).outputText)(React, turn => ({turn,available:false,recovering:false,error:''}));
return renderToStaticMarkup(React.createElement(component, { turn }));
const deferred = () => {
let resolve, reject;
const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
return { promise, resolve, reject };
};
const saved = (id, status, extras = {}) => ({ id, question: 'saved question', status, ...extras });
const page = (id, turns = [], extra = {}) => ({ id, turns, ...extra });
// Run the component's current submission/cancellation closures with API doubles.
// This catches wiring errors that helper-only assertions would miss, without DOM or network.
function fixture(api, hooks = {}, initialSession = 'session-1') {
const body = `
const {beginAnalysisSubmission,requestSubmissionCancellation,submissionOutcomeUnknown}=helpers;
let query='',sessionId=${JSON.stringify(initialSession)},sessionContext=null,releaseId=undefined,sourceResultRef=undefined;
let sessionReadOnly=false,stopping=false,busy=false,historyLoading=false,lastTurn=null,turns=[],activeTurnId='',retryQuestion='',error='',progress='',queuedFollowup='';
const mounted={current:true},navigationGeneration={current:0},subscriptionGeneration={current:0},streamController={current:null},submissionAttempt={current:null},followOutput={current:true},explicitlyFollowing={current:false},followRequest={current:null},cancellationRequest={current:null};
const user={id:'fixture-user'},ANALYSIS_FINAL_STATUSES=new Set(['COMPLETED','PARTIAL','FAILED','CANCELLED','NEEDS_CLARIFICATION']);
const beginAnalysisSelection=()=>1,rememberAnalysisSession=()=>{},rememberPendingAnalysisSession=()=>{},writeAnalysisLocation=()=>{};
const onUnauthorized=()=>false,apiMessage=e=>e.message,message={error(){},info(){}};
const setStopping=v=>{stopping=v;},setBusy=v=>{busy=v;if(!v){stopping=false;cancellationRequest.current=null;}},setError=v=>{error=v;},setRetryQuestion=v=>{retryQuestion=v;},setQuery=v=>{query=v;},setSessionId=v=>{sessionId=v;};
const setLastTurn=v=>{lastTurn=typeof v==='function'?v(lastTurn):v;},setTurns=v=>{turns=typeof v==='function'?v(turns):v;};
const setActiveTurnId=v=>{activeTurnId=v;},setStreamProgress=v=>{progress=v;},setQueuedFollowup=v=>{queuedFollowup=v;};
const loadSessions=async()=>{if(hooks.loadSessions)await hooks.loadSessions();};
const followTurn=async id=>{activeTurnId=id;busy=true;if(hooks.followTurn)await hooks.followTurn(id);};
${closures}
return {submit,cancelTurn,retryTurn,queueFollowup,sendQueuedFollowup,
setReadOnly(value){sessionReadOnly=value;},
seedTurn(turn){lastTurn=turn;},
setInput(value){query=value;},
finishCurrent(){busy=false;lastTurn={...lastTurn,status:'COMPLETED'};},
switchSession(id){navigationGeneration.current++;submissionAttempt.current=null;sessionId=id;busy=false;lastTurn=null;activeTurnId='';error='';},
get:()=>({busy,stopping,lastTurn,turns,activeTurnId,retryQuestion,error,progress,queuedFollowup,query,attempt:submissionAttempt.current})};
`;
return new Function('api', 'helpers', 'hooks', 'restoredAnalysisDraft', ts.transpileModule(body, {compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText)(api, helpers, hooks, restoredAnalysisDraft);
function fixture(t, overrides = {}, initialPages = { 'session-1': page('session-1') }) {
const pages = { ...initialPages };
const requests = { starts: [], cancels: [], retries: [], follows: [] };
const transport = {
analysisSessions: async () => ({ items: Object.keys(pages).map(id => ({ id })) }),
analysisSessionFollow: (id, { signal, onEvent }) => {
const end = deferred();
requests.follows.push({ id, emit: onEvent, close: end.resolve });
signal.addEventListener('abort', end.resolve, { once: true });
onEvent({ event: 'snapshot', data: pages[id] || page(id) });
return end.promise;
},
createAnalysisSession: async () => ({ session: { id: 'session-1' } }),
startAnalysisTurn: async (id, body) => {
requests.starts.push({ id, ...body });
const turn = saved('turn-1', 'QUEUED', { sessionId: id, question: body.question });
pages[id] = page(id, [...(pages[id]?.turns || []), turn], { activeTurnId: turn.id });
return { turn };
},
retryAnalysisTurn: async id => { requests.retries.push(id); throw new Error('Unexpected retry'); },
cancelAnalysisTurn: async id => {
requests.cancels.push(id);
for (const [sessionId, previous] of Object.entries(pages)) {
const turns = previous.turns.map(turn => turn.id === id ? { ...turn, status: 'CANCELLED' } : turn);
pages[sessionId] = { ...previous, turns, activeTurnId: previous.activeTurnId === id ? '' : previous.activeTurnId };
}
return { status: 'CANCELLED', turnId: id };
},
...overrides,
};
const client = createAnalysisSessionClient({ userId: 'submission-fixture', transport });
t.after(client.dispose);
return { client, pages, requests, state: client.getSnapshot };
}
test('read-only history cannot submit, retry, or queue analysis and keeps its saved turn and draft', async () => {
const calls=[];const ui=fixture({startAnalysisTurn:async()=>calls.push('start'),retryAnalysisTurn:async()=>calls.push('retry')});
const turn={id:'legacy-turn',status:'FAILED',question:'old question',result:{answer:'saved answer'}};
ui.seedTurn(turn);ui.setInput('new question');ui.setReadOnly(true);
await ui.submit();await ui.retryTurn(turn);ui.queueFollowup();
assert.deepEqual(calls,[]);assert.equal(ui.get().lastTurn,turn);assert.equal(ui.get().query,'new question');
assert.equal(ui.get().busy,false);assert.equal(ui.get().queuedFollowup,'');
test('read-only history cannot submit or retry and keeps its saved turn', async t => {
const legacy = saved('legacy-turn', 'FAILED', { result: { answer: 'saved answer' } });
const { client, requests, state } = fixture(t, {}, { 'session-1': page('session-1', [legacy], { readOnly: true }) });
await client.openSession('session-1');
assert.equal(await client.submit('new question'), false);
assert.equal(await client.retry('legacy-turn'), false);
assert.deepEqual(requests.starts, []);
assert.deepEqual(requests.retries, []);
assert.equal(state().turns[0].result.answer, 'saved answer');
assert.equal(state().busy, false);
assert.equal(state().queuedQuestion, '');
});
test('unknown result retries reuse the key only for identical frozen submission', () => {
const input={sessionId:'s',question:'q',generation:1,context:{month:9,year:2026}};
const prior=helpers.beginAnalysisSubmission(null,input,()=> 'first-key');prior.uncertain=true;prior.inFlight=false;
assert.equal(helpers.beginAnalysisSubmission(prior,{...input,context:{year:2026,month:9}},()=> 'new-key'),prior);
for(const change of [{question:'other'},{sessionId:'other'},{generation:2},{context:{month:8,year:2026}}])
assert.equal(helpers.beginAnalysisSubmission(prior,{...input,...change},()=> 'new-key').idempotencyKey,'new-key');
const input = { sessionId: 's', question: 'q', generation: 1, context: { month: 9, year: 2026 } };
const prior = beginAnalysisSubmission(null, input, () => 'first-key');
prior.uncertain = true;
prior.inFlight = false;
assert.equal(beginAnalysisSubmission(prior, { ...input, context: { year: 2026, month: 9 } }, () => 'new-key'), prior);
for (const change of [{ question: 'other' }, { sessionId: 'other' }, { generation: 2 }, { context: { month: 8, year: 2026 } }]) {
assert.equal(beginAnalysisSubmission(prior, { ...input, ...change }, () => 'new-key').idempotencyKey, 'new-key');
}
});
test('explicit client rejection differs from an unknown network/server outcome', () => {
for(const status of [400,401,403,404,409,413,422,429])assert.equal(helpers.submissionOutcomeUnknown({status}),false);
for(const status of [0,200,408,500,502,503])assert.equal(helpers.submissionOutcomeUnknown({status}),true);
assert.equal(helpers.submissionOutcomeUnknown(new Error('connection lost')),true);
for (const status of [400, 401, 403, 404, 409, 413, 422, 429]) assert.equal(submissionOutcomeUnknown({ status }), false);
for (const status of [0, 200, 408, 500, 502, 503]) assert.equal(submissionOutcomeUnknown({ status }), true);
assert.equal(submissionOutcomeUnknown(new Error('connection lost')), true);
});
test('stop during turn creation is fulfilled once its response identifies the turn', async () => {
const start=deferred(),cancelled=[];
const ui=fixture({startAnalysisTurn:()=>start.promise,cancelAnalysisTurn:async id=>cancelled.push(id),analysisTurn:async()=>({status:'CANCELLED'})});
const pending=ui.submit('q');await ui.cancelTurn();assert.deepEqual(cancelled,[]);
start.resolve({turn:{id:'turn-1',status:'QUEUED'}});await pending;
assert.deepEqual(cancelled,['turn-1']);assert.equal(ui.get().lastTurn.status,'CANCELLED');assert.equal(ui.get().busy,false);
test('stop during turn creation is fulfilled once the receipt identifies the turn', async t => {
const receipt = deferred();
const { client, pages, requests, state } = fixture(t, { startAnalysisTurn: () => receipt.promise });
await client.openSession('session-1');
const pending = client.submit('q');
await tick();
assert.equal(await client.cancel(), true);
assert.deepEqual(requests.cancels, []);
const turn = saved('turn-1', 'QUEUED');
pages['session-1'] = page('session-1', [turn], { activeTurnId: 'turn-1' });
receipt.resolve({ turn });
assert.equal(await pending, true);
assert.deepEqual(requests.cancels, ['turn-1']);
assert.equal(state().turns.at(-1).status, 'CANCELLED');
assert.equal(state().busy, false);
});
test('stop before the new session is created prevents a model turn from starting', async () => {
const created=deferred();let starts=0;
const ui=fixture({createAnalysisSession:()=>created.promise,startAnalysisTurn:async()=>{starts++;}}, {}, '');
const pending=ui.submit('q');await ui.cancelTurn();created.resolve({session:{id:'new-session'}});await pending;
assert.equal(starts,0);assert.equal(ui.get().lastTurn.status,'CANCELLED');assert.equal(ui.get().busy,false);
test('stop before the new session is created prevents a model turn from starting', async t => {
const created = deferred();
const { client, requests, state } = fixture(t, { createAnalysisSession: () => created.promise }, {});
const pending = client.submit('q');
assert.equal(await client.cancel(), true);
created.resolve({ session: { id: 'new-session' } });
assert.equal(await pending, false);
assert.deepEqual(requests.starts, []);
assert.deepEqual(state().turns, []);
assert.equal(state().pendingQuestion, '');
assert.equal(state().busy, false);
});
test('a follow-up entered while analysis runs is sent after the current turn settles', async () => {
const following=deferred(),questions=[];
const ui=fixture({startAnalysisTurn:async(_session,body)=>{questions.push(body.question);return {turn:{id:`turn-${questions.length}`}};}},
{followTurn:()=>following.promise});
const first=ui.submit('initial question');await tick();
ui.setInput('follow-up question');ui.queueFollowup();
assert.equal(ui.get().queuedFollowup,'follow-up question');
assert.equal(ui.get().query,'');
assert.deepEqual(questions,['initial question']);
following.resolve();await first;ui.finishCurrent();
await ui.sendQueuedFollowup();
assert.deepEqual(questions,['initial question','follow-up question']);
assert.equal(ui.get().queuedFollowup,'');
test('a follow-up waits for the accepted task to settle and then sends once', async t => {
const { client, requests, pages, state } = fixture(t);
await client.openSession('session-1');
assert.equal(await client.submit('initial question'), true);
await tick();
assert.equal(await client.submit('follow-up question'), true);
assert.equal(await client.submit('second queued question'), false);
assert.equal(state().queuedQuestion, 'follow-up question');
assert.deepEqual(requests.starts.map(request => request.question), ['initial question']);
pages['session-1'] = page('session-1', [saved('turn-1', 'COMPLETED', { question: 'initial question' })]);
const current = requests.follows.at(-1);
current.emit({ id: '1', event: 'completed', data: { turnId: 'turn-1', result: { answer: 'done' } } });
current.close();
await tick();
requests.follows.at(-1).close();
await tick();
assert.deepEqual(requests.starts.map(request => request.question), ['initial question', 'follow-up question']);
assert.equal(state().queuedQuestion, '');
});
test('session-list refresh cannot delay turn following or its stop target', async () => {
const list=deferred(),following=deferred(),followed=[];
const ui=fixture({startAnalysisTurn:async()=>({turn:{id:'turn-1'}})}, {loadSessions:()=>list.promise,followTurn:id=>{followed.push(id);return following.promise;}});
const pending=ui.submit('q');await tick();assert.deepEqual(followed,['turn-1']);assert.equal(ui.get().activeTurnId,'turn-1');
following.resolve();list.resolve();await pending;
test('session-list refresh cannot delay following or the stop target', async t => {
const list = deferred();
const { client, requests, state } = fixture(t, { analysisSessions: () => list.promise });
await client.openSession('session-1');
assert.equal(await client.submit('q'), true);
await tick();
assert.equal(state().sessionsLoading, true);
assert.equal(requests.follows.length, 2);
assert.equal(state().activeTurnId, 'turn-1');
assert.equal(await client.cancel(), true);
assert.deepEqual(requests.cancels, ['turn-1']);
list.resolve({ items: [] });
});
test('a lost accepted response retries the same key without archiving an unsaved phantom turn', async () => {
const calls=[];
const ui=fixture({startAnalysisTurn:async(session,body)=>{calls.push({session,...body});if(calls.length===1)throw Object.assign(new Error('lost response'),{status:0});return {turn:{id:'original-turn'}};}});
await ui.submit('q');assert.equal(ui.get().attempt.uncertain,true);
await ui.submit(ui.get().retryQuestion);assert.equal(calls.length,2);assert.equal(calls[0].idempotencyKey,calls[1].idempotencyKey);
assert.equal(ui.get().lastTurn.id,'original-turn');assert.deepEqual(ui.get().turns,[]);
test('a lost accepted response retries the same key without archiving a phantom turn', async t => {
const bodies = [];
const { client, pages, state } = fixture(t, {
startAnalysisTurn: async (id, body) => {
bodies.push(body);
if (bodies.length === 1) throw Object.assign(new Error('service unavailable'), { status: 503 });
const turn = saved('original-turn', 'RUNNING', { question: body.question });
pages[id] = page(id, [turn], { activeTurnId: turn.id });
return { turn };
},
});
await client.openSession('session-1');
assert.equal(await client.submit('q'), false);
assert.equal(state().retryQuestion, 'q');
assert.equal(state().error, 'service unavailable');
assert.equal(state().busy, false);
assert.equal(state().activeTurnId, '');
assert.deepEqual(state().turns, []);
assert.equal(await client.submit(state().retryQuestion), true);
assert.equal(bodies.length, 2);
assert.equal(bodies[0].idempotencyKey, bodies[1].idempotencyKey);
assert.deepEqual(state().turns.map(turn => turn.id), ['original-turn']);
});
test('an explicit rejection clears the attempt so a corrected retry gets a fresh key', async () => {
const keys=[];
const ui=fixture({startAnalysisTurn:async(_session,body)=>{keys.push(body.idempotencyKey);throw Object.assign(new Error('validation rejected'),{status:400});}});
await ui.submit('q');assert.equal(ui.get().attempt,null);await ui.submit('corrected q');assert.notEqual(keys[0],keys[1]);
test('an explicit 400 rejection gives the same editable question a fresh key without showing it as running', async t => {
const keys = [];
const { client, state } = fixture(t, {
startAnalysisTurn: async (_id, body) => {
keys.push(body.idempotencyKey);
throw Object.assign(new Error('invalid question'), { status: 400 });
},
});
await client.openSession('session-1');
assert.equal(await client.submit('rejected question'), false);
assert.equal(state().retryQuestion, 'rejected question');
assert.equal(state().error, 'invalid question');
assert.equal(state().busy, false);
assert.deepEqual(state().turns, []);
assert.equal(await client.submit(state().retryQuestion), false);
assert.notEqual(keys[0], keys[1]);
});
test('switching session while creation is pending cannot cancel or render into the new session', async () => {
const start=deferred(),cancelled=[];
const ui=fixture({startAnalysisTurn:()=>start.promise,cancelAnalysisTurn:async id=>cancelled.push(id)});
const pending=ui.submit('q');await ui.cancelTurn();ui.switchSession('session-2');start.resolve({turn:{id:'old-turn'}});await pending;
assert.deepEqual(cancelled,[]);assert.equal(ui.get().lastTurn,null);assert.equal(ui.get().activeTurnId,'');
test('a pending stop applies only to its original turn after navigation', async t => {
const receipt = deferred();
const { client, requests, state } = fixture(t, { startAnalysisTurn: () => receipt.promise });
await client.openSession('session-1');
const pending = client.submit('q');
await tick();
assert.equal(await client.cancel(), true);
await client.openSession('session-2');
receipt.resolve({ turn: saved('old-turn', 'RUNNING', { sessionId: 'session-1' }) });
assert.equal(await pending, true);
assert.deepEqual(requests.cancels, ['old-turn']);
assert.deepEqual(state().turns, []);
assert.equal(state().activeTurnId, '');
assert.equal(state().sessionId, 'session-2');
});
test('stop during retry waits for requeue instead of cancelling the old terminal state', async () => {
const retry=deferred(),cancelled=[];
const ui=fixture({retryAnalysisTurn:()=>retry.promise,cancelAnalysisTurn:async id=>cancelled.push(id),analysisTurn:async()=>({status:'CANCELLED'})});
ui.seedTurn({id:'newest-turn',question:'newest question',status:'COMPLETED'});
const pending=ui.retryTurn({id:'partial-turn',sessionId:'session-1',question:'q',status:'PARTIAL'});
await ui.cancelTurn();assert.deepEqual(cancelled,[]);
retry.resolve({turn:{id:'partial-turn',sessionId:'session-1',status:'QUEUED'}});await pending;
assert.deepEqual(cancelled,['partial-turn']);assert.equal(ui.get().busy,false);assert.equal(ui.get().lastTurn.question,'q');
test('stop during retry waits for requeue and targets the original saved turn', async t => {
const receipt = deferred();
const savedTurn = saved('partial-turn', 'PARTIAL');
const { client, pages, requests, state } = fixture(t, { retryAnalysisTurn: () => receipt.promise }, {
'session-1': page('session-1', [savedTurn, saved('newest-turn', 'COMPLETED')]),
});
await client.openSession('session-1');
const pending = client.retry('partial-turn');
assert.equal(await client.cancel(), true);
assert.deepEqual(requests.cancels, []);
const turn = { ...savedTurn, status: 'QUEUED' };
pages['session-1'] = page('session-1', [turn, saved('newest-turn', 'COMPLETED')], { activeTurnId: 'partial-turn' });
receipt.resolve({ turn });
assert.equal(await pending, true);
assert.deepEqual(requests.cancels, ['partial-turn']);
assert.equal(state().busy, false);
assert.equal(state().turns.find(row => row.id === 'partial-turn').status, 'CANCELLED');
});
test('a late cancellation failure cannot put an error in a newly selected session', async () => {
const cancel=deferred(),following=deferred();
const ui=fixture({startAnalysisTurn:async()=>({turn:{id:'turn-1'}}),cancelAnalysisTurn:()=>cancel.promise}, {followTurn:()=>following.promise});
const pending=ui.submit('q');await tick();const stopping=ui.cancelTurn();ui.switchSession('other');cancel.reject(new Error('cancellation response lost'));await stopping;following.resolve();await pending;
assert.equal(ui.get().error,'');assert.equal(ui.get().lastTurn,null);
test('a late cancellation failure cannot put an error in a newly selected session', async t => {
const cancel = deferred();
const { client, state } = fixture(t, { cancelAnalysisTurn: () => cancel.promise });
await client.openSession('session-1');
await client.submit('q');
const stopping = client.cancel();
await client.openSession('other');
cancel.reject(new Error('cancellation response lost'));
assert.equal(await stopping, false);
assert.equal(state().error, '');
assert.deepEqual(state().turns, []);
});
test('repeated stop clicks make one cancellation request until the task settles', async () => {
const cancel=deferred(),following=deferred();let cancellationCount=0,detailReads=0;
const ui=fixture({startAnalysisTurn:async()=>({turn:{id:'turn-1'}}),cancelAnalysisTurn:()=>{cancellationCount++;return cancel.promise;},
analysisTurn:async()=>{detailReads++;return {id:'turn-1',status:'CANCELLED'};}}, {followTurn:()=>following.promise});
const pending=ui.submit('q');await tick();const first=ui.cancelTurn(),second=ui.cancelTurn();
await second;assert.equal(cancellationCount,1);assert.equal(ui.get().stopping,true);
cancel.resolve();await first;assert.equal(ui.get().attempt,null);assert.equal(ui.get().busy,false);assert.equal(detailReads,1);
following.resolve();await pending;
test('repeated stop clicks share one request until the task settles', async t => {
const cancellation = deferred();
let count = 0;
const { client, pages, state } = fixture(t, { cancelAnalysisTurn: () => { count++; return cancellation.promise; } });
await client.openSession('session-1');
await client.submit('q');
const first = client.cancel();
assert.equal(await client.cancel(), false);
assert.equal(count, 1);
assert.equal(state().stopping, true);
pages['session-1'] = page('session-1', [saved('turn-1', 'CANCELLED')]);
cancellation.resolve({ status: 'CANCELLED', turnId: 'turn-1' });
assert.equal(await first, true);
assert.equal(state().busy, false);
});
test('stopping retains a queued question and any newer draft without sending either', async () => {
const following=deferred(),questions=[];
const ui=fixture({startAnalysisTurn:async(_session,body)=>{questions.push(body.question);return {turn:{id:'turn-1'}};},
cancelAnalysisTurn:async()=>{},analysisTurn:async()=>({id:'turn-1',status:'CANCELLED'})}, {followTurn:()=>following.promise});
const pending=ui.submit('initial');await tick();
ui.setInput('queued follow-up');ui.queueFollowup();ui.setInput('new unsent draft');
await ui.cancelTurn();await ui.sendQueuedFollowup();
assert.equal(ui.get().query,'queued follow-up\n\nnew unsent draft');assert.equal(ui.get().queuedFollowup,'');
assert.deepEqual(questions,['initial']);following.resolve();await pending;
test('stopping keeps the queued question available for editing and does not send it', async t => {
const { client, requests, state } = fixture(t);
await client.openSession('session-1');
await client.submit('initial');
await client.submit('queued follow-up');
await client.cancel();
await tick();
requests.follows.at(-1).close();
await tick();
assert.equal(state().queuedQuestion, 'queued follow-up');
assert.deepEqual(requests.starts.map(request => request.question), ['initial']);
assert.equal(client.takeQueued(), 'queued follow-up');
assert.equal(state().queuedQuestion, '');
});
test('a failed stop request allows another explicit stop attempt', async () => {
const following=deferred();let cancellationCount=0;
const ui=fixture({startAnalysisTurn:async()=>({turn:{id:'turn-1'}}),cancelAnalysisTurn:async()=>{cancellationCount++;if(cancellationCount===1)throw new Error('offline');},
analysisTurn:async()=>({id:'turn-1',status:'CANCELLED'})}, {followTurn:()=>following.promise});
const pending=ui.submit('initial');await tick();await ui.cancelTurn();
assert.equal(ui.get().stopping,false);assert.equal(ui.get().busy,true);
await ui.cancelTurn();assert.equal(cancellationCount,2);assert.equal(ui.get().busy,false);
following.resolve();await pending;
test('a failed stop request allows another explicit stop attempt', async t => {
let count = 0;
const { client, pages, state } = fixture(t, {
cancelAnalysisTurn: async id => {
if (++count === 1) throw new Error('offline');
pages['session-1'] = page('session-1', [saved(id, 'CANCELLED')]);
return { status: 'CANCELLED', turnId: id };
},
});
await client.openSession('session-1');
await client.submit('initial');
assert.equal(await client.cancel(), false);
assert.equal(state().stopping, false);
assert.equal(state().busy, true);
assert.equal(await client.cancel(), true);
assert.equal(count, 2);
assert.equal(state().busy, false);
});
test('unknown 503 submission renders recovery notice without claiming a queued or running task', async () => {
const ui=fixture({startAnalysisTurn:async()=>{throw Object.assign(new Error('service unavailable'),{status:503});}});
await ui.submit('question with unknown outcome');
assert.equal(ui.get().attempt.uncertain,true);
const html=renderDraft(ui.get().lastTurn);
assert.doesNotMatch(html,/提交结果暂未确认/);
assert.doesNotMatch(html,/排队中|正在准备分析|仍在运行/);
assert.equal(ui.get().lastTurn.status,undefined);
test('a fresh submission immediately carries waiting status and a clock before acceptance', async t => {
const receipt = deferred();
const { client, pages, state } = fixture(t, { startAnalysisTurn: () => receipt.promise });
await client.openSession('session-1');
const pending = client.submit('即时状态');
assert.equal(state().turns.at(-1).status, 'SUBMITTING');
assert.ok(Number.isFinite(Date.parse(state().turns.at(-1)._uiSubmittedAt)));
const turn = saved('accepted', 'RUNNING', { question: '即时状态', createdAt: new Date().toISOString() });
pages['session-1'] = page('session-1', [turn], { activeTurnId: turn.id });
receipt.resolve({ turn });
assert.equal(await pending, true);
assert.equal(state().turns.at(-1).id, 'accepted');
assert.ok(Number.isFinite(Date.parse(state().turns.at(-1).createdAt)));
});
test('an explicit 400 rejection renders an unsuccessful draft without a running status', async () => {
const ui=fixture({startAnalysisTurn:async()=>{throw Object.assign(new Error('invalid question'),{status:400});}});
await ui.submit('rejected question');
assert.equal(ui.get().attempt,null);
const html=renderDraft(ui.get().lastTurn);
assert.doesNotMatch(html,/本次提交未成功/);
assert.doesNotMatch(html,/排队中|正在准备分析|仍在运行|恢复原任务/);
assert.equal(ui.get().lastTurn.status,undefined);
});
test('a fresh submission immediately carries waiting status and a clock before acceptance',async()=>{
const pending=deferred();const ui=fixture({startAnalysisTurn:()=>pending.promise});
const work=ui.submit('即时状态');assert.equal(ui.get().lastTurn.status,'SUBMITTING');
assert.ok(Number.isFinite(Date.parse(ui.get().lastTurn._uiSubmittedAt)));
pending.resolve({turn:{id:'accepted',status:'RUNNING'}});await work;
assert.ok(Number.isFinite(Date.parse(ui.get().lastTurn._uiSubmittedAt)));
});
test('retry starts a fresh waiting clock without displaying the old body or plan clock',async()=>{
const response=deferred();const ui=fixture({retryAnalysisTurn:()=>response.promise,analysisTurn:async()=>({id:'old',status:'QUEUED'})});
const work=ui.retryTurn({id:'old',status:'PARTIAL',answer:'old text',createdAt:'2020-01-01T00:00:00Z',startedAt:'2020-01-01T00:00:01Z',plan:{startedAt:'2020-01-01T00:00:01Z'}});
assert.equal(ui.get().lastTurn.status,'SUBMITTING');assert.equal(ui.get().lastTurn.answer,undefined);assert.equal(ui.get().lastTurn.plan,undefined);
response.resolve({turn:{id:'old',sessionId:'session-1',status:'QUEUED'}});await work;
test('retry starts a fresh waiting clock without the old answer or plan clock', async t => {
const receipt = deferred();
const old = saved('old', 'PARTIAL', {
answer: 'old text', createdAt: '2020-01-01T00:00:00Z', startedAt: '2020-01-01T00:00:01Z',
plan: { startedAt: '2020-01-01T00:00:01Z' },
});
const { client, pages, state } = fixture(t, { retryAnalysisTurn: () => receipt.promise }, {
'session-1': page('session-1', [old]),
});
await client.openSession('session-1');
const pending = client.retry('old');
const current = state().turns[0];
assert.equal(current.status, 'SUBMITTING');
assert.ok(Number.isFinite(Date.parse(current._uiSubmittedAt)));
assert.equal(current.answer, undefined);
assert.equal(current.plan, undefined);
assert.equal(current.startedAt, undefined);
const turn = saved('old', 'QUEUED');
pages['session-1'] = page('session-1', [turn], { activeTurnId: turn.id });
receipt.resolve({ turn });
assert.equal(await pending, true);
});
@@ -8,14 +8,14 @@ const saved=()=>({id:'turn1',status:'PARTIAL',question:'原问题',plan:{protoco
const complete=source=>({...structuredClone(source),status:'COMPLETED',visualState:'ready',visualRecovery:{complete:true},visuals:[{id:'chart1',series:[2]}]});
const deferred=()=>{let resolve,reject;const promise=new Promise((r,j)=>{resolve=r;reject=j;});return{promise,resolve,reject};};
const tick=()=>new Promise(r=>setImmediate(r));
function fixture(request){let cursor=0,dirty=false,queue=[],source=saved(),value;const states=new Map(),refs=new Map(),effects=new Map(),calls={api:0,denied:0};
function fixture(request,auto=false){let cursor=0,dirty=false,queue=[],source=saved(),value;const states=new Map(),refs=new Map(),effects=new Map(),calls={api:0,denied:0};
const hooks={useState(initial){const i=cursor++;if(!states.has(i))states.set(i,initial);return[states.get(i),next=>{states.set(i,next);dirty=true;}];},useRef(initial){const i=cursor++;if(!refs.has(i))refs.set(i,{current:initial});return refs.get(i);},useCallback(fn){cursor++;return fn;},useEffect(fn,deps){const i=cursor++,old=effects.get(i);if(!old||deps.some((d,j)=>!Object.is(d,old.deps[j])))queue.push(()=>{old?.cleanup?.();effects.set(i,{deps,cleanup:fn()});});}};
const api={recoverAnalysisVisuals:async id=>{calls.api++;assert.equal(id,source.id);return request();}};
// Separate modules retain their own helper bindings just as in production.
const snapshot=new Function('api',snapshotBody+';return {analysisSnapshotResult,reportSnapshotDifferences,reportSnapshotIdentity};')(api);
const useHook=new Function('api','snapshot','hooks',`const {analysisSnapshotResult,reportSnapshotDifferences,reportSnapshotIdentity}=snapshot;const {useState,useEffect,useRef,useCallback}=hooks;${hookBody};return useAnalysisVisualRecovery;`)(api,snapshot,hooks);
const denied=error=>{if(error.message==='DENIED'){calls.denied++;return true;}return false;};
const render=()=>{let n=0;do{dirty=false;queue=[];cursor=0;value=useHook(source,denied);queue.forEach(fn=>fn());if(++n>15)throw Error('render loop');}while(dirty);return value;};
const render=()=>{let n=0;do{dirty=false;queue=[];cursor=0;value=useHook(source,denied,auto);queue.forEach(fn=>fn());if(++n>15)throw Error('render loop');}while(dirty);return value;};
return{calls,render,get value(){return value;},get source(){return source;},replace(next){source=next;return render();},async settle(){await tick();return render();},unmount(){effects.forEach(e=>e.cleanup?.());}};
}
// Resolve its imported snapshot helper explicitly.
@@ -32,3 +32,14 @@ test('a duplicate click recovers only charts and retains facts',async()=>{const
test('a changed fact, source execution, or returned turn is rejected',async()=>{for(const change of [v=>({...v,answer:'换了答案'}),v=>({...v,id:'turn2'}),v=>({...v,plan:{...v.plan,executionId:'exec2'}})]){let ui;ui=fixture(async()=>change(complete(ui.source)));ui.render();await ui.value.recover();await ui.settle();assert.equal(ui.value.turn.status,'PARTIAL');assert.match(ui.value.error,/原分析已变化/);ui.unmount();}});
test('late recovery cannot overwrite a changed revision or an unmounted view',async()=>{const response=deferred(),ui=fixture(()=>response.promise);ui.render();const before=structuredClone(ui.source),request=ui.value.recover();ui.replace({...before,plan:{...before.plan,revision:3},answer:'新答案'});response.resolve(complete(before));await request;await ui.settle();assert.equal(ui.value.turn.answer,'新答案');assert.equal(ui.value.turn.status,'PARTIAL');ui.unmount();});
test('failure retains the saved answer and permission errors reach the access handler',async()=>{for(const message of ['暂时失败','DENIED']){const ui=fixture(async()=>{throw Error(message);});ui.render();await ui.value.recover();await ui.settle();assert.equal(ui.value.turn.answer,'原答案');assert.equal(ui.value.turn.status,'PARTIAL');assert.equal(ui.calls.denied,message==='DENIED'?1:0);if(message!=='DENIED')assert.equal(ui.value.error,message);ui.unmount();}});
test('a completed empty aggregate selection has no chart retry while real chart errors remain recoverable',()=>{
const ui=fixture(async()=>{throw Error('should not query');});ui.render();
const value={...ui.source,status:'COMPLETED',visualState:'not_requested',plan:{...ui.source.plan,task:{kind:'analysis',executionMode:'native_agent',visualPreference:'auto',aggregateSelection:{metric:'rate'}}}};
ui.replace(value);assert.equal(ui.value.available,false);
ui.replace({...value,visualState:'failed'});assert.equal(ui.value.available,true);ui.unmount();
});
test('automatic presentation recovery runs once per saved execution and retains the original answer on failure',async()=>{
const ui=fixture(async()=>{throw Error('temporary chart failure');},true);
ui.render();await ui.settle();await ui.settle();assert.equal(ui.calls.api,1);
assert.equal(ui.value.turn.answer,'原答案');assert.equal(ui.value.turn.visualState,'failed');ui.unmount();
});
@@ -85,6 +85,11 @@ test('late authorization for an older snapshot cannot remount or overwrite a cha
auth.resolve();await ui.settle();assert.equal(ui.calls.loads,loads);assert.equal(ui.calls.options.at(-1).scope.product,'新规格');assert.deepEqual(ui.calls.options.at(-1).series[0].values,[.91,.93]);ui.unmount();
});
test('quiet chart failures remove the card and expose no error or retry controls',async()=>{
const ui=fixture();ui.props.quiet=true;ui.render();const tree=await ui.settle();
assert.equal(tree,null);assert.doesNotMatch(text(tree),/failed|重试|失败/);ui.unmount();
});
test('unmounting while authorization is pending prevents a late renderer start',async()=>{
const auth=deferred(),ui=fixture({authorize:()=>auth.promise});ui.render();await ui.settle();ui.retry();ui.unmount();auth.resolve();await tick();assert.equal(ui.calls.loads,1);
});