Files
Agent-Workbench/tests/engine-context.test.mjs
T
2026-11-07 22:50:39 +08:00

79 lines
6.6 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { engineCanonicalDigest } from '../src/shared/contracts/engines.mjs';
import { nativeMessagesToChat } from '../src/shared/contracts/engine-execution.mjs';
import { engineHistoryGroups,engineResultView,engineContextIndex,engineContextView } from '../src/shared/contracts/engine-context.mjs';
import { replayFixtureJson } from '../scripts/verify-replay-fixtures.mjs';
function replay(name){
const {input,config,evidence}=replayFixtureJson('engine-context/'+name+'.json');
const messages=nativeMessagesToChat(input);
const index=engineContextIndex(messages,evidence,{artifact_id:'original-native-input',sha256:engineCanonicalDigest(input)});
const projected=engineContextView(messages,input.tools.map(x=>({type:'function',function:x})),config,index,{id:'original-index',sha256:engineCanonicalDigest(index)});
return {input,messages,index,config,projected,evidence};
}
for(const name of ['r1-off','r1-on','r2-on','r2-off'])test('sealed '+name+' failure fits its original 16K config with authentic latest status and readable source',()=>{
const {input,messages,index,config,projected}=replay(name);
assert.equal(config.contextLimit,16000);assert.equal(projected.mode,'bounded');
assert.ok(projected.before.estimatedInputTokens+input.maxTokens+128>16000);
assert.ok(projected.metrics.estimatedInputTokens<=projected.inputBudget);
assert.ok(projected.metrics.estimatedInputTokens+input.maxTokens+projected.safetyTokens<=16000);
assert.deepEqual(projected.messages.filter(x=>['system','developer','user'].includes(x.role)).slice(1),messages.filter(x=>['system','developer','user'].includes(x.role)));
assert.doesNotThrow(()=>engineHistoryGroups(projected.messages));
const text=JSON.stringify(projected.messages),latest=index.groups.filter(x=>x.results.length).at(-1);
for(const result of latest.results)assert.ok(text.includes(result.call_id)||text.includes(result.result_artifact_id));
if(name!=='r1-on'){assert.ok(text.includes('failed'));assert.ok(text.includes('logArtifactId'));assert.ok(text.includes('"failed":9')||text.includes('\\"failed\\":9'));}
assert.ok(text.includes('original-index'));assert.ok(projected.archivedGroups.length>0);
});
test('archived native call pairs require exact saved arguments/results rather than model-written summaries',()=>{
const {messages,evidence}=replay('r1-off');
const changed=structuredClone(evidence);changed[0].content+='changed';
assert.throws(()=>engineContextIndex(messages,changed,{}),/参数或结果/);
assert.throws(()=>engineContextIndex(messages,evidence.slice(1),{}),/缺少所属/);
const malformed=structuredClone(messages);malformed.find(x=>x.role==='tool').tool_call_id='foreign';
assert.throws(()=>engineHistoryGroups(malformed),/缺少或错配/);
});
test('full system/user requirements and mandatory current failure can refuse rather than be trimmed',()=>{
const {messages,index,config}=replay('r1-off');
const required={role:'user',content:'Do not change protected files. 原要求。'.repeat(2000)};
const original=structuredClone([...messages,required]);
const view=engineContextView(original,[],{...config,contextLimit:1600},index,{id:'idx',sha256:'original'});
assert.ok(view.metrics.estimatedInputTokens>view.inputBudget);assert.ok(view.messages.some(x=>x.content===required.content));
assert.deepEqual(original,[...messages,required]);
});
test('small native input is byte-preserving; developer instructions remain mandatory after compaction',()=>{
const messages=[{role:'developer',content:'Bounded host policy'},{role:'user',content:'Fix original code'}];
const config={model:'fixture',contextLimit:16000,maxOutputTokens:512};
const view=engineContextView(messages,[],config,null,{id:null,sha256:null});
assert.equal(view.mode,'full');assert.deepEqual(view.body.messages,messages);assert.deepEqual(view.archivedGroups,[]);
});
test('older failing checks and pending proposals remain visible after a later large file read',()=>{
const {messages,evidence,config}=replay('r1-off');
const changes={role:'assistant',content:'',tool_calls:[{id:'proposal',type:'function',function:{name:'propose_file',arguments:'{"path":"src/amount.mjs"}'}}]};
const source={role:'assistant',content:'',tool_calls:[{id:'read',type:'function',function:{name:'read_file',arguments:'{"path":"test/expense.test.mjs"}'}}]};
const returned=[{role:'tool',tool_call_id:'proposal',content:JSON.stringify({status:'pending',change_id:'pending-amount',path:'src/amount.mjs'})},
{role:'tool',tool_call_id:'read',content:JSON.stringify({path:'test/expense.test.mjs',content:'actual old file content\n'.repeat(2000)})}];
const original=[...messages,changes,returned[0],source,returned[1]];
const proof=[...evidence,...[changes,source].map((item,i)=>({callId:item.tool_calls[0].id,name:item.tool_calls[0].function.name,
argumentsSha256:engineCanonicalDigest(JSON.parse(item.tool_calls[0].function.arguments)),content:returned[i].content,
artifactId:'owned-'+i,sha256:'saved-'+i,invocationId:'tool-'+i,state:'completed',requiresVerification:false}))];
const index=engineContextIndex(original,proof,{}),view=engineContextView(original,[],config,index,{id:'history',sha256:'original'});
const text=JSON.stringify(view.messages);assert.equal(view.mode,'bounded');assert.ok(view.metrics.estimatedInputTokens<=view.inputBudget);
assert.ok(text.includes('pending-amount'));assert.ok(text.includes('failed'));assert.ok(text.includes('logArtifactId'));
assert.ok(text.includes('recorded_operations'));assert.ok(text.includes('view_content_truncated'));assert.doesNotThrow(()=>engineHistoryGroups(view.messages));
});
test('bounded result keeps every check status and cuts Unicode only on whole characters',()=>{
const results=Array.from({length:9},(_,index)=>({id:'check-'+index,status:index===8?'failed':'passed',logArtifactId:'log-'+index,
tests:{total:1,passed:index===8?0:1,failed:index===8?1:0},logExcerpt:'a'.repeat(1199)+'😀diagnostic'}));
const view=engineResultView(JSON.stringify({results,content:'a'.repeat(2399)+'😀file'}));
assert.equal(view.results.length,9);assert.equal(view.results[8].status,'failed');assert.equal(view.results[8].logArtifactId,'log-8');
assert.equal(view.results[0].logExcerpt,undefined);assert.equal(view.content_excerpt,'a'.repeat(2399));assert.equal(view.view_content_truncated,true);
assert.equal(engineResultView(JSON.stringify({results:[{...results[0],status:'failed'}]})).results[0].logExcerpt,'a'.repeat(1199));
assert.throws(()=>engineContextView([{role:'user',content:'x'.repeat(10000)}],[],{model:'fixture',contextLimit:2000,maxOutputTokens:512},null,null),/归档索引/);
});