Core regression / Python core, intervention UI and release configuration (push) Successful in 4m35s
Core regression / JavaScript syntax (push) Successful in 6s
Core regression / Python core, intervention UI and release configuration (pull_request) Successful in 3m54s
Core regression / JavaScript syntax (pull_request) Successful in 4s
160 lines
9.7 KiB
JavaScript
160 lines
9.7 KiB
JavaScript
/** Exercise production diagnosis orchestration with controlled session boundaries. */
|
|
import assert from 'node:assert/strict';
|
|
import {readFile} from 'node:fs/promises';
|
|
import vm from 'node:vm';
|
|
import path from 'node:path';
|
|
import {randomUUID,createHash} from 'node:crypto';
|
|
|
|
const deferred=()=>{let resolve;const promise=new Promise(yes=>{resolve=yes;});return {promise,resolve};};
|
|
const tick=()=>new Promise(resolve=>setImmediate(resolve));
|
|
const events=[],handlers=new Map(),routes=new Map(),sessions=new Map(),prompts=[],cancelled=[],selected=[];
|
|
let nextCreate=null,nextPrompt=null,latestTimeout,now=1000000,publicationFailure=null;
|
|
const publicationCleanup=[];
|
|
const timeouts=[];
|
|
const context={task_id:'',revision:'current'};
|
|
const ctx={on:(name,fn)=>handlers.set(name,fn),effect:()=>{},
|
|
connection:{admit:()=>({})},tools:{register:()=>{},guard:()=>{}},
|
|
webServer:{register:route=>routes.set(route.path,route.handler)},
|
|
workspaceRegistry:{create:async()=>({id:'workspace'})},
|
|
sessionController:{
|
|
selectModel:async()=>{assert.fail('Automatic diagnosis must not save the global default');},
|
|
create:async({sessionId=randomUUID()}={})=>{
|
|
if(nextCreate){const wait=nextCreate;nextCreate=null;await wait.promise;}
|
|
const idle=deferred(),rows=[];
|
|
const pending=[];
|
|
sessions.set(sessionId,{idle,rows,pending,wakeRequested:false,session:{snapshotEvents:()=>rows},whenIdle:()=>idle.promise,
|
|
cancel:(_cause,options={})=>{
|
|
cancelled.push(sessionId);
|
|
if(!options.keepInbox){pending.length=0;sessions.get(sessionId).wakeRequested=false;}
|
|
}});
|
|
return {sessionId};
|
|
},rename:async()=>{},cancel:async({sessionId})=>{sessions.get(sessionId).cancel({kind:'user'},{keepInbox:true});},
|
|
commands:{prompt:async({sessionId})=>{
|
|
if(nextPrompt){const wait=nextPrompt;nextPrompt=null;await wait.promise;}
|
|
prompts.push(sessionId);
|
|
sessions.get(sessionId).pending.push('diagnosis');
|
|
sessions.get(sessionId).wakeRequested=true;
|
|
}}
|
|
},llm:{resolveCallConfig:async selection=>selection},agents:{get:id=>sessions.get(id),
|
|
serializeImageAdmission:async(_agent,action)=>action(),
|
|
selectForNextRequest:(agent,selection)=>{
|
|
const sessionId=[...sessions].find(([_id,item])=>item===agent)[0];
|
|
assert.ok(!prompts.includes(sessionId));selected.push({sessionId,...selection});
|
|
}}};
|
|
let source=await readFile(new URL('../integration/dsh/task-plugin/host.mjs',import.meta.url),'utf8');
|
|
source=source.replace(/^import .*;\r?\n/gm,'').replace(/export /g,'');
|
|
const sandbox={path,randomUUID,createHash,Date:class extends Date{static now(){return now;}},
|
|
setTimeout:(callback,ms)=>{latestTimeout=callback;timeouts.push(ms);return setTimeout(callback,ms);},clearTimeout,console,
|
|
readFile:async()=>JSON.stringify(context),appendFile:async()=>{},readdir:async()=>[],
|
|
lstat:async()=>({isFile:()=>true,isSymbolicLink:()=>false,size:0}),
|
|
mkdir:async()=>{},
|
|
writeFile:async()=>{if(publicationFailure==='write')throw Error('fixture snapshot write failed');},
|
|
rename:async()=>{if(publicationFailure==='rename')throw Error('fixture snapshot rename failed');},
|
|
unlink:async filename=>{publicationCleanup.push(filename);},defineTool:value=>value,
|
|
registerRuntimeUsage:async()=>({dispose:()=>{},snapshot:()=>({settings:{response_timeout_seconds:90}})}),
|
|
registerLifecycle:()=>{},lifecycleNames:[],registerFileTools:()=>{},fileToolNames:[],modelSnapshot:value=>value,
|
|
process:{env:{DX_DSH_HOME:'controlled',DX_DSH_WORKSPACE:'controlled'},stdout:{write:line=>{
|
|
if(line.startsWith('DX_DSH_DIAGNOSIS '))events.push(JSON.parse(line.slice('DX_DSH_DIAGNOSIS '.length)));
|
|
}}}};
|
|
vm.createContext(sandbox);
|
|
vm.runInContext(source+'\nglobalThis.applyPlugin=apply;',sandbox);
|
|
await sandbox.applyPlugin(ctx);
|
|
const start=(id,options={})=>handlers.get('dx/diagnose-request')({request_id:id,incident_id:createHash('sha256').update(id).digest('hex').slice(0,24),
|
|
phase:'diagnose',snapshot:{task_id:''},evidence:'controlled fixture',...options});
|
|
const waitFor=async predicate=>{for(let i=0;i<100&&!predicate();i++)await tick();assert.ok(predicate(),'expected lifecycle event');};
|
|
const terminal=id=>events.find(event=>event.request_id===id&&['completed','cancelled','failed'].includes(event.status));
|
|
|
|
start('cancel-active');start('keep-active',{model_selection:{provider:'configured',model:'saved-model',reasoningEffort:'high'}});
|
|
await waitFor(()=>prompts.length===2);
|
|
const first=events.find(event=>event.request_id==='cancel-active'&&event.status==='started').session_id;
|
|
const other=events.find(event=>event.request_id==='keep-active'&&event.status==='started').session_id;
|
|
assert.equal(selected.length,1,'automatic session must use the same configured model as readiness');
|
|
assert.equal(selected[0].sessionId,other);
|
|
assert.equal(selected[0].provider,'configured');
|
|
assert.equal(selected[0].model,'saved-model');
|
|
assert.equal(selected[0].reasoningEffort,'high');
|
|
handlers.get('dx/diagnose-cancel')({request_id:'unknown'});
|
|
assert.deepEqual(cancelled,[]);
|
|
handlers.get('dx/diagnose-cancel')({request_id:'cancel-active'});
|
|
await waitFor(()=>terminal('cancel-active'));
|
|
assert.equal(terminal('cancel-active').status,'cancelled');
|
|
assert.deepEqual(cancelled,[first]);
|
|
assert.equal(terminal('keep-active'),undefined);
|
|
sessions.get(other).rows.push({type:'assistant/message',data:{message:{content:[{type:'text',text:'{"action":"none"}'}]}}});
|
|
sessions.get(other).idle.resolve();
|
|
await waitFor(()=>terminal('keep-active'));
|
|
assert.equal(terminal('keep-active').status,'completed');
|
|
|
|
nextCreate=deferred();const creating=nextCreate;
|
|
start('cancel-creating');
|
|
handlers.get('dx/diagnose-cancel')({request_id:'cancel-creating'});
|
|
creating.resolve();
|
|
await waitFor(()=>terminal('cancel-creating'));
|
|
assert.equal(terminal('cancel-creating').status,'cancelled');
|
|
assert.equal(prompts.length,2,'cancel during session creation must never enqueue a prompt');
|
|
|
|
nextPrompt=deferred();const admitting=nextPrompt;
|
|
start('cancel-admitting');
|
|
await waitFor(()=>events.some(event=>event.request_id==='cancel-admitting'&&event.status==='started'));
|
|
const admittingSession=events.find(event=>event.request_id==='cancel-admitting'&&event.status==='started').session_id;
|
|
handlers.get('dx/diagnose-cancel')({request_id:'cancel-admitting'});
|
|
await waitFor(()=>terminal('cancel-admitting'));
|
|
assert.equal(terminal('cancel-admitting').status,'cancelled');
|
|
admitting.resolve();
|
|
await waitFor(()=>cancelled.filter(id=>id===admittingSession).length===2);
|
|
assert.ok(prompts.includes(admittingSession),'fixture admitted the delayed prompt');
|
|
assert.equal(sessions.get(admittingSession).pending.length,0,'cancel must clear the late automatic inbox');
|
|
assert.equal(sessions.get(admittingSession).wakeRequested,false,'cancelled diagnosis must not wake another turn');
|
|
|
|
nextPrompt=deferred();const timingOut=nextPrompt;
|
|
start('timeout-admitting');
|
|
await waitFor(()=>events.some(event=>event.request_id==='timeout-admitting'&&event.status==='started'));
|
|
const timeoutSession=events.find(event=>event.request_id==='timeout-admitting'&&event.status==='started').session_id;
|
|
latestTimeout();
|
|
await waitFor(()=>terminal('timeout-admitting'));
|
|
assert.equal(terminal('timeout-admitting').error,'diagnosis_timeout');
|
|
timingOut.resolve();
|
|
await waitFor(()=>cancelled.filter(id=>id===timeoutSession).length===2);
|
|
assert.equal(sessions.get(timeoutSession).pending.length,0,'timeout must clear the late automatic inbox');
|
|
|
|
nextCreate=deferred();const coldCreate=nextCreate;
|
|
const sharedIncident=createHash('sha256').update('shared-budget').digest('hex').slice(0,24);
|
|
start('budget-diagnose',{incident_id:sharedIncident,model_budget_ms:180000});
|
|
now+=75000;coldCreate.resolve();
|
|
await waitFor(()=>events.some(event=>event.request_id==='budget-diagnose'&&event.status==='started'));
|
|
assert.equal(timeouts.at(-1),180000,'cold creation must not consume model budget');
|
|
const budgetSession=events.find(event=>event.request_id==='budget-diagnose'&&event.status==='started').session_id;
|
|
now+=40000;
|
|
sessions.get(budgetSession).rows.push({type:'assistant/message',data:{message:{content:[{type:'text',text:'{"action":"none"}'}]}}});
|
|
sessions.get(budgetSession).idle.resolve();
|
|
await waitFor(()=>terminal('budget-diagnose'));
|
|
nextPrompt=deferred();const reflectAdmission=nextPrompt;
|
|
start('budget-reflect',{incident_id:sharedIncident,phase:'reflect',model_budget_ms:140000});
|
|
await waitFor(()=>events.some(event=>event.request_id==='budget-reflect'&&event.status==='started'));
|
|
assert.equal(timeouts.at(-1),140000,'reflection must consume the remaining shared budget');
|
|
handlers.get('dx/diagnose-cancel')({request_id:'budget-reflect'});
|
|
reflectAdmission.resolve();
|
|
await waitFor(()=>terminal('budget-reflect'));
|
|
|
|
for(const boundary of ['write','rename']){
|
|
publicationFailure=boundary;
|
|
const before=prompts.length,cleanups=publicationCleanup.length,id='snapshot-'+boundary+'-failure';
|
|
start(id);
|
|
await waitFor(()=>terminal(id));
|
|
assert.equal(terminal(id).status,'failed');
|
|
assert.equal(terminal(id).error,'native_diagnosis_failed');
|
|
assert.equal(prompts.length,before,'Snapshot publication failure must not admit a model prompt');
|
|
assert.ok(!events.some(event=>event.request_id===id&&event.status==='started'));
|
|
assert.equal(publicationCleanup.length,cleanups+1,'Failed publication releases its temporary file');
|
|
publicationFailure=null;
|
|
}
|
|
|
|
async function action(revision){
|
|
const req={method:'POST',async *[Symbol.asyncIterator](){yield JSON.stringify({action:'cancel_diagnosis',task_id:'',revision});}};
|
|
const res={status:200,writeHead(code){this.status=code;},end(){},setHeader(){}};
|
|
await routes.get('/dx/action')(req,res);return res.status;
|
|
}
|
|
assert.equal(await action('stale'),409);
|
|
assert.equal(await action('current'),200,'taskless incidents must remain cancellable');
|
|
console.log('PASS native diagnosis cancellation, session isolation, creation race, publication failures and action revision checks');
|