Structured outputs, tool calling, erros

import assert from "node:assert/strict";
const pedidos=new Map([["p7",{dono:"u1",valor:100}],["p8",{dono:"u1",valor:60}]]);
const intencoes=new Map();
const logs=[];
let efeitos=0;
function falhar(codigo){throw Object.assign(new Error(codigo),{codigo});}
function autorizar(contexto,pedidoId){
  const pedido=pedidos.get(pedidoId);
  if(!pedido||pedido.dono!==contexto.usuario) falhar("SEM_PERMISSAO");
  return pedido;
}
function normalizar(payload){
  if(typeof payload.pedidoId!=="string" || !Number.isSafeInteger(payload.valor) || payload.valor<=0)
    falhar("SCHEMA_INVALIDO");
  return JSON.stringify({pedidoId:payload.pedidoId,valor:payload.valor});
}
function consultarIntencao(chave,contexto){
  const registro=intencoes.get(chave);
  if(!registro) return {status:"nao_enviado"};
  autorizar(contexto,registro.pedidoId);
  if(registro.usuario!==contexto.usuario) falhar("SEM_PERMISSAO");
  return registro.resultado??{status:"pendente"};
}
function emitir(chave,payload,contexto,{perderResposta=false}={}){
  const normalizado=normalizar(payload);
  const pedido=autorizar(contexto,payload.pedidoId);
  // A mesma intenção usa chave derivada do usuário e do pedido.
  const chaveEsperada="reembolso:"+contexto.usuario+":"+payload.pedidoId;
  if(chave!==chaveEsperada) falhar("CHAVE_INCOMPATIVEL");
  const anterior=intencoes.get(chave);
  if(anterior){
    if(anterior.usuario!==contexto.usuario||anterior.payload!==normalizado)
      falhar("PAYLOAD_INCOMPATIVEL");
    return anterior.resultado;
  }
  if(payload.valor!==pedido.valor) falhar("VALOR_NAO_AUTORIZADO");
  // Simulação síncrona: intenção e recibo estão no mesmo processo.
  const registro={usuario:contexto.usuario,pedidoId:payload.pedidoId,payload:normalizado};
  intencoes.set(chave,registro);
  efeitos++;
  registro.resultado={status:"emitido",pedidoId:payload.pedidoId,recibo:"r"+efeitos};
  logs.push({etapa:"emissao",codigo:"CONFIRMADO",recibo:registro.resultado.recibo});
  if(perderResposta) falhar("RESPOSTA_PERDIDA");
  return registro.resultado;
}
function executarComRecuperacao(chave,payload,contexto,opcoes){
  try {return emitir(chave,payload,contexto,opcoes);}
  catch(erro){
    if(erro.codigo!=="RESPOSTA_PERDIDA") throw erro;
    // Reconciliar antes de qualquer nova tentativa de efeito.
    logs.push({etapa:"reconciliacao",codigo:"CONSULTA_DE_ESTADO"});
    const resultado=consultarIntencao(chave,contexto);
    if(resultado.status!=="emitido") falhar("RESULTADO_DESCONHECIDO");
    return resultado;
  }
}
function validarClassificacao(objeto){
  const categorias=["financeiro","acesso","revisao"];
  const prioridades=["normal","alta"];
  if(!categorias.includes(objeto.categoria)||!prioridades.includes(objeto.prioridade)||
     typeof objeto.resumo!=="string"||typeof objeto.acaoRecomendada!=="string")
    falhar("CLASSIFICACAO_INVALIDA");
  return objeto;
}
// Fallback somente nesta operação sem efeito. Cada fornecedor é um mock local.
function classificarComFallback(provedores,maxTentativas=2){
  let ultimo;
  for(let i=0;i<Math.min(maxTentativas,provedores.length);i++){
    try {return {dados:validarClassificacao(provedores[i]()),tentativas:i+1};}
    catch(erro){ultimo=erro;logs.push({etapa:"classificacao",tentativa:i+1,codigo:erro.codigo});}
  }
  throw ultimo??new Error("Nenhum provedor disponível");
}
const contexto={usuario:"u1"};
const p7={pedidoId:"p7",valor:100};
const chave7="reembolso:u1:p7";
const primeiro=emitir(chave7,p7,contexto);
assert.deepEqual(emitir(chave7,p7,contexto),primeiro);
assert.equal(efeitos,1);
assert.throws(()=>emitir(chave7,p7,{usuario:"u2"}),/SEM_PERMISSAO/);
assert.throws(()=>emitir(chave7,{pedidoId:"p7",valor:90},contexto),/PAYLOAD_INCOMPATIVEL/);
assert.throws(()=>emitir("outra-chave",p7,contexto),/CHAVE_INCOMPATIVEL/);
assert.throws(()=>emitir(chave7,{pedidoId:"p7",valor:"100"},contexto),/SCHEMA_INVALIDO/);
const recuperado=executarComRecuperacao("reembolso:u1:p8",{pedidoId:"p8",valor:60},
  contexto,{perderResposta:true});
assert.equal(recuperado.status,"emitido");
assert.equal(efeitos,2);
assert.deepEqual(emitir("reembolso:u1:p8",{pedidoId:"p8",valor:60},contexto),recuperado);
assert.equal(efeitos,2);
const fornecedores=[()=>falhar("TEMPORARIO"),()=>({categoria:"financeiro",prioridade:"normal",
  resumo:"Cliente pede revisão",acaoRecomendada:"Consultar elegibilidade"})];
assert.equal(classificarComFallback(fornecedores,2).tentativas,2);
assert.throws(()=>classificarComFallback(fornecedores,1),/TEMPORARIO/);
assert.ok(logs.some(x=>x.etapa==="reconciliacao"));
console.log({status:"aprovado",efeitos,intencoes:intencoes.size,logs});