cdp-edge 2.2.5 → 2.3.1

package/server-edge-tracker/modules/ml/{ltv.js → ltv.ts}

@@ -4,11 +4,55 @@
  */
 
 import { extractFeatures, predictWithWeights, loadActiveWeights } from './logistic.js';
+import { Env, TrackPayload } from '../../types.js';
+
+// ── Tipos ───────────────────────────────────────────────────────────────────────
+export interface LtvResult {
+  score: number;
+  class: string;
+  value: number;
+  source?: string;
+}
+
+export interface AbVariation {
+  id: number;
+  test_id: number;
+  name: string;
+  system_prompt: string;
+  weight: number;
+  is_control: number;
+  total_assigned?: number;
+  accuracy_score?: number;
+}
+
+export interface AbTestCreate {
+  name: string;
+  description?: string;
+  min_sample?: number;
+  variations: Array<{
+    name: string;
+    system_prompt?: string;
+    weight?: number;
+    is_control?: boolean;
+  }>;
+}
+
+export interface AutoDecideResult {
+  decided: boolean;
+  reason?: string;
+  test_id?: number;
+  test_name?: string;
+  winner_id?: number;
+  winner_name?: string;
+  improvement?: string;
+  is_control_winner?: boolean;
+  winning_prompt?: string;
+}
 
 // Cache key para o teste ativo (KV — evita hit no D1 a cada request /track)
 const AB_LTV_CACHE_KEY = 'ab_ltv_active_test';
 
-// ── Prompt especializado para imóveis ────────────────────────────────────────
+// ── Prompt especializado para imóveis ───────────────────────────────────────
 // Ativado automaticamente quando property_lat/lng estão presentes no payload.
 // Override por A/B test tem prioridade sobre este prompt.
 const REAL_ESTATE_PROMPT = `You are a real estate lead scoring expert for the Brazilian market.
@@ -26,7 +70,7 @@ Scoring rules (apply additively):
 No explanation. JSON only.`;
 
 // ── predictLtv — Heurística em 5 dimensões (0-100 pts) ───────────────────────
