Files
Agent-Workbench/scripts/live-model-observation.mjs
2026-11-03 11:53:07 +08:00

50 lines
3.9 KiB
JavaScript

// Legacy model fields describe the dispatched route, not authenticated model weights.
// Public execution views may contain only the most recent Runs; gaps stay explicit.
export function observedTaskModels(state,taskId=state?.execution?.task?.id){
const execution=state?.execution??{},runs=new Map(),attempts=new Map(),issues=[];
for(const run of [...(execution.runs??[]),execution.run].filter(Boolean)){
if(taskId&&run.taskId===taskId&&typeof run.id==='string')runs.set(run.id,run);
}
const task=execution.task?.id===taskId?execution.task:null;
const validCount=value=>Number.isSafeInteger(value)&&value>=0;
let declared=task&&validCount(task.usage?.requests)?task.usage.requests:null;
if(declared===null&&runs.size&&[...runs.values()].every(run=>validCount(run.usage?.requests)))
declared=[...runs.values()].reduce((total,run)=>total+run.usage.requests,0);
for(const run of runs.values())for(const receipt of run.consumption??[]){
if(typeof receipt.attemptId!=='string'||!receipt.attemptId){issues.push({kind:'missing_attempt_id',runId:run.id});continue;}
const attempt={runId:run.id,attemptId:receipt.attemptId,requestId:receipt.requestId??null,
model:typeof receipt.model==='string'&&receipt.model.trim()?receipt.model:null,
protocol:typeof receipt.protocol==='string'&&receipt.protocol.trim()?receipt.protocol:null,
connectionId:receipt.connectionId??null,outcome:receipt.outcome??null,
requestedModel:receipt.modelIdentity?.requestedModel??receipt.model??null,
modelIdentity:receipt.modelIdentity?structuredClone(receipt.modelIdentity):null,
usageStatus:receipt.usageStatus??'unknown',usage:receipt.usage??null};
const previous=attempts.get(attempt.attemptId);
if(previous){
if(JSON.stringify(previous)!==JSON.stringify(attempt))issues.push({kind:'conflicting_attempt',attemptId:attempt.attemptId,runIds:[previous.runId,run.id]});
continue;
}
attempts.set(attempt.attemptId,attempt);
if(!attempt.model||!attempt.protocol)issues.push({kind:'missing_route_identity',attemptId:attempt.attemptId});
if(attempt.usageStatus==='reported'&&!attempt.usage)issues.push({kind:'missing_reported_usage',attemptId:attempt.attemptId});
}
const observed=[...attempts.values()],models=[...new Set(observed.map(value=>value.model).filter(Boolean))],routes=new Map();
for(const attempt of observed){
const identity={connectionId:attempt.connectionId,model:attempt.model,protocol:attempt.protocol},key=JSON.stringify(identity);
if(!routes.has(key))routes.set(key,{...identity,requests:0,reportedUsageRequests:0,unknownUsageRequests:0});
const route=routes.get(key);route.requests++;
if(attempt.usageStatus==='reported'&&attempt.usage)route.reportedUsageRequests++;else route.unknownUsageRequests++;
}
if(!taskId)issues.push({kind:'missing_task_identity'});
if(declared!==null&&declared!==observed.length)issues.push({kind:'request_coverage_gap',recordedRequests:declared,observedAttempts:observed.length});
const status=issues.length?'incomplete':!observed.length?declared===0?'not_observed':'unavailable':models.length>1?'mixed':'observed';
const identities=observed.map(attempt=>attempt.modelIdentity),identityCounts={};
for(const identity of identities){const key=identity?.status??'historical_unchecked';identityCounts[key]=(identityCounts[key]??0)+1;}
return {schemaVersion:1,source:'task_run_consumption',taskId:taskId??null,status,
identityScope:'request_routes_and_upstream_reported_identifiers_not_model_weights',
responseIdentity:{counts:identityCounts,reportedModels:[...new Set(identities.flatMap(value=>value?.reportedModels??[]))],
allAccepted:observed.length>0&&issues.length===0&&identities.every(value=>value?.complete===true&&['matched','mapped'].includes(value.status))},
model:['observed','mixed'].includes(status)&&models.length===1?models[0]:null,models,
observedAttempts:observed.length,recordedRequests:declared,routes:[...routes.values()],attempts:observed,issues};
}