// 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};
}