-export async function predictLtv(env, payload, request, customSystemPrompt = null) {
+export async function predictLtv(env: Env, payload: TrackPayload, request: Request | null, customSystemPrompt: string | null = null): Promise<LtvResult> {
   // ── Tentar modelo treinado (regressão logística real) ─────────────────────
   // Se existir modelo ativo no KV/D1, usa-o em vez da heurística manual.
   // Fallback automático para heurística se modelo não disponível.
@@ -34,10 +78,10 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
     const model = await loadActiveWeights(env);
     if (model?.weights?.length) {
       const hour    = new Date().getUTCHours();
-      const country = (payload.country || request?.cf?.country || '').toUpperCase();
+      const country = (payload.country || (request as any)?.cf?.country || '').toUpperCase();
       const features = extractFeatures({
         utm_source:      payload.utmSource,
-        engagement_score: parseFloat(payload.engagementScore || 0),
+        engagement_score: parseFloat(String(payload.engagementScore || '0')),
         intention_level: payload.intentionLevel,
         days_since_lead: 0,  // evento atual = recência máxima
         has_email:       !!payload.email,
@@ -49,7 +93,7 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
       const score100 = predictWithWeights(model, features);
       const ltvClass    = score100 >= 70 ? 'High' : score100 >= 40 ? 'Medium' : 'Low';
       const ltvMultiplier = score100 >= 70 ? 3.5 : score100 >= 40 ? 1.8 : 0.8;
-      const productValue  = payload.value ? parseFloat(payload.value) : 0;
+      const productValue  = payload.value ? parseFloat(String(payload.value)) : 0;
       const baseValue     = productValue > 0 ? productValue : 197;
       const predictedValue = Math.round(baseValue * ltvMultiplier * 100) / 100;
 
@@ -60,14 +104,14 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
   let score = 0;
 
   // 1. Engajamento browser (0–30)
-  const engScore  = parseFloat(payload.engagementScore || 0);
-  const userScore = parseFloat(payload.userScore || 0);
+  const engScore  = parseFloat(String(payload.engagementScore || '0'));
+  const userScore = parseFloat(String((payload as any).userScore || '0'));
   score += Math.min(15, Math.round((engScore / 5) * 15));
   score += Math.min(15, Math.round((userScore / 100) * 15));
 
   // 2. Origem de tráfego (0–25)
   const src = (payload.utmSource || '').toLowerCase();
-  const utm_score_map = {
+  const utm_score_map: Record<string, number> = {
     facebook: 25, instagram: 25, meta: 25,
     google: 22, youtube: 22, tiktok: 20,
     email: 18, sms: 18,
@@ -77,8 +121,8 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
 
   // 3. Contexto de rede (0–15)
   const hour    = new Date().getUTCHours();
-  const country = (payload.country || request.cf?.country || '').toUpperCase();
-  const org     = String(request.cf?.asOrganization || '').toLowerCase();
+  const country = (payload.country || (request as any)?.cf?.country || '').toUpperCase();
+  const org     = String((request as any).cf?.asOrganization || '').toLowerCase();
 
   const isHighConvTime = hour >= 21 || hour <= 2;
   score += isHighConvTime ? 8 : (hour >= 12 && hour <= 20 ? 4 : 1);
@@ -101,27 +145,28 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
   if (payload.firstName) score += 2;
 
   // 5b. Tipo de evento imobiliário (0–15) — sinais de intenção de compra física
-  const evType = (payload.eventType || '').toLowerCase();
+  const evType = ((payload as any).eventType || '').toLowerCase();
   if (evType === 'customizeproduct') score += 15; // simulação de financiamento → intenção máxima
   else if (evType === 'findlocation')  score += 10; // viu mapa/localização → visita física iminente
   else if (evType === 'addtowishlist') score += 8;  // favoritou → interesse persistente
 
   // 6. Proximidade ao imóvel físico (0–15) — apenas quando distância calculada
-  const distKm = parseFloat(payload.distanceKm ?? payload.user_distance_km ?? -1);
+  const distKm = parseFloat(String(payload.distanceKm || (payload as any).user_distance_km || '-1'));
   if (distKm >= 0) {
-    if      (distKm <  5)  score += 15;
-    else if (distKm < 15)  score += 10;
-    else if (distKm < 30)  score += 6;
-    else if (distKm < 60)  score += 3;
+    if      (distKm < 5)  score += 15;
+    else if (distKm < 15) score += 10;
+    else if (distKm < 30) score += 6;
+    else if (distKm < 60) score += 3;
     // > 60km: sem bônus — lead distante precisa de argumento diferente
-  } else if (payload.property_lat || payload.propertyLat) {
+  } else if (payload.property_lat || (payload as any).propertyLat) {
     // Coords no payload mas distância não resolvida: pequeno bônus por intenção de rota
     score += 3;
   }
 
   score = Math.min(100, score);
 
-  let ltvClass, ltvMultiplier;
+  let ltvClass: string;
+  let ltvMultiplier: number;
   if (score >= 70) {
     ltvClass = 'High';   ltvMultiplier = 3.5;
   } else if (score >= 40) {
@@ -130,7 +175,7 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
     ltvClass = 'Low';    ltvMultiplier = 0.8;
   }
 
-  const productValue   = payload.value ? parseFloat(payload.value) : 0;
+  const productValue   = payload.value ? parseFloat(String(payload.value)) : 0;
   const baseValue      = productValue > 0 ? productValue : 197;
   const predictedValue = Math.round(baseValue * ltvMultiplier * 100) / 100;
 
@@ -138,16 +183,16 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
   let aiAdjustment = 0;
   if (env.AI && score >= 40) {
     try {
-      const isRealEstate = !!(payload.property_lat || payload.propertyLat);
+      const isRealEstate = !!(payload.property_lat || (payload as any).propertyLat);
       const systemContent = customSystemPrompt ||
         (isRealEstate
           ? REAL_ESTATE_PROMPT
           : 'You are a conversion rate expert. Reply ONLY with a JSON object {"adjustment": <number between -10 and 10>} based on the lead data provided. No explanation.');
 
-      const userContext = {
-        utm_source:  payload.utmSource,
-        intention:   intentionLevel,
-        engagement:  engScore,
+      const userContext: Record<string, any> = {
+        utm_source: payload.utmSource,
+        intention: intentionLevel,
+        engagement: engScore,
         hour_utc:    hour,
         country,
         has_email:   !!payload.email,
@@ -155,11 +200,11 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
       };
       if (isRealEstate) {
         userContext.event_type     = 'real_estate_schedule';
-        userContext.distance_km    = payload.distanceKm ?? payload.user_distance_km ?? 'unknown';
-        userContext.distance_bucket = payload.distanceBucket ?? 'unknown';
-        userContext.scroll_score   = payload.scrollScore || payload.scroll_score || 0;
-        userContext.time_level     = payload.timeLevel || payload.time_level || 'unknown';
-        userContext.intent_score   = payload.intent_score || 'high';
+        userContext.distance_km    = payload.distanceKm || (payload as any).user_distance_km || 'unknown';
+        userContext.distance_bucket = payload.distanceBucket || 'unknown';
+        userContext.scroll_score   = payload.scrollScore || (payload as any).scroll_score || 0;
+        userContext.time_level     = payload.timeLevel || (payload as any).timeLevel || 'unknown';
+        userContext.intent_score   = payload.intentScoreNum || payload.intent_score || 'high';
         userContext.hour_brt       = (hour - 3 + 24) % 24; // UTC-3 aproximado
       }
 
@@ -168,7 +213,7 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
         { role: 'user', content: JSON.stringify(userContext) },
       ];
       const aiRes = await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', { messages: prompt, max_tokens: 32 });
-      const parsed = JSON.parse(aiRes.response.trim());
+      const parsed = JSON.parse((aiRes as any).response.trim());
       if (typeof parsed.adjustment === 'number') {
         aiAdjustment = Math.max(-10, Math.min(10, parsed.adjustment));
       }
@@ -183,13 +228,13 @@ export async function predictLtv(env, payload, request, customSystemPrompt = nul
 }
 
 // ── getLtvAbVariation — busca variação ativa do A/B test ─────────────────────
-export async function getLtvAbVariation(env) {
+export async function getLtvAbVariation(env: Env): Promise<AbVariation | null> {
   if (!env.DB) return null;
 
   try {
-    let testData = null;
+    let testData: any = null;
     if (env.GEO_CACHE) {
-      const cached = await env.GEO_CACHE.get(AB_LTV_CACHE_KEY, 'json');
+      const cached = await env.GEO_CACHE.get(AB_LTV_CACHE_KEY, 'json') as any;
       if (cached) testData = cached;
     }
 
@@ -214,7 +259,7 @@ export async function getLtvAbVariation(env) {
 
     if (!testData || testData.length === 0) return null;
 
-    const totalWeight = testData.reduce((s, v) => s + (v.weight || 0.5), 0);
+    const totalWeight = testData.reduce((s: number, v: AbVariation) => s + (v.weight || 0.5), 0);
     let rand = Math.random() * totalWeight;
     for (const variation of testData) {
       rand -= (variation.weight || 0.5);
@@ -222,14 +267,14 @@ export async function getLtvAbVariation(env) {
     }
     return testData[testData.length - 1];
 
-  } catch (err) {
-    console.error('[AB-LTV] getLtvAbVariation error:', err.message);
+  } catch (err: any) {
+    console.error('[AB-LTV] getLtvAbVariation error:', err?.message || String(err));
     return null;
   }
 }
 
 // ── recordAbAssignment — registra variação usada para um lead ─────────────────
-export async function recordAbAssignment(env, userId, variationId, testId, predictedLtv, predictedClass, emailHash) {
+export async function recordAbAssignment(env: Env, userId: string, variationId: number, testId: number, predictedLtv: number | null, predictedClass: string | null, emailHash: string | null): Promise<void> {
   if (!env.DB) return;
   try {
     await env.DB.prepare(`
@@ -238,17 +283,17 @@ export async function recordAbAssignment(env, userId, variationId, testId, predi
     `).bind(testId, variationId, userId, emailHash || null, predictedLtv || null, predictedClass || null).run();
 
     await env.DB.prepare(`UPDATE ltv_ab_variations SET total_assigned = total_assigned + 1 WHERE id = ?`).bind(variationId).run();
-  } catch (err) {
-    console.error('[AB-LTV] recordAbAssignment error:', err.message);
+  } catch (err: any) {
+    console.error('[AB-LTV] recordAbAssignment error:', err?.message || String(err));
   }
 }
 
 // ── POST /api/ltv/ab-test/create ─────────────────────────────────────────────
-export async function handleLtvAbTestCreate(env, request, headers) {
+export async function handleLtvAbTestCreate(env: Env, request: Request, headers: Headers): Promise<Response> {
   if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
 
-  let body;
-  try { body = await request.json(); }
+  let body: AbTestCreate;
+  try { body = await request.json() as AbTestCreate; }
   catch { return new Response(JSON.stringify({ error: 'JSON inválido no body' }), { status: 400, headers }); }
 
   const { name, description, min_sample = 100, variations } = body;
@@ -259,7 +304,7 @@ export async function handleLtvAbTestCreate(env, request, headers) {
 
   const running = await env.DB.prepare(`SELECT id FROM ltv_ab_tests WHERE status = 'running' LIMIT 1`).first();
   if (running) {
-    return new Response(JSON.stringify({ error: 'Já existe um teste em andamento.', running_test_id: running.id }), { status: 409, headers });
+    return new Response(JSON.stringify({ error: 'Já existe um teste em andamento.', running_test_id: (running as any).id }), { status: 409, headers });
   }
 
   try {
@@ -276,28 +321,28 @@ export async function handleLtvAbTestCreate(env, request, headers) {
       INSERT INTO ltv_ab_tests (name, description, status, min_sample, created_at) VALUES (?, ?, 'running', ?, ?)
     `).bind(name, description || null, min_sample, now).run();
 
-    const testId = testRes.meta?.last_row_id;
+    const testId = (testRes as any).meta?.last_row_id;
     if (!testId) throw new Error('Falha ao criar o teste no D1');
 
-    const createdVariations = [];
+    const createdVariations: Array<{ id: number; name: string; weight: number; is_control: boolean }> = [];
     for (const v of variations) {
       const vRes = await env.DB.prepare(`
         INSERT INTO ltv_ab_variations (test_id, name, system_prompt, weight, is_control, created_at) VALUES (?, ?, ?, ?, ?, ?)
       `).bind(testId, v.name, v.system_prompt, v.weight || 0.5, v.is_control ? 1 : 0, now).run();
-      createdVariations.push({ id: vRes.meta?.last_row_id, name: v.name, weight: v.weight, is_control: !!v.is_control });
+      createdVariations.push({ id: (vRes as any).meta?.last_row_id, name: v.name, weight: v.weight || 0.5, is_control: !!v.is_control });
     }
 
     if (env.GEO_CACHE) await env.GEO_CACHE.delete(AB_LTV_CACHE_KEY);
 
     return new Response(JSON.stringify({ success: true, test_id: testId, name, status: 'running', min_sample, variations: createdVariations, started_at: now }), { status: 201, headers });
-  } catch (err) {
-    console.error('[AB-LTV] create error:', err.message);
-    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  } catch (err: any) {
+    console.error('[AB-LTV] create error:', err?.message || String(err));
+    return new Response(JSON.stringify({ error: err?.message || String(err) }), { status: 500, headers });
   }
 }
 
 // ── GET /api/ltv/ab-test/list ─────────────────────────────────────────────────
-export async function handleLtvAbTestList(env, request, headers) {
+export async function handleLtvAbTestList(env: Env, request: Request, headers: Headers): Promise<Response> {
   if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
 
   const url    = new URL(request.url);
@@ -306,7 +351,7 @@ export async function handleLtvAbTestList(env, request, headers) {
 
   try {
     const cond     = status ? 'WHERE t.status = ?' : '';
-    const bindings = status ? [status, limit] : [limit];
+    const bindings: (string | number)[] = status ? [status, limit] : [limit];
 
     const tests = await env.DB.prepare(`
       SELECT t.id, t.name, t.description, t.status, t.winner_id,
@@ -322,14 +367,14 @@ export async function handleLtvAbTestList(env, request, headers) {
     `).bind(...bindings).all();
 
     return new Response(JSON.stringify({ success: true, total: (tests.results || []).length, tests: tests.results || [] }), { status: 200, headers });
-  } catch (err) {
-    console.error('[AB-LTV] list error:', err.message);
-    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  } catch (err: any) {
+    console.error('[AB-LTV] list error:', err?.message || String(err));
+    return new Response(JSON.stringify({ error: err?.message || String(err) }), { status: 500, headers });
   }
 }
 
 // ── GET /api/ltv/ab-test/results ─────────────────────────────────────────────
-export async function handleLtvAbTestResults(env, request, headers) {
+export async function handleLtvAbTestResults(env: Env, request: Request, headers: Headers): Promise<Response> {
   if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
 
   const url    = new URL(request.url);
@@ -342,15 +387,15 @@ export async function handleLtvAbTestResults(env, request, headers) {
     const testRes = await env.DB.prepare(`SELECT id, name, status, min_sample, winner_id, started_at FROM ltv_ab_tests ${cond} LIMIT 1`).bind(...testBind).first();
     if (!testRes) return new Response(JSON.stringify({ error: 'Nenhum teste encontrado' }), { status: 404, headers });
 
-    const perf = await env.DB.prepare(`SELECT * FROM v_ab_test_performance WHERE test_id = ?`).bind(testRes.id).all();
+    const perf = await env.DB.prepare(`SELECT * FROM v_ab_test_performance WHERE test_id = ?`).bind((testRes as any).id).all();
     const variations = perf.results || [];
-    const ready      = variations.every(v => (v.total_assigned || 0) >= testRes.min_sample);
-    let recommendation = null;
+    const ready      = variations.every((v: any) => (v.total_assigned || 0) >= (testRes as any).min_sample);
+    let recommendation: any = null;
 
     if (ready && variations.length > 0) {
-      const best = variations.reduce((a, b) => (b.accuracy_score || 0) > (a.accuracy_score || 0) ? b : a);
-      const control = variations.find(v => v.is_control);
-      const improvement = control ? ((best.accuracy_score || 0) - (control.accuracy_score || 0)) * 100 : null;
+      const best = variations.reduce((a: any, b: any) => (Number(b.accuracy_score) || 0) > (Number(a.accuracy_score) || 0) ? b : a);
+      const control = variations.find((v: any) => v.is_control);
+      const improvement = control ? ((Number(best.accuracy_score) || 0) - (Number(control.accuracy_score) || 0)) * 100 : null;
       recommendation = {
         winner_variation_id: best.variation_id, winner_variation_name: best.variation_name,
         accuracy_score: best.accuracy_score, improvement_vs_control: improvement ? `+${improvement.toFixed(1)}%` : null,
@@ -360,20 +405,20 @@ export async function handleLtvAbTestResults(env, request, headers) {
 
     return new Response(JSON.stringify({
       success: true,
-      test: { id: testRes.id, name: testRes.name, status: testRes.status, min_sample: testRes.min_sample, started_at: testRes.started_at, is_ready: ready },
+      test: { id: (testRes as any).id, name: (testRes as any).name, status: (testRes as any).status, min_sample: (testRes as any).min_sample, started_at: (testRes as any).started_at, is_ready: ready },
       variations, recommendation,
     }), { status: 200, headers });
-  } catch (err) {
-    console.error('[AB-LTV] results error:', err.message);
-    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  } catch (err: any) {
+    console.error('[AB-LTV] results error:', err?.message || String(err));
+    return new Response(JSON.stringify({ error: err?.message || String(err) }), { status: 500, headers });
   }
 }
 
 // ── POST /api/ltv/ab-test/winner ──────────────────────────────────────────────
-export async function handleLtvAbTestWinner(env, request, headers) {
+export async function handleLtvAbTestWinner(env: Env, request: Request, headers: Headers): Promise<Response> {
   if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
 
-  let body;
+  let body: any;
   try { body = await request.json(); }
   catch { return new Response(JSON.stringify({ error: 'JSON inválido' }), { status: 400, headers }); }
 
@@ -390,22 +435,22 @@ export async function handleLtvAbTestWinner(env, request, headers) {
     if (env.GEO_CACHE) await env.GEO_CACHE.delete(AB_LTV_CACHE_KEY);
 
     return new Response(JSON.stringify({
-      success: true, test_id, winner_variation_id: variation_id, winner_name: variation.name,
-      is_control: variation.is_control === 1, winning_prompt: variation.system_prompt,
-      message: variation.is_control === 1
+      success: true, test_id, winner_variation_id: variation_id, winner_name: (variation as any).name,
+      is_control: (variation as any).is_control === 1, winning_prompt: (variation as any).system_prompt,
+      message: (variation as any).is_control === 1
         ? 'O prompt original (controle) venceu. Nenhuma alteração necessária.'
         : 'Novo prompt vencedor identificado. Copie o campo winning_prompt e aplique ao predictLtv() como novo default.',
     }), { status: 200, headers });
-  } catch (err) {
-    console.error('[AB-LTV] winner error:', err.message);
-    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  } catch (err: any) {
+    console.error('[AB-LTV] winner error:', err?.message || String(err));
+    return new Response(JSON.stringify({ error: err?.message || String(err) }), { status: 500, headers });
   }
 }
 
 // ── autoDecideAbWinner — declara winner automaticamente via cron ──────────────
 // Critério: todas as variações com amostra >= min_sample
 //           E diferença de accuracy_score >= 5pp entre melhor e controle
-export async function autoDecideAbWinner(env) {
+export async function autoDecideAbWinner(env: Env): Promise<AutoDecideResult> {
   if (!env.DB) return { decided: false, reason: 'no_db' };
 
   try {
@@ -419,24 +464,24 @@ export async function autoDecideAbWinner(env) {
     // Buscar performance das variações
     const perf = await env.DB.prepare(
       `SELECT * FROM v_ab_test_performance WHERE test_id = ?`
-    ).bind(test.id).all();
+    ).bind((test as any).id).all();
 
     const variations = perf.results || [];
     if (variations.length < 2) return { decided: false, reason: 'insufficient_variations' };
 
     // Verificar se todas têm amostra suficiente
-    const allReady = variations.every(v => (v.total_assigned || 0) >= test.min_sample);
+    const allReady = variations.every((v: any) => (v.total_assigned || 0) >= (test as any).min_sample);
     if (!allReady) {
-      const minAssigned = Math.min(...variations.map(v => v.total_assigned || 0));
-      return { decided: false, reason: `sample_insufficient (${minAssigned}/${test.min_sample})` };
+      const minAssigned = Math.min(...variations.map((v: any) => v.total_assigned || 0));
+      return { decided: false, reason: `sample_insufficient (${minAssigned}/${(test as any).min_sample})` };
     }
 
     // Encontrar melhor e controle
-    const best    = variations.reduce((a, b) => (b.accuracy_score || 0) > (a.accuracy_score || 0) ? b : a);
-    const control = variations.find(v => v.is_control) || variations[0];
+    const best    = variations.reduce((a: any, b: any) => (b.accuracy_score || 0) > (a.accuracy_score || 0) ? b : a);
+    const control = variations.find((v: any) => v.is_control) || variations[0];
 
-    const bestScore    = parseFloat(best.accuracy_score    || 0);
-    const controlScore = parseFloat(control.accuracy_score || 0);
+    const bestScore    = parseFloat(String(best.accuracy_score)    || '0');
+    const controlScore = parseFloat(String(control.accuracy_score) || '0');
     const diff         = bestScore - controlScore;
 
     // Empate técnico → controle vence (determinístico)
@@ -455,17 +500,17 @@ export async function autoDecideAbWinner(env) {
 
     return {
       decided:       true,
-      test_id:       test.id,
-      test_name:     test.name,
-      winner_id:     best.variation_id,
-      winner_name:   best.variation_name,
+      test_id:       (test as any).id,
+      test_name:     (test as any).name,
+      winner_id:     typeof best.variation_id === 'number' ? best.variation_id : undefined,
+      winner_name:   typeof best.variation_name === 'string' ? best.variation_name : undefined,
       improvement:   `+${(diff * 100).toFixed(1)}pp`,
       is_control_winner: best.variation_id === control.variation_id,
-      winning_prompt: best.system_prompt || null,
+      winning_prompt: String(best.system_prompt || ''),
     };
 
-  } catch (err) {
-    console.error('[AB-LTV] autoDecide error:', err.message);
-    return { decided: false, reason: err.message };
+  } catch (err: any) {
+    console.error('[AB-LTV] autoDecide error:', err?.message || String(err));
+    return { decided: false, reason: err?.message || String(err) };
   }
 }