B2BCall Bootstrap
66cc2058fd
- apps/dialer-worker: motor do discador preditivo completo
- predictive-engine.ts: EWMA de answerProbability/avgTalkTimeSeconds/
abandonRate, previsao de liberacao de agentes, calculo de quantas
chamadas originar. Logica pura, 14 testes unitarios
- cps-limiter.ts: token bucket via script Lua atomico no Redis (dois
buckets independentes campanha+tronco, min() dos dois, seguro com
multiplos workers)
- lead-repository.ts: reserva atomica via FOR UPDATE SKIP LOCKED,
recuperacao de reservas orfas apos queda de worker
- campaign-lock.ts: lock distribuido por campanha (Redis SET NX PX +
token de posse, renovacao/liberacao seguras via Lua)
- schedule.ts: janela de horario da campanha (timezone real via
Intl.DateTimeFormat, dias da semana), 6 testes unitarios
- retry-rules.ts: motor de retentativa por causa de encerramento,
configuravel por campanha, nunca infinito
- simulation.ts + campaign-worker.ts (modo DIALER_SIMULATION): permite
testar o motor inteiro sem tronco de operadora real
- simulation-harness.ts: reproduz em tempo discreto e deterministico o
cenario exato de aceite da secao 66 (20 agentes/10 CPS/30% atendimento/
TMA 180s) — 6 testes validando CPS nunca excedido, concorrencia nunca
excedida, pacing nao diverge
- campaign-worker.ts: orquestra tudo contra Postgres/Redis/Asterisk reais
- docs/PREDICTIVE_DIALER.md: algoritmo documentado, incluindo dois bugs
reais encontrados e corrigidos durante o teste do cenario de aceite
(concorrencia nao contava chamadas em atendimento; pacing subia sem
limite durante periodos ociosos, causando rajada maxima assim que um
agente ficava livre) e limitacoes conhecidas (AMD e wrap-up automatico
via eventos reais ainda pendentes, documentados sem esconder)
Testado ponta a ponta contra containers reais (Postgres/Redis/Asterisk):
campanha completa criada -> agente disponivel via API -> leads importados
-> campanha iniciada -> reserva atomica -> CPS respeitado -> simulacao de
NO_ANSWER (retry agendado) e ANSWERED (AGENT_CONNECTED, EWMA atualizada ao
vivo) -> parada sem derrubar chamadas em andamento.
45 lines
1.7 KiB
TypeScript
45 lines
1.7 KiB
TypeScript
import { PrismaClient } from '@b2bcall/database';
|
|
import { estimateAgentsFreeingSoon, type LiveCounts } from './predictive-engine';
|
|
|
|
/**
|
|
* Consulta o estado real (Postgres) para montar o LiveCounts que o motor
|
|
* preditivo usa a cada tick. Nunca lê do Asterisk diretamente — o Asterisk
|
|
* não é fonte de verdade de negócio (agente.md seção 97).
|
|
*/
|
|
export async function getLiveCounts(
|
|
prisma: PrismaClient,
|
|
campaignId: string,
|
|
queueId: string,
|
|
avgTalkTimeSeconds: number,
|
|
): Promise<LiveCounts> {
|
|
const members = await prisma.queueMember.findMany({ where: { queueId }, select: { agentId: true } });
|
|
const agentIds = members.map((m) => m.agentId);
|
|
|
|
const openStates = agentIds.length
|
|
? await prisma.agentStateEvent.findMany({
|
|
where: { agentId: { in: agentIds }, endedAt: null },
|
|
select: { agentId: true, state: true, startedAt: true },
|
|
})
|
|
: [];
|
|
|
|
const availableAgents = openStates.filter((s) => s.state === 'AVAILABLE').length;
|
|
const inCallStartedAt = openStates.filter((s) => s.state === 'IN_CALL').map((s) => s.startedAt);
|
|
const agentsLikelyToFreeSoon = estimateAgentsFreeingSoon(inCallStartedAt, avgTalkTimeSeconds, 15);
|
|
|
|
const [dialingCalls, ringingCalls, connectedWaitingAgent, agentConnectedCalls] = await Promise.all([
|
|
prisma.dialAttempt.count({ where: { campaignId, state: 'ORIGINATING' } }),
|
|
prisma.dialAttempt.count({ where: { campaignId, state: 'RINGING' } }),
|
|
prisma.dialAttempt.count({ where: { campaignId, state: 'QUEUED' } }),
|
|
prisma.dialAttempt.count({ where: { campaignId, state: 'AGENT_CONNECTED' } }),
|
|
]);
|
|
|
|
return {
|
|
availableAgents,
|
|
agentsLikelyToFreeSoon,
|
|
dialingCalls,
|
|
ringingCalls,
|
|
connectedWaitingAgent,
|
|
agentConnectedCalls,
|
|
};
|
|
}
|