@runnerpro/backend 1.19.7 → 1.19.9

package/lib/cjs/prompt/ai.js

@@ -16,7 +16,23 @@ const modelPricing_1 = require("./modelPricing");
 const constants_1 = require("./constants");
 const googleModel_1 = require("./googleModel");
 const bedrockModel_1 = require("./bedrockModel");
+const slack_1 = require("../slack");
 const MIN_RETRIES = 1;
+// ✅ Detección de Chain-of-Thought (CoT) que se cuela en la respuesta final del modelo
+const COT_HTML_TAG = /<\/?(thinking|thought|reasoning)\b/i;
+const COT_STRONG_TAG = /(^|\n)\s*(thought|thinking|reasoning|chain[- ]of[- ]thought|final answer|let me think)\s*[:\n]/i;
+const COT_META_BULLET = /^\s*\*\s+\*[A-Z][^*\n]{1,40}\*/gm;
+const COT_META_PATTERNS = [
+    /\battempt\s*\d+\b/i,
+    /\bcritique\s*\d+\b/i,
+    /\bself[- ]correction\b/i,
+    /\b(refining|refined|final polish|final version|final check|revised (draft|version))\b/i,
+    /\bword count(\s*check)?\b/i,
+    /\blet'?s (check|see|count|verify|recount)\b/i,
+    /\b(okay|wait|actually|hmm),?\s+(let|so|now|the|i|that|maybe)\b/i,
+];
+const COT_ENGLISH_FUNCTION_WORDS = /\b(the|and|with|that|this|would|should|because|let'?s|we'?ll|maybe|okay)\b/gi;
+const COT_SCORE_THRESHOLD = 3;
 const costTrackingStorage = new node_async_hooks_1.AsyncLocalStorage();
 /**
  * Indica si conviene saltar inmediatamente al siguiente modelo de la cadena de fallback.
@@ -63,6 +79,111 @@ function extractModelName(model) {
 }
 // eslint-disable-next-line no-console
 const log = (...args) => console.error(...args);
+/**
+ * Detecta si un texto contiene chain-of-thought (razonamiento interno del modelo)
+ * que NO debe llegar al usuario final. Usa una combinación de:
+ * - Señales fuertes: etiquetas explícitas tipo `<thinking>`, `thought:` o bullets meta
+ *   tipo `*   *Draft:*`. Cualquiera dispara directamente.
+ * - Señales débiles: vocabulario meta (Attempt N, Critique N, word count...), densidad
+ *   de asteriscos/bullets/comillas y palabras funcionales en inglés (las respuestas
+ *   legítimas siempre van en español). Suman puntos hasta un umbral.
+ *
+ * @param text - Texto devuelto por el modelo
+ * @returns true si el texto parece contener CoT y debería ser saneado
+ */
+function looksLikeChainOfThought(text) {
+    if (!text || typeof text !== 'string')
+        return false;
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
+    // ⭐ Señales fuertes — cualquiera dispara
+    if (COT_HTML_TAG.test(trimmed))
+        return true;
+    if (COT_STRONG_TAG.test(trimmed))
+        return true;
+    const metaBullets = (trimmed.match(COT_META_BULLET) || []).length;
+    if (metaBullets >= 2)
+        return true;
+    // ⭐ Señales débiles — score acumulativo
+    let score = 0;
+    for (const re of COT_META_PATTERNS)
+        if (re.test(trimmed))
+            score++;
+    const asteriskRatio = (trimmed.match(/\*/g) || []).length / trimmed.length;
+    if (asteriskRatio > 0.02)
+        score++;
+    const bulletLines = trimmed.split('\n').filter((l) => /^\s*\*\s/.test(l)).length;
+    if (bulletLines >= 6)
+        score++;
+    const quoteCount = (trimmed.match(/"/g) || []).length;
+    if (quoteCount >= 8)
+        score++;
+    const englishHits = (trimmed.match(COT_ENGLISH_FUNCTION_WORDS) || []).length;
+    if (englishHits >= 6)
+        score += 2;
+    else if (englishHits >= 3)
+        score++;
+    return score >= COT_SCORE_THRESHOLD;
+}
+/**
+ * Refuerza el `system` original con instrucciones explícitas anti chain-of-thought
+ * para usar en el reintento cuando se detectó CoT en la primera respuesta.
+ */
+function buildAntiCotSystem(originalSystem) {
+    const guard = '\n\nIMPORTANTE: Devuelve SOLO el mensaje final listo para enviar. No incluyas razonamiento, borradores, etiquetas tipo "thought" o "thinking", listas de intentos, autocríticas, conteo de palabras ni ningún meta-contenido. Responde siempre en español.';
+    return (originalSystem || '') + guard;
+}
+/**
+ * Sanitizer de último recurso: pide a un modelo LITE que extraiga del texto
+ * contaminado únicamente la respuesta final, sin razonamiento ni etiquetas.
+ *
+ * @param rawText - Texto contaminado con CoT
+ * @returns Texto limpio + cost de la llamada, o null si no se pudo sanear
+ */
+function sanitizeWithLite(rawText) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const liteModel = (0, googleModel_1.createGoogleModel)('LITE');
+            const { text, usage } = yield (0, ai_1.generateText)({
+                model: liteModel,
+                system: `Eres un extractor de respuestas. Recibes un texto que contiene el razonamiento interno de otro modelo (borradores, autocríticas, intentos, conteos de palabras, etiquetas tipo "thought", etc.) seguido de la respuesta final que el modelo quería devolver al usuario.
+
+Tu única tarea es devolver EXACTAMENTE esa respuesta final, sin razonamiento, sin etiquetas, sin comillas envolventes y sin meta-contenido.
+
+Reglas:
+1. Devuelve solo texto plano en español, listo para enviar al usuario.
+2. NO añadas explicaciones, encabezados ni introducciones.
+3. NO inventes contenido: extrae lo que ya está.
+4. Si no puedes identificar una respuesta final clara, devuelve cadena vacía.`,
+                prompt: rawText,
+            });
+            const modelName = extractModelName(liteModel);
+            const cost = (0, modelPricing_1.calculateCost)(modelName, usage === null || usage === void 0 ? void 0 : usage.inputTokens, usage === null || usage === void 0 ? void 0 : usage.outputTokens);
+            return { text: text.trim(), cost };
+        }
+        catch (error) {
+            log(`[AI] sanitizeWithLite falló: ${error === null || error === void 0 ? void 0 : error.message}`);
+            return null;
+        }
+    });
+}
+/**
+ * Notifica a Slack cuando una respuesta contaminada con CoT no se ha podido sanear.
+ * No bloquea el flujo si el envío a Slack falla.
+ */
+function notifyCotFailure(modelLabel, rawText) {
+    try {
+        const preview = rawText.slice(0, 1000);
+        (0, slack_1.notifySlack)({
+            text: `⚠️ *generateText: chain-of-thought no saneable*\n*Modelo:* ${modelLabel}\n*Preview (1000 chars):*\n\`\`\`${preview}\`\`\``,
+            channel: slack_1.CHANNEL_SLACK.BRUTAL,
+        });
+    }
+    catch (error) {
+        // Silenciar: la notificación es best-effort
+    }
+}
 /**
  * Wrapper de generateObject con retry automático y cadena de fallbacks.
  * Calcula el coste de producción de la llamada y lo acumula automáticamente
@@ -133,12 +254,22 @@ function generateObject(options) {
 }
 exports.generateObject = generateObject;
 /**
- * Wrapper de generateText con retry automático y cadena de fallbacks.
- * Calcula el coste de producción de la llamada y lo acumula automáticamente
- * si se ejecuta dentro de runWithCostTracking.
+ * Wrapper de generateText con retry automático, cadena de fallbacks y saneamiento
+ * de chain-of-thought.
+ *
+ * Defensa en profundidad contra CoT que se cuela en la respuesta final del modelo:
+ *  1. Tras cada respuesta exitosa, valida con `looksLikeChainOfThought`.
+ *  2. Si detecta CoT → reintenta 1 vez con `system` reforzado y temperatura +0.1.
+ *  3. Si el retry sigue contaminado → llama a un modelo LITE para extraer la
+ *     respuesta final del CoT (`sanitizeWithLite`).
+ *  4. Si nada limpia el output → notifica a Slack y lanza error para evitar enviar CoT.
+ *
+ * Los costes de retry y sanitizer se acumulan al cost original y se reportan a
+ * `runWithCostTracking`.
  *
  * @param options - Opciones para generateText (model, system, prompt, temperature, etc.)
- * @returns Texto generado y coste de la llamada
+ * @returns Texto generado limpio (sin CoT) y coste total de la llamada
+ * @throws Error si tras retry + sanitizer sigue habiendo CoT, para evitar que llegue al cliente.
  *
  * @example
  * ```typescript
@@ -162,10 +293,11 @@ function generateText(options) {
                 const { text, usage } = yield (0, ai_1.generateText)(currentOptions);
                 const modelName = extractModelName(currentOptions.model);
                 const cost = (0, modelPricing_1.calculateCost)(modelName, usage === null || usage === void 0 ? void 0 : usage.inputTokens, usage === null || usage === void 0 ? void 0 : usage.outputTokens);
+                const cleanResult = yield ensureNoChainOfThought({ rawText: text, baseCost: cost, originalOptions: options, modelLabel: modelName });
                 const tracker = costTrackingStorage.getStore();
                 if (tracker)
-                    tracker.push(cost);
-                return { text: text.trim(), cost };
+                    tracker.push(cleanResult.cost);
+                return cleanResult;
             }
             catch (error) {
                 lastError = error;
@@ -195,6 +327,62 @@ function generateText(options) {
     });
 }
 exports.generateText = generateText;
+/**
+ * Garantiza que el texto devuelto no contenga chain-of-thought.
+ *
+ * Flujo (defensa en profundidad):
+ *  1. Si el texto está limpio → se devuelve tal cual.
+ *  2. Si tiene CoT → 1 retry con `system` reforzado y temperatura ligeramente superior.
+ *  3. Si el retry sigue contaminado → se delega a `sanitizeWithLite` para extraer la
+ *     respuesta final del CoT con un modelo LITE.
+ *  4. Si todo falla → se notifica a Slack y se lanza error para evitar enviar CoT al cliente.
+ *
+ * Los costes de retry y sanitizer se acumulan al cost base para que `runWithCostTracking`
+ * los recoja correctamente.
+ */
+function ensureNoChainOfThought(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { rawText, baseCost, originalOptions, modelLabel } = params;
+        const trimmed = (rawText || '').trim();
+        if (!looksLikeChainOfThought(trimmed)) {
+            return { text: trimmed, cost: baseCost };
+        }
+        log(`[AI] generateText — chain-of-thought detectado en ${modelLabel}, reintentando con system reforzado`);
+        const accumulatedCost = Object.assign({}, baseCost);
+        const baseTemperature = typeof originalOptions.temperature === 'number' ? originalOptions.temperature : 0.7;
+        const retryTemperature = Math.min(1, baseTemperature + 0.1);
+        // Paso 2: retry con system anti-CoT y temperatura ligeramente superior
+        try {
+            const { text: retryText, usage: retryUsage } = yield (0, ai_1.generateText)(Object.assign(Object.assign({}, originalOptions), { system: buildAntiCotSystem(originalOptions.system), temperature: retryTemperature }));
+            const retryModelLabel = extractModelName(originalOptions.model);
+            const retryCost = (0, modelPricing_1.calculateCost)(retryModelLabel, retryUsage === null || retryUsage === void 0 ? void 0 : retryUsage.inputTokens, retryUsage === null || retryUsage === void 0 ? void 0 : retryUsage.outputTokens);
+            accumulatedCost.inputTokens = (accumulatedCost.inputTokens || 0) + (retryCost.inputTokens || 0);
+            accumulatedCost.outputTokens = (accumulatedCost.outputTokens || 0) + (retryCost.outputTokens || 0);
+            accumulatedCost.cost = (accumulatedCost.cost || 0) + (retryCost.cost || 0);
+            const retryTrimmed = (retryText || '').trim();
+            if (retryTrimmed && !looksLikeChainOfThought(retryTrimmed)) {
+                return { text: retryTrimmed, cost: accumulatedCost };
+            }
+            log(`[AI] generateText — el retry en ${retryModelLabel} sigue contaminado, delegando a sanitizer LITE`);
+        }
+        catch (error) {
+            log(`[AI] generateText — retry anti-CoT falló en ${modelLabel}: ${error === null || error === void 0 ? void 0 : error.message}`);
+        }
+        // Paso 3: sanitizer LITE como último recurso
+        const sanitized = yield sanitizeWithLite(rawText);
+        if (sanitized) {
+            accumulatedCost.inputTokens = (accumulatedCost.inputTokens || 0) + (sanitized.cost.inputTokens || 0);
+            accumulatedCost.outputTokens = (accumulatedCost.outputTokens || 0) + (sanitized.cost.outputTokens || 0);
+            accumulatedCost.cost = (accumulatedCost.cost || 0) + (sanitized.cost.cost || 0);
+            if (sanitized.text && !looksLikeChainOfThought(sanitized.text)) {
+                return { text: sanitized.text, cost: accumulatedCost };
+            }
+        }
+        // Paso 4: imposible sanear — notificar y abortar
+        notifyCotFailure(modelLabel, rawText);
+        throw new Error(`[AI] generateText devolvió chain-of-thought no saneable en ${modelLabel}`);
+    });
+}
 /**
  * Ejecuta una función async acumulando los costes de todas las llamadas a IA.
  * Al finalizar, devuelve el resultado original junto con el coste total agregado.

package/lib/cjs/slack/index.js

@@ -25,5 +25,6 @@ const CHANNEL_SLACK = {
     COACH_LOGS: 'T05JCPFMXE0/B0AEP9THSFJ/x1ea4vRfUN63NHOPvBvombQB',
     BRUTAL: 'T05JCPFMXE0/B05RDSHESGZ/lHGRox6UiOkioUMHQscap9pA',
     TEST: 'T05JCPFMXE0/B0601LMECSW/RsTOfjgMrxCPIvHAIttjwIPj',
+    SOPORTE: 'T05JCPFMXE0/B0AS6LGEWC9/ZnXA4AOgaJhZCjsvYi0JCny0',
 };
 exports.CHANNEL_SLACK = CHANNEL_SLACK;

package/lib/cjs/types/prompt/ai.d.ts

@@ -27,12 +27,22 @@ declare function generateObject(options: Parameters<typeof originalGenerateObjec
     cost: CostResult;
 }>;
 /**
- * Wrapper de generateText con retry automático y cadena de fallbacks.
- * Calcula el coste de producción de la llamada y lo acumula automáticamente
- * si se ejecuta dentro de runWithCostTracking.
+ * Wrapper de generateText con retry automático, cadena de fallbacks y saneamiento
+ * de chain-of-thought.
+ *
+ * Defensa en profundidad contra CoT que se cuela en la respuesta final del modelo:
+ *  1. Tras cada respuesta exitosa, valida con `looksLikeChainOfThought`.
+ *  2. Si detecta CoT → reintenta 1 vez con `system` reforzado y temperatura +0.1.
+ *  3. Si el retry sigue contaminado → llama a un modelo LITE para extraer la
+ *     respuesta final del CoT (`sanitizeWithLite`).
+ *  4. Si nada limpia el output → notifica a Slack y lanza error para evitar enviar CoT.
+ *
+ * Los costes de retry y sanitizer se acumulan al cost original y se reportan a
+ * `runWithCostTracking`.
  *
  * @param options - Opciones para generateText (model, system, prompt, temperature, etc.)
- * @returns Texto generado y coste de la llamada
+ * @returns Texto generado limpio (sin CoT) y coste total de la llamada
+ * @throws Error si tras retry + sanitizer sigue habiendo CoT, para evitar que llegue al cliente.
  *
  * @example
  * ```typescript

package/lib/cjs/types/prompt/ai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../../../src/prompt/ai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,sBAAsB,EAAE,YAAY,IAAI,oBAAoB,EAAE,MAAM,IAAI,CAAC;AAEpG,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAsDhE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iBAAe,cAAc,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAyC/H;AAED;;;;;;;;;;;;;;;GAeG;AACH,iBAAe,YAAY,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAyC5H;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAe,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,SAAS,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAc5H;AAED,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,mBAAmB,EAAE,CAAC"}
+{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../../../src/prompt/ai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,sBAAsB,EAAE,YAAY,IAAI,oBAAoB,EAAE,MAAM,IAAI,CAAC;AAEpG,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AA+KhE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iBAAe,cAAc,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAyC/H;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iBAAe,YAAY,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CA0C5H;AA2ED;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAe,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,SAAS,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAc5H;AAED,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

package/lib/cjs/types/slack/index.d.ts

@@ -7,6 +7,7 @@ declare const CHANNEL_SLACK: {
     COACH_LOGS: string;
     BRUTAL: string;
     TEST: string;
+    SOPORTE: string;
 };
 export { notifySlack, CHANNEL_SLACK, };
 //# sourceMappingURL=index.d.ts.map

package/lib/cjs/types/slack/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/slack/index.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,WAAW;;;UAYhB,CAAC;AAQF,QAAA,MAAM,aAAa;;;;;CAKlB,CAAC;AAEF,OAAO,EACL,WAAW,EACX,aAAa,GACd,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/slack/index.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,WAAW;;;UAYhB,CAAC;AAQF,QAAA,MAAM,aAAa;;;;;;CAMlB,CAAC;AAEF,OAAO,EACL,WAAW,EACX,aAAa,GACd,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runnerpro/backend",
-  "version": "1.19.7",
+  "version": "1.19.9",
   "description": "A collection of common backend functions",
   "exports": {
     ".": "./lib/cjs/index.js"