Propuesta IA: aplanar el nivel calculo y subir el tope del subtitulo

Segunda tanda de rechazos observados contra datos reales (3 vueltas mas): - Cada dimension del valor del problema tenia sus factores dentro de un objeto `calculo`. Ese nivel no aportaba nada semantico y era justo donde el modelo se perdia: devolvia {item: {...}, notaMetodologia} y quemaba reintentos. Ahora `factores` y `montoAnualMXN` cuelgan de la dimension. Un nivel menos de anidamiento en el punto exacto donde fallaba. - subtitulo.max(300) se quedaba corto. Sube a 400. La primera tanda de arreglos ya habia bajado los rechazos de 7 a 3 en tres vueltas, y de 3 vueltas con reintento en la redaccion a solo 1. Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>
2026-07-28 21:07:39 -06:00
parent bdd9319fd0
commit 434a427f70
7 changed files with 187 additions and 68 deletions
@@ -0,0 +1,113 @@
+/**
+ * Caza del error intermitente: corre el pipeline real contra UJ2606UR001 hasta que
+ * falle, e imprime TODO lo que sepamos de la peticion que lo provoco.
+ */
+import { cargarEconomia } from "@/lib/propuesta/economia";
+import { crearCliente, modelo } from "@/lib/propuesta/cliente-ia";
+import { hechosSchema, diagnosticoSchema, redaccionSchema, aJsonSchema, type Hechos, type Diagnostico } from "@/lib/propuesta/schemas";
+import { SYSTEM_BASE, mensajePaso1, mensajePaso2, mensajePaso3, type ContextoEntrada } from "@/lib/propuesta/prompts";
+import { prisma } from "@/lib/db";
+import type Anthropic from "@anthropic-ai/sdk";
+import type { z } from "zod";
+import fs from "node:fs";
+
+const LOG = process.argv[2];
+// Escritura directa: el buffer de stdout se pierde si el proceso muere.
+function log(...a: unknown[]) {
+  const linea = a.map((x) => (typeof x === "string" ? x : JSON.stringify(x))).join(" ");
+  fs.appendFileSync(LOG, linea + "\n");
+}
+const console = { log } as unknown as Console;
+
+const NUMERO = "UJ2606UR001";
+const TRANSCRIPCION = "Una propuesta de zero to hero para un negocio inicial";
+
+/** Igual que llamarConHerramienta pero registra cada peticion y explota con detalle. */
+async function correrPaso(nombre: string, msg: string, schema: z.ZodType, maxTokens: number, maxIntentos: number) {
+  const cliente = crearCliente();
+  const tools = [{ name: nombre, description: "Registra el resultado.", input_schema: aJsonSchema(schema) as never }];
+  const mensajes: Anthropic.MessageParam[] = [{ role: "user", content: msg }];
+
+  for (let intento = 1; intento <= maxIntentos; intento++) {
+    let res: Anthropic.Message;
+    try {
+      res = await cliente.messages.create({
+        model: modelo(), max_tokens: maxTokens,
+        system: [{ type: "text", text: SYSTEM_BASE, cache_control: { type: "ephemeral" } }],
+        tools, messages: mensajes,
+      });
+    } catch (e) {
+      const err = e as { status?: number; message?: string; error?: unknown };
+      console.log(`\n*** ERROR EN ${nombre} intento ${intento} ***`);
+      console.log("   status:", err.status);
+      console.log("   message:", String(err.message).slice(0, 600));
+      if (err.error) console.log("   error:", JSON.stringify(err.error).slice(0, 800));
+      console.log("\n   --- FORMA DE LOS MENSAJES ENVIADOS ---");
+      mensajes.forEach((m, i) => {
+        const c = m.content;
+        const tipos = typeof c === "string" ? "string" : (c as { type: string }[]).map((b) => b.type).join(",");
+        console.log(`   [${i}] role=${m.role} bloques=${tipos}`);
+      });
+      throw new Error("REPRODUCIDO");
+    }
+
+    const bloques = res.content.map((b) => b.type).join(",");
+    console.log(`   ${nombre} intento ${intento}: stop=${res.stop_reason} bloques=[${bloques}] out=${res.usage.output_tokens}`);
+
+    const tus = res.content.filter((b): b is Anthropic.ToolUseBlock => b.type === "tool_use");
+    const ok = tus.find((b) => b.name === nombre);
+    if (ok) {
+      const parsed = schema.safeParse(ok.input);
+      if (parsed.success) return parsed.data;
+      const errTxt = (await import("zod")).z.prettifyError(parsed.error);
+      console.log(`      zod rechazo: ${errTxt.split("\n")[0]}`);
+      mensajes.push(
+        { role: "assistant", content: res.content },
+        { role: "user", content: [
+          ...tus.map((b) => ({ type: "tool_result" as const, tool_use_id: b.id, is_error: true, content: errTxt })),
+          { type: "text" as const, text: "Corrige y reintenta." },
+        ] },
+      );
+      continue;
+    }
+    mensajes.push(
+      { role: "assistant", content: res.content },
+      { role: "user", content: `Debes llamar a ${nombre}.` },
+    );
+  }
+  return null;
+}
+
+async function unaVuelta(entrada: ContextoEntrada, econ: Awaited<ReturnType<typeof cargarEconomia>>, n: number) {
+  console.log(`\n===== VUELTA ${n} =====`);
+  const h = (await correrPaso("registrar_hechos", mensajePaso1(entrada), hechosSchema, 8000, 5)) as Hechos | null;
+  if (!h) { console.log("  extraccion agoto intentos"); return; }
+  const d = (await correrPaso("registrar_diagnostico", mensajePaso2(entrada, h, econ), diagnosticoSchema, 8000, 4)) as Diagnostico | null;
+  if (!d) { console.log("  diagnostico agoto intentos"); return; }
+  const r = await correrPaso("registrar_propuesta", mensajePaso3(entrada, h, d, econ), redaccionSchema, 12000, 4);
+  console.log(r ? "  vuelta completa OK" : "  redaccion agoto intentos");
+}
+
+async function main() {
+  const cot = await prisma.cotizacion.findFirst({ where: { numero: NUMERO }, include: { cliente: true, servicios: true } });
+  if (!cot) throw new Error("no encontrada");
+  const econ = await cargarEconomia(cot.id);
+  const entrada: ContextoEntrada = {
+    transcripcion: TRANSCRIPCION,
+    notas: cot.servicios.map((s) => s.notas).filter(Boolean).join("\n"),
+    observaciones: cot.observaciones || "",
+    cliente: cot.cliente.nombre, empresa: cot.cliente.empresa || "", proyecto: cot.proyecto,
+  };
+  console.log(`${econ.partidas.length} partidas`);
+
+  for (let i = 1; i <= 3; i++) {
+    try { await unaVuelta(entrada, econ, i); }
+    catch (e) {
+      if (e instanceof Error && e.message === "REPRODUCIDO") { console.log("\n>>> error reproducido, deteniendo"); break; }
+      throw e;
+    }
+  }
+  await prisma.$disconnect();
+}
+
+main().catch((e) => { console.error("fallo:", e); process.exit(1); });