404 lines
12 KiB
TypeScript
404 lines
12 KiB
TypeScript
/**
|
|
* Agentic Readiness Score v2.0
|
|
* Algoritmo basado en metodología de 6 dimensiones con normalización continua
|
|
*/
|
|
|
|
import type { TierKey, SubFactor, AgenticReadinessResult, CustomerSegment } from '../types';
|
|
import { AGENTIC_READINESS_WEIGHTS, AGENTIC_READINESS_THRESHOLDS } from '../constants';
|
|
|
|
export interface AgenticReadinessInput {
|
|
// Datos básicos (SILVER)
|
|
volumen_mes: number;
|
|
aht_values: number[];
|
|
escalation_rate: number;
|
|
cpi_humano: number;
|
|
volumen_anual: number;
|
|
|
|
// Datos avanzados (GOLD)
|
|
structured_fields_pct?: number;
|
|
exception_rate?: number;
|
|
hourly_distribution?: number[];
|
|
off_hours_pct?: number;
|
|
csat_values?: number[];
|
|
motivo_contacto_entropy?: number;
|
|
resolucion_entropy?: number;
|
|
|
|
// Tier
|
|
tier: TierKey;
|
|
}
|
|
|
|
/**
|
|
* SUB-FACTOR 1: REPETITIVIDAD (25%)
|
|
* Basado en volumen mensual con normalización logística
|
|
*/
|
|
function calculateRepetitividadScore(volumen_mes: number): SubFactor {
|
|
const { k, x0 } = AGENTIC_READINESS_THRESHOLDS.repetitividad;
|
|
|
|
// Función logística: score = 10 / (1 + exp(-k * (volumen - x0)))
|
|
const score = 10 / (1 + Math.exp(-k * (volumen_mes - x0)));
|
|
|
|
return {
|
|
name: 'repetitividad',
|
|
displayName: 'Repetitividad',
|
|
score: Math.round(score * 10) / 10,
|
|
weight: AGENTIC_READINESS_WEIGHTS.repetitividad,
|
|
description: `Volumen mensual: ${volumen_mes} interacciones`,
|
|
details: {
|
|
volumen_mes,
|
|
threshold_medio: x0
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* SUB-FACTOR 2: PREDICTIBILIDAD (20%)
|
|
* Basado en variabilidad AHT + tasa de escalación + variabilidad input/output
|
|
*/
|
|
function calculatePredictibilidadScore(
|
|
aht_values: number[],
|
|
escalation_rate: number,
|
|
motivo_contacto_entropy?: number,
|
|
resolucion_entropy?: number
|
|
): SubFactor {
|
|
const thresholds = AGENTIC_READINESS_THRESHOLDS.predictibilidad;
|
|
|
|
// 1. VARIABILIDAD AHT (40%)
|
|
const aht_mean = aht_values.reduce((a, b) => a + b, 0) / aht_values.length;
|
|
const aht_variance = aht_values.reduce((sum, val) => sum + Math.pow(val - aht_mean, 2), 0) / aht_values.length;
|
|
const aht_std = Math.sqrt(aht_variance);
|
|
const cv_aht = aht_std / aht_mean;
|
|
|
|
// Normalizar CV a escala 0-10
|
|
const score_aht = Math.max(0, Math.min(10,
|
|
10 * (1 - (cv_aht - thresholds.cv_aht_excellent) / (thresholds.cv_aht_poor - thresholds.cv_aht_excellent))
|
|
));
|
|
|
|
// 2. TASA DE ESCALACIÓN (30%)
|
|
const score_escalacion = Math.max(0, Math.min(10,
|
|
10 * (1 - escalation_rate / thresholds.escalation_poor)
|
|
));
|
|
|
|
// 3. VARIABILIDAD INPUT/OUTPUT (30%)
|
|
let score_variabilidad: number;
|
|
if (motivo_contacto_entropy !== undefined && resolucion_entropy !== undefined) {
|
|
// Alta entropía input + Baja entropía output = BUENA para automatización
|
|
const input_normalized = Math.min(motivo_contacto_entropy / 3.0, 1.0);
|
|
const output_normalized = Math.min(resolucion_entropy / 3.0, 1.0);
|
|
score_variabilidad = 10 * (input_normalized * (1 - output_normalized));
|
|
} else {
|
|
// Si no hay datos de entropía, usar promedio de AHT y escalación
|
|
score_variabilidad = (score_aht + score_escalacion) / 2;
|
|
}
|
|
|
|
// PONDERACIÓN FINAL
|
|
const predictibilidad = (
|
|
0.40 * score_aht +
|
|
0.30 * score_escalacion +
|
|
0.30 * score_variabilidad
|
|
);
|
|
|
|
return {
|
|
name: 'predictibilidad',
|
|
displayName: 'Predictibilidad',
|
|
score: Math.round(predictibilidad * 10) / 10,
|
|
weight: AGENTIC_READINESS_WEIGHTS.predictibilidad,
|
|
description: `CV AHT: ${(cv_aht * 100).toFixed(1)}%, Escalación: ${(escalation_rate * 100).toFixed(1)}%`,
|
|
details: {
|
|
cv_aht: Math.round(cv_aht * 1000) / 1000,
|
|
escalation_rate,
|
|
score_aht: Math.round(score_aht * 10) / 10,
|
|
score_escalacion: Math.round(score_escalacion * 10) / 10,
|
|
score_variabilidad: Math.round(score_variabilidad * 10) / 10
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* SUB-FACTOR 3: ESTRUCTURACIÓN (15%)
|
|
* Porcentaje de campos estructurados vs texto libre
|
|
*/
|
|
function calculateEstructuracionScore(structured_fields_pct: number): SubFactor {
|
|
const score = structured_fields_pct * 10;
|
|
|
|
return {
|
|
name: 'estructuracion',
|
|
displayName: 'Estructuración',
|
|
score: Math.round(score * 10) / 10,
|
|
weight: AGENTIC_READINESS_WEIGHTS.estructuracion,
|
|
description: `${(structured_fields_pct * 100).toFixed(0)}% de campos estructurados`,
|
|
details: {
|
|
structured_fields_pct
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* SUB-FACTOR 4: COMPLEJIDAD INVERSA (15%)
|
|
* Basado en tasa de excepciones
|
|
*/
|
|
function calculateComplejidadInversaScore(exception_rate: number): SubFactor {
|
|
// Menor tasa de excepciones → Mayor score
|
|
// < 5% → Excelente (score 10)
|
|
// > 30% → Muy complejo (score 0)
|
|
const score_excepciones = Math.max(0, Math.min(10, 10 * (1 - exception_rate / 0.30)));
|
|
|
|
return {
|
|
name: 'complejidad_inversa',
|
|
displayName: 'Complejidad Inversa',
|
|
score: Math.round(score_excepciones * 10) / 10,
|
|
weight: AGENTIC_READINESS_WEIGHTS.complejidad_inversa,
|
|
description: `${(exception_rate * 100).toFixed(1)}% de excepciones`,
|
|
details: {
|
|
exception_rate
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* SUB-FACTOR 5: ESTABILIDAD (10%)
|
|
* Basado en distribución horaria y % llamadas fuera de horas
|
|
*/
|
|
function calculateEstabilidadScore(
|
|
hourly_distribution: number[],
|
|
off_hours_pct: number
|
|
): SubFactor {
|
|
// 1. UNIFORMIDAD DISTRIBUCIÓN HORARIA (60%)
|
|
// Calcular entropía de Shannon
|
|
const total = hourly_distribution.reduce((a, b) => a + b, 0);
|
|
let score_uniformidad = 0;
|
|
let entropy_normalized = 0;
|
|
|
|
if (total > 0) {
|
|
const probs = hourly_distribution.map(v => v / total).filter(p => p > 0);
|
|
const entropy = -probs.reduce((sum, p) => sum + p * Math.log2(p), 0);
|
|
const max_entropy = Math.log2(hourly_distribution.length);
|
|
entropy_normalized = entropy / max_entropy;
|
|
score_uniformidad = entropy_normalized * 10;
|
|
}
|
|
|
|
// 2. % LLAMADAS FUERA DE HORAS (40%)
|
|
// Más llamadas fuera de horas → Mayor necesidad agentes → Mayor score
|
|
const score_off_hours = Math.min(10, (off_hours_pct / 0.30) * 10);
|
|
|
|
// PONDERACIÓN
|
|
const estabilidad = (
|
|
0.60 * score_uniformidad +
|
|
0.40 * score_off_hours
|
|
);
|
|
|
|
return {
|
|
name: 'estabilidad',
|
|
displayName: 'Estabilidad',
|
|
score: Math.round(estabilidad * 10) / 10,
|
|
weight: AGENTIC_READINESS_WEIGHTS.estabilidad,
|
|
description: `${(off_hours_pct * 100).toFixed(1)}% fuera de horario`,
|
|
details: {
|
|
entropy_normalized: Math.round(entropy_normalized * 1000) / 1000,
|
|
off_hours_pct,
|
|
score_uniformidad: Math.round(score_uniformidad * 10) / 10,
|
|
score_off_hours: Math.round(score_off_hours * 10) / 10
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* SUB-FACTOR 6: ROI (15%)
|
|
* Basado en ahorro potencial anual
|
|
*/
|
|
function calculateROIScore(
|
|
volumen_anual: number,
|
|
cpi_humano: number,
|
|
automation_savings_pct: number = 0.70
|
|
): SubFactor {
|
|
const ahorro_anual = volumen_anual * cpi_humano * automation_savings_pct;
|
|
|
|
// Normalización logística
|
|
const { k, x0 } = AGENTIC_READINESS_THRESHOLDS.roi;
|
|
const score = 10 / (1 + Math.exp(-k * (ahorro_anual - x0)));
|
|
|
|
return {
|
|
name: 'roi',
|
|
displayName: 'ROI',
|
|
score: Math.round(score * 10) / 10,
|
|
weight: AGENTIC_READINESS_WEIGHTS.roi,
|
|
description: `€${(ahorro_anual / 1000).toFixed(0)}K ahorro potencial anual`,
|
|
details: {
|
|
ahorro_anual: Math.round(ahorro_anual),
|
|
volumen_anual,
|
|
cpi_humano,
|
|
automation_savings_pct
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* AJUSTE POR DISTRIBUCIÓN CSAT (Opcional, ±10%)
|
|
* Distribución normal → Proceso estable
|
|
*/
|
|
function calculateCSATDistributionAdjustment(csat_values: number[]): number {
|
|
// Test de normalidad simplificado (basado en skewness y kurtosis)
|
|
const n = csat_values.length;
|
|
const mean = csat_values.reduce((a, b) => a + b, 0) / n;
|
|
const variance = csat_values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / n;
|
|
const std = Math.sqrt(variance);
|
|
|
|
// Skewness
|
|
const skewness = csat_values.reduce((sum, val) => sum + Math.pow((val - mean) / std, 3), 0) / n;
|
|
|
|
// Kurtosis
|
|
const kurtosis = csat_values.reduce((sum, val) => sum + Math.pow((val - mean) / std, 4), 0) / n;
|
|
|
|
// Normalidad: skewness cercano a 0, kurtosis cercano a 3
|
|
const skewness_score = Math.max(0, 1 - Math.abs(skewness));
|
|
const kurtosis_score = Math.max(0, 1 - Math.abs(kurtosis - 3) / 3);
|
|
const normality_score = (skewness_score + kurtosis_score) / 2;
|
|
|
|
// Ajuste: +5% si muy normal, -5% si muy anormal
|
|
const adjustment = 1 + ((normality_score - 0.5) * 0.10);
|
|
|
|
return adjustment;
|
|
}
|
|
|
|
/**
|
|
* ALGORITMO COMPLETO (Tier GOLD)
|
|
*/
|
|
export function calculateAgenticReadinessScoreGold(data: AgenticReadinessInput): AgenticReadinessResult {
|
|
const sub_factors: SubFactor[] = [];
|
|
|
|
// 1. REPETITIVIDAD
|
|
sub_factors.push(calculateRepetitividadScore(data.volumen_mes));
|
|
|
|
// 2. PREDICTIBILIDAD
|
|
sub_factors.push(calculatePredictibilidadScore(
|
|
data.aht_values,
|
|
data.escalation_rate,
|
|
data.motivo_contacto_entropy,
|
|
data.resolucion_entropy
|
|
));
|
|
|
|
// 3. ESTRUCTURACIÓN
|
|
sub_factors.push(calculateEstructuracionScore(data.structured_fields_pct || 0.5));
|
|
|
|
// 4. COMPLEJIDAD INVERSA
|
|
sub_factors.push(calculateComplejidadInversaScore(data.exception_rate || 0.15));
|
|
|
|
// 5. ESTABILIDAD
|
|
sub_factors.push(calculateEstabilidadScore(
|
|
data.hourly_distribution || Array(24).fill(1),
|
|
data.off_hours_pct || 0.2
|
|
));
|
|
|
|
// 6. ROI
|
|
sub_factors.push(calculateROIScore(
|
|
data.volumen_anual,
|
|
data.cpi_humano
|
|
));
|
|
|
|
// PONDERACIÓN BASE
|
|
const agentic_readiness_base = sub_factors.reduce(
|
|
(sum, factor) => sum + (factor.score * factor.weight),
|
|
0
|
|
);
|
|
|
|
// AJUSTE POR DISTRIBUCIÓN CSAT (Opcional)
|
|
let agentic_readiness_final = agentic_readiness_base;
|
|
if (data.csat_values && data.csat_values.length > 10) {
|
|
const adjustment = calculateCSATDistributionAdjustment(data.csat_values);
|
|
agentic_readiness_final = agentic_readiness_base * adjustment;
|
|
}
|
|
|
|
// Limitar a rango 0-10
|
|
agentic_readiness_final = Math.max(0, Math.min(10, agentic_readiness_final));
|
|
|
|
// Interpretación
|
|
let interpretation = '';
|
|
let confidence: 'high' | 'medium' | 'low' = 'high';
|
|
|
|
if (agentic_readiness_final >= 8) {
|
|
interpretation = 'Excelente candidato para automatización completa (Automate)';
|
|
} else if (agentic_readiness_final >= 5) {
|
|
interpretation = 'Buen candidato para asistencia agéntica (Assist)';
|
|
} else if (agentic_readiness_final >= 3) {
|
|
interpretation = 'Candidato para augmentación humana (Augment)';
|
|
} else {
|
|
interpretation = 'No recomendado para automatización en este momento';
|
|
}
|
|
|
|
return {
|
|
score: Math.round(agentic_readiness_final * 10) / 10,
|
|
sub_factors,
|
|
tier: 'gold',
|
|
confidence,
|
|
interpretation
|
|
};
|
|
}
|
|
|
|
/**
|
|
* ALGORITMO SIMPLIFICADO (Tier SILVER)
|
|
*/
|
|
export function calculateAgenticReadinessScoreSilver(data: AgenticReadinessInput): AgenticReadinessResult {
|
|
const sub_factors: SubFactor[] = [];
|
|
|
|
// 1. REPETITIVIDAD (30%)
|
|
const repetitividad = calculateRepetitividadScore(data.volumen_mes);
|
|
repetitividad.weight = 0.30;
|
|
sub_factors.push(repetitividad);
|
|
|
|
// 2. PREDICTIBILIDAD SIMPLIFICADA (30%)
|
|
const predictibilidad = calculatePredictibilidadScore(
|
|
data.aht_values,
|
|
data.escalation_rate
|
|
);
|
|
predictibilidad.weight = 0.30;
|
|
sub_factors.push(predictibilidad);
|
|
|
|
// 3. ROI (40%)
|
|
const roi = calculateROIScore(data.volumen_anual, data.cpi_humano);
|
|
roi.weight = 0.40;
|
|
sub_factors.push(roi);
|
|
|
|
// PONDERACIÓN SIMPLIFICADA
|
|
const agentic_readiness = sub_factors.reduce(
|
|
(sum, factor) => sum + (factor.score * factor.weight),
|
|
0
|
|
);
|
|
|
|
// Interpretación
|
|
let interpretation = '';
|
|
if (agentic_readiness >= 7) {
|
|
interpretation = 'Buen candidato para automatización';
|
|
} else if (agentic_readiness >= 4) {
|
|
interpretation = 'Candidato para asistencia agéntica';
|
|
} else {
|
|
interpretation = 'Requiere análisis más profundo (considerar GOLD)';
|
|
}
|
|
|
|
return {
|
|
score: Math.round(agentic_readiness * 10) / 10,
|
|
sub_factors,
|
|
tier: 'silver',
|
|
confidence: 'medium',
|
|
interpretation
|
|
};
|
|
}
|
|
|
|
/**
|
|
* FUNCIÓN PRINCIPAL - Selecciona algoritmo según tier
|
|
*/
|
|
export function calculateAgenticReadinessScore(data: AgenticReadinessInput): AgenticReadinessResult {
|
|
if (data.tier === 'gold') {
|
|
return calculateAgenticReadinessScoreGold(data);
|
|
} else if (data.tier === 'silver') {
|
|
return calculateAgenticReadinessScoreSilver(data);
|
|
} else {
|
|
// BRONZE: Sin Agentic Readiness
|
|
return {
|
|
score: 0,
|
|
sub_factors: [],
|
|
tier: 'bronze',
|
|
confidence: 'low',
|
|
interpretation: 'Análisis Bronze no incluye Agentic Readiness Score'
|
|
};
|
|
}
|
|
}
|