@hoilab/ada-cli 0.84.22 → 0.85.0

package/dist/core/telemetria/otlp.js

@@ -0,0 +1,373 @@
+/**
+ * OTLP que NO PUEDE filtrar contenido.
+ *
+ * La casilla que marca un comité de compras es «exporta a OpenTelemetry». Eso
+ * lo tiene cualquiera: el contrato es un puñado de variables de entorno
+ * (`OTEL_EXPORTER_OTLP_ENDPOINT` y compañía) y un JSON con una forma fija. Lo
+ * que no tiene cualquiera es exportar SIN convertir el colector de
+ * observabilidad del cliente en un tratamiento de datos personales que nadie ha
+ * inventariado.
+ *
+ * El competidor trae una variable para capturar el CUERPO de los mensajes —el
+ * patrón se llama `CAPTURE_MESSAGE_CONTENT` en la especificación de OTel para
+ * GenAI—. Activarla mete prompts y respuestas del modelo en un almacén de
+ * trazas: un segundo depósito de justo aquello que el RGPD manda minimizar, y
+ * encima uno del que el DPO no suele saber nada porque lo administra el equipo
+ * de plataforma.
+ *
+ * PROPIEDAD DE DISEÑO, y es lo que este módulo vende:
+ *
+ *   NO EXISTE en este fichero ninguna variable de entorno, opción, parámetro ni
+ *   bandera que active la exportación de contenido. No es que venga apagada por
+ *   defecto: es que no está. Una opción apagada la enciende alguien un martes;
+ *   un mecanismo que no existe no se enciende.
+ *
+ * Hay una prueba que recorre el fuente de este módulo comprobándolo, con los
+ * comentarios quitados —porque este párrafo nombra el patrón que persigue y si
+ * no, se acusaría a sí misma—. Ver `test/otlp-sin-contenido.test.ts`.
+ *
+ * TRES CINTURONES, no uno:
+ *
+ *   1. `atributosDeSuceso` trabaja con una LISTA BLANCA explícita. Lo que no
+ *      está, no sale. Es la misma regla que ya cumple `audit/libro.ts`: se
+ *      registra la FORMA de lo que pasó, nunca su contenido.
+ *   2. El descarte es CONTABLE. Sale en `ada.atributos_descartados`, para que
+ *      «este suceso traía cinco claves que no exporto» sea un dato y no un
+ *      silencio. Un filtro mudo es indistinguible de un filtro roto.
+ *   3. `sinContenido` es la red por debajo: cualquier valor con salto de línea o
+ *      más largo que 200 caracteres se cae aunque su clave esté en la lista.
+ *      Sirve para el día en que alguien añada una clave sin pensarlo.
+ *
+ * LO QUE ESTE MÓDULO NO HACE. No envía nada. Construye el cuerpo y lo devuelve;
+ * quien lo suba a un colector es otro, y así este fichero no tiene ninguna
+ * salida a la red que auditar.
+ */
+import { createHash } from "node:crypto";
+const SENALES = ["trazas", "logs", "metricas"];
+/** Los dos únicos protocolos que este exportador sabe rendir. */
+const PROTOCOLOS = ["http/protobuf", "http/json"];
+/**
+ * El contrato estándar, tal cual. Los nombres son los de OpenTelemetry y no se
+ * traducen: son lo que un comité de compras busca en la documentación.
+ */
+const VARIABLE_ENDPOINT_BASE = "OTEL_EXPORTER_OTLP_ENDPOINT";
+const VARIABLE_PROTOCOLO_BASE = "OTEL_EXPORTER_OTLP_PROTOCOL";
+const VARIABLES_POR_SENAL = {
+    trazas: { endpoint: "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", protocolo: "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL" },
+    logs: { endpoint: "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT", protocolo: "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL" },
+    metricas: { endpoint: "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT", protocolo: "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL" },
+};
+/** Una variable vacía o con solo espacios cuenta como no puesta. */
+function valor(env, nombre) {
+    const crudo = env[nombre];
+    if (typeof crudo !== "string")
+        return undefined;
+    const limpio = crudo.trim();
+    return limpio === "" ? undefined : limpio;
+}
+function esUrlHttp(candidato) {
+    try {
+        const url = new URL(candidato);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Lee la configuración del entorno, con TRES estados y sin inventarse nada.
+ *
+ * La base (`OTEL_EXPORTER_OTLP_ENDPOINT` / `_PROTOCOL`) vale para las tres
+ * señales; la variable específica de una señal la sobreescribe.
+ *
+ * Lo que NO hace, y es deliberado: no cae a `http/protobuf` cuando falta el
+ * protocolo, aunque sea el defecto de la especificación. Un endpoint sin
+ * protocolo declarado sale como `invalida`. El motivo es el de siempre: elegir
+ * en silencio por el operador convierte un despiste suyo en una configuración
+ * nuestra, y el día que el colector no reciba nada nadie sabrá por qué.
+ */
+export function configuracionOtlp(env = process.env) {
+    const endpointBase = valor(env, VARIABLE_ENDPOINT_BASE);
+    const protocoloBase = valor(env, VARIABLE_PROTOCOLO_BASE);
+    const porSenal = {};
+    const problemas = [];
+    /** Señales con protocolo declarado y ningún endpoint donde mandarlo. */
+    const protocoloHuerfano = [];
+    for (const senal of SENALES) {
+        const variables = VARIABLES_POR_SENAL[senal];
+        const endpoint = valor(env, variables.endpoint) ?? endpointBase;
+        const protocolo = valor(env, variables.protocolo) ?? protocoloBase;
+        if (endpoint === undefined) {
+            if (protocolo !== undefined)
+                protocoloHuerfano.push(senal);
+            continue;
+        }
+        if (!esUrlHttp(endpoint)) {
+            problemas.push(`${senal}: el endpoint recibido (${endpoint}) no es una URL http:// ni https://`);
+            continue;
+        }
+        if (protocolo === undefined) {
+            problemas.push(`${senal}: hay endpoint (${endpoint}) y ningun protocolo declarado; ` +
+                `declara ${variables.protocolo} o ${VARIABLE_PROTOCOLO_BASE} con ${PROTOCOLOS.join(" o ")} ` +
+                "(no se asume ninguno por defecto)");
+            continue;
+        }
+        if (!PROTOCOLOS.includes(protocolo)) {
+            problemas.push(`${senal}: el protocolo recibido (${protocolo}) no es valido; los unicos validos son ${PROTOCOLOS.join(" y ")}`);
+            continue;
+        }
+        porSenal[senal] = { endpoint, protocolo: protocolo };
+    }
+    // Una señal mal configurada NO entra en `porSenal`: quien lea esto no puede
+    // acabar exportando a un sitio que no supimos validar.
+    if (problemas.length > 0) {
+        return { estado: "invalida", porSenal, motivo: problemas.join("; ") };
+    }
+    const configuradas = Object.keys(porSenal);
+    if (configuradas.length > 0) {
+        const detalle = configuradas.map((s) => `${s} -> ${porSenal[s]?.endpoint} (${porSenal[s]?.protocolo})`);
+        return { estado: "configurada", porSenal, motivo: `exportacion OTLP activa para ${detalle.join(", ")}` };
+    }
+    // El tercer estado se dice entero: «no hay endpoint» y «hay protocolo pero
+    // no hay endpoint» son dos situaciones distintas para quien la está montando.
+    if (protocoloHuerfano.length > 0) {
+        return {
+            estado: "sin-configurar",
+            porSenal,
+            motivo: `hay protocolo declarado para ${protocoloHuerfano.join(", ")} pero ningun endpoint: ` +
+                `sin ${VARIABLE_ENDPOINT_BASE} (o el especifico de la senal) no hay nada que exportar`,
+        };
+    }
+    return {
+        estado: "sin-configurar",
+        porSenal,
+        motivo: `no hay ninguna variable ${VARIABLE_ENDPOINT_BASE} en el entorno: la exportacion OTLP esta apagada`,
+    };
+}
+/**
+ * LA LISTA BLANCA. Clave del suceso -> nombre del atributo OTLP.
+ *
+ * Todo lo que hay aquí es FORMA: qué pasó, con qué herramienta, cómo acabó,
+ * cuánto ocupó. Nada de aquí puede llevar texto del usuario.
+ *
+ * Lo que NO está, y no por olvido:
+ *
+ *   · `argv` — el texto del comando. Es la clave más golosa y la que más caro
+ *     sale: un comando lleva rutas, nombres de cliente y a veces un secreto
+ *     pegado en la línea.
+ *   · `ruta` — la ruta completa del fichero. El nombre de un fichero ya es un
+ *     dato: `/casos/2024/despido-<nombre>.docx` identifica a una persona sin
+ *     que haga falta abrirlo. Del fichero salen sus hashes y nada más.
+ *   · `motivo` — texto libre de la política. Hoy son frases nuestras; mañana
+ *     alguien mete ahí lo que el modelo dijo.
+ *   · `extension` — ruta en disco de la extensión, mismo argumento que `ruta`.
+ *   · `violaciones` — lista de texto libre del sandbox.
+ *
+ * Y nunca, en ninguna versión: el prompt, la respuesta del modelo o el
+ * contenido de un fichero. No hay clave en `SucesoDeSesion` que los lleve, y
+ * este módulo existe para que siga sin haberla.
+ */
+const LISTA_BLANCA = {
+    tipo: "ada.suceso.tipo",
+    // tool
+    nombre: "ada.tool.nombre",
+    ok: "ada.tool.ok",
+    decision: "ada.permiso.veredicto",
+    // comando
+    codigo: "ada.comando.codigo",
+    sandbox: "ada.comando.encierro",
+    origen: "ada.comando.origen",
+    // modelo
+    proveedor: "ada.modelo.proveedor",
+    modelo: "ada.modelo.nombre",
+    entrada: "ada.modelo.tokens_entrada",
+    salida: "ada.modelo.tokens_salida",
+    motivoParada: "ada.modelo.motivo_parada",
+    // fichero: solo los hashes, jamás la ruta
+    antes: "ada.fichero.hash_antes",
+    despues: "ada.fichero.hash_despues",
+    tool: "ada.fichero.tool",
+    // red: el dominio, nunca la ruta ni los parametros (ahi viajan los tokens)
+    dominio: "ada.red.dominio",
+    permitido: "ada.red.permitido",
+    // credenciales: el identificador, jamas el valor
+    accion: "ada.credencial.accion",
+    credencialId: "ada.credencial.id",
+    resultado: "ada.credencial.resultado",
+    // purga por retencion
+    politica: "ada.politica.nombre",
+    entradas: "ada.purga.entradas",
+    hashDeCierre: "ada.purga.hash_de_cierre",
+    // medidas genericas, si el suceso las trae
+    bytes: "ada.bytes",
+    duracionMs: "ada.duracion_ms",
+};
+/** Nombre del contador de descartes. Se expone porque las pruebas lo miran. */
+export const CLAVE_DESCARTADOS = "ada.atributos_descartados";
+/** Un valor de cadena más largo que esto ya no es forma: es texto. */
+const LARGO_MAXIMO = 200;
+/**
+ * Las claves sospechosas de llevar texto libre.
+ *
+ * Dos señales, las dos baratas y las dos difíciles de fingir por un dato de
+ * forma: un salto de línea (un hash no los tiene, un diff sí) y una longitud
+ * que ningún identificador nuestro alcanza.
+ *
+ * Es un cinturón POR ENCIMA de la lista blanca, no un sustituto. Sola dejaría
+ * pasar una ruta de 40 caracteres; la lista blanca sola dejaría pasar lo que
+ * alguien añada mañana sin pensarlo. Hacen falta las dos.
+ */
+export function sinContenido(atributos) {
+    const sospechosas = [];
+    for (const [clave, valorDelAtributo] of Object.entries(atributos)) {
+        if (typeof valorDelAtributo !== "string")
+            continue;
+        if (valorDelAtributo.length > LARGO_MAXIMO || /[\r\n]/.test(valorDelAtributo))
+            sospechosas.push(clave);
+    }
+    return sospechosas;
+}
+/**
+ * Los atributos de un suceso, filtrados y con el descarte contado.
+ *
+ * `ada.atributos_descartados` cuenta lo que se quedó fuera: claves que no están
+ * en la lista blanca, claves cuyo valor no es un escalar exportable y claves
+ * que `sinContenido` marcó. Sin ese número, un filtro que se comiera todo y un
+ * suceso que no traía nada darían el mismo span.
+ *
+ * Una clave de la lista blanca con valor `null` no cuenta como descarte y no
+ * sale: en el libro `null` significa «el fichero no existía» o «no había
+ * credencial activa», y un atributo ausente en OTLP significa exactamente eso.
+ */
+export function atributosDeSuceso(entrada) {
+    const candidatos = {
+        "ada.sesion": entrada.sesion,
+        "ada.seq": entrada.seq,
+    };
+    let descartados = 0;
+    for (const [clave, valorCrudo] of Object.entries(entrada.suceso ?? {})) {
+        const nombre = LISTA_BLANCA[clave];
+        if (nombre === undefined) {
+            descartados++;
+            continue;
+        }
+        if (valorCrudo === null || valorCrudo === undefined)
+            continue;
+        if (typeof valorCrudo !== "string" && typeof valorCrudo !== "number" && typeof valorCrudo !== "boolean") {
+            // Un objeto o un array en una clave blanca: no se aplana ni se
+            // serializa, porque serializar es justo por donde entraría el texto.
+            descartados++;
+            continue;
+        }
+        candidatos[nombre] = valorCrudo;
+    }
+    for (const clave of sinContenido(candidatos)) {
+        delete candidatos[clave];
+        descartados++;
+    }
+    candidatos[CLAVE_DESCARTADOS] = descartados;
+    return candidatos;
+}
+/** Un identificador hexadecimal derivado del suceso, estable entre procesos. */
+function hex(material, bytes) {
+    return createHash("sha256")
+        .update(material)
+        .digest("hex")
+        .slice(0, bytes * 2);
+}
+/** El atributo tal y como lo espera OTLP/JSON: clave y valor etiquetado. */
+function atributoOtlp(clave, valorDelAtributo) {
+    if (typeof valorDelAtributo === "boolean")
+        return { key: clave, value: { boolValue: valorDelAtributo } };
+    if (typeof valorDelAtributo === "number") {
+        return Number.isInteger(valorDelAtributo)
+            ? { key: clave, value: { intValue: String(valorDelAtributo) } }
+            : { key: clave, value: { doubleValue: valorDelAtributo } };
+    }
+    return { key: clave, value: { stringValue: valorDelAtributo } };
+}
+/** Códigos de `SpanKind` de OTLP. Solo se usan estos dos. */
+const SPAN_KIND_INTERNAL = 1;
+const SPAN_KIND_CLIENT = 3;
+/** Códigos de `StatusCode`: 0 sin fijar, 2 error. El 1 (`OK`) se reserva. */
+const STATUS_UNSET = 0;
+const STATUS_ERROR = 2;
+/** ¿El suceso terminó mal? Se mira la forma, nunca el texto del error. */
+function fueError(suceso) {
+    if (suceso.ok === false)
+        return true;
+    if (typeof suceso.codigo === "number" && suceso.codigo !== 0)
+        return true;
+    if (suceso.permitido === false)
+        return true;
+    return false;
+}
+/**
+ * Un span de OTLP a partir de una entrada del libro.
+ *
+ * `traceId` sale de la sesión y `spanId` de la sesión más el número de
+ * secuencia: los sucesos de una misma sesión cuelgan de la misma traza sin que
+ * haya que guardar estado en ningún sitio, y dos procesos que exporten el mismo
+ * libro producen los mismos identificadores en vez de duplicar la traza.
+ *
+ * Si el sello de tiempo no se puede leer, los dos tiempos van a cero y el span
+ * lo dice en `ada.sello_ilegible`. Poner la hora actual sería inventarse un
+ * dato: en un registro de cumplimiento, una hora inventada es peor que un cero.
+ */
+export function spanDeSuceso(entrada) {
+    const suceso = (entrada.suceso ?? {});
+    const tipo = typeof suceso.tipo === "string" ? suceso.tipo : "desconocido";
+    const atributos = atributosDeSuceso(entrada);
+    const milis = Date.parse(entrada.ts);
+    const ilegible = Number.isNaN(milis);
+    if (ilegible)
+        atributos["ada.sello_ilegible"] = true;
+    const inicio = ilegible ? 0n : BigInt(milis) * 1000000n;
+    const duracion = typeof suceso.duracionMs === "number" && suceso.duracionMs > 0 ? BigInt(Math.round(suceso.duracionMs)) : 0n;
+    return {
+        traceId: hex(`traza:${entrada.sesion}`, 16),
+        spanId: hex(`span:${entrada.sesion}:${entrada.seq}`, 8),
+        name: `ada.${tipo}`,
+        kind: tipo === "red" || tipo === "modelo" ? SPAN_KIND_CLIENT : SPAN_KIND_INTERNAL,
+        startTimeUnixNano: String(inicio),
+        endTimeUnixNano: String(inicio + duracion * 1000000n),
+        attributes: Object.entries(atributos).map(([clave, v]) => atributoOtlp(clave, v)),
+        // El estado va sin `message`: el texto de un error es contenido, y este
+        // es el hueco por donde se colaria.
+        status: { code: fueError(suceso) ? STATUS_ERROR : STATUS_UNSET },
+    };
+}
+/** Lo que se anuncia como productor de las trazas. Nada de esto es un dato del usuario. */
+const RECURSO = [
+    ["service.name", "ada"],
+    ["telemetry.sdk.name", "ada-libro-de-sesion"],
+    ["telemetry.sdk.language", "nodejs"],
+];
+/**
+ * El cuerpo `ResourceSpans` de OTLP/JSON, listo para que otro lo suba.
+ *
+ * La forma es la del estándar y no se improvisa:
+ * `resourceSpans[] -> scopeSpans[] -> spans[]`, con `traceId` y `spanId` en
+ * hexadecimal y los tiempos en nanosegundos desde epoch como cadena, porque son
+ * enteros de 64 bits y un `number` de JavaScript no los sostiene.
+ *
+ * Una lista vacía devuelve un cuerpo con cero spans y NO un cuerpo vacío: el
+ * colector tiene que poder distinguir «esta sesión no tuvo sucesos» de «no se
+ * exportó nada».
+ */
+export function cuerpoOtlp(entradas) {
+    return {
+        resourceSpans: [
+            {
+                resource: { attributes: RECURSO.map(([clave, v]) => atributoOtlp(clave, v)) },
+                scopeSpans: [
+                    {
+                        scope: { name: "ada.core.audit.libro", version: "1" },
+                        spans: entradas.map(spanDeSuceso),
+                    },
+                ],
+            },
+        ],
+    };
+}
+//# sourceMappingURL=otlp.js.map

package/dist/core/telemetria/otlp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp.js","sourceRoot":"","sources":["../../../src/core/telemetria/otlp.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OTLP que NO PUEDE filtrar contenido.\n *\n * La casilla que marca un comité de compras es «exporta a OpenTelemetry». Eso\n * lo tiene cualquiera: el contrato es un puñado de variables de entorno\n * (`OTEL_EXPORTER_OTLP_ENDPOINT` y compañía) y un JSON con una forma fija. Lo\n * que no tiene cualquiera es exportar SIN convertir el colector de\n * observabilidad del cliente en un tratamiento de datos personales que nadie ha\n * inventariado.\n *\n * El competidor trae una variable para capturar el CUERPO de los mensajes —el\n * patrón se llama `CAPTURE_MESSAGE_CONTENT` en la especificación de OTel para\n * GenAI—. Activarla mete prompts y respuestas del modelo en un almacén de\n * trazas: un segundo depósito de justo aquello que el RGPD manda minimizar, y\n * encima uno del que el DPO no suele saber nada porque lo administra el equipo\n * de plataforma.\n *\n * PROPIEDAD DE DISEÑO, y es lo que este módulo vende:\n *\n *   NO EXISTE en este fichero ninguna variable de entorno, opción, parámetro ni\n *   bandera que active la exportación de contenido. No es que venga apagada por\n *   defecto: es que no está. Una opción apagada la enciende alguien un martes;\n *   un mecanismo que no existe no se enciende.\n *\n * Hay una prueba que recorre el fuente de este módulo comprobándolo, con los\n * comentarios quitados —porque este párrafo nombra el patrón que persigue y si\n * no, se acusaría a sí misma—. Ver `test/otlp-sin-contenido.test.ts`.\n *\n * TRES CINTURONES, no uno:\n *\n *   1. `atributosDeSuceso` trabaja con una LISTA BLANCA explícita. Lo que no\n *      está, no sale. Es la misma regla que ya cumple `audit/libro.ts`: se\n *      registra la FORMA de lo que pasó, nunca su contenido.\n *   2. El descarte es CONTABLE. Sale en `ada.atributos_descartados`, para que\n *      «este suceso traía cinco claves que no exporto» sea un dato y no un\n *      silencio. Un filtro mudo es indistinguible de un filtro roto.\n *   3. `sinContenido` es la red por debajo: cualquier valor con salto de línea o\n *      más largo que 200 caracteres se cae aunque su clave esté en la lista.\n *      Sirve para el día en que alguien añada una clave sin pensarlo.\n *\n * LO QUE ESTE MÓDULO NO HACE. No envía nada. Construye el cuerpo y lo devuelve;\n * quien lo suba a un colector es otro, y así este fichero no tiene ninguna\n * salida a la red que auditar.\n */\n\nimport { createHash } from \"node:crypto\";\nimport type { EntradaDelLibro } from \"../audit/libro.ts\";\n\n/** Las tres señales del contrato OTLP. Se nombran en español como el resto. */\nexport type SenalOtlp = \"trazas\" | \"logs\" | \"metricas\";\n\nexport interface ConfiguracionOtlp {\n\testado: \"sin-configurar\" | \"configurada\" | \"invalida\";\n\tporSenal: Partial<Record<SenalOtlp, { endpoint: string; protocolo: \"http/protobuf\" | \"http/json\" }>>;\n\tmotivo: string;\n}\n\nconst SENALES: readonly SenalOtlp[] = [\"trazas\", \"logs\", \"metricas\"];\n\n/** Los dos únicos protocolos que este exportador sabe rendir. */\nconst PROTOCOLOS = [\"http/protobuf\", \"http/json\"] as const;\ntype Protocolo = (typeof PROTOCOLOS)[number];\n\n/**\n * El contrato estándar, tal cual. Los nombres son los de OpenTelemetry y no se\n * traducen: son lo que un comité de compras busca en la documentación.\n */\nconst VARIABLE_ENDPOINT_BASE = \"OTEL_EXPORTER_OTLP_ENDPOINT\";\nconst VARIABLE_PROTOCOLO_BASE = \"OTEL_EXPORTER_OTLP_PROTOCOL\";\nconst VARIABLES_POR_SENAL: Record<SenalOtlp, { endpoint: string; protocolo: string }> = {\n\ttrazas: { endpoint: \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\", protocolo: \"OTEL_EXPORTER_OTLP_TRACES_PROTOCOL\" },\n\tlogs: { endpoint: \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\", protocolo: \"OTEL_EXPORTER_OTLP_LOGS_PROTOCOL\" },\n\tmetricas: { endpoint: \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\", protocolo: \"OTEL_EXPORTER_OTLP_METRICS_PROTOCOL\" },\n};\n\n/** Una variable vacía o con solo espacios cuenta como no puesta. */\nfunction valor(env: NodeJS.ProcessEnv, nombre: string): string | undefined {\n\tconst crudo = env[nombre];\n\tif (typeof crudo !== \"string\") return undefined;\n\tconst limpio = crudo.trim();\n\treturn limpio === \"\" ? undefined : limpio;\n}\n\nfunction esUrlHttp(candidato: string): boolean {\n\ttry {\n\t\tconst url = new URL(candidato);\n\t\treturn url.protocol === \"http:\" || url.protocol === \"https:\";\n\t} catch {\n\t\treturn false;\n\t}\n}\n\n/**\n * Lee la configuración del entorno, con TRES estados y sin inventarse nada.\n *\n * La base (`OTEL_EXPORTER_OTLP_ENDPOINT` / `_PROTOCOL`) vale para las tres\n * señales; la variable específica de una señal la sobreescribe.\n *\n * Lo que NO hace, y es deliberado: no cae a `http/protobuf` cuando falta el\n * protocolo, aunque sea el defecto de la especificación. Un endpoint sin\n * protocolo declarado sale como `invalida`. El motivo es el de siempre: elegir\n * en silencio por el operador convierte un despiste suyo en una configuración\n * nuestra, y el día que el colector no reciba nada nadie sabrá por qué.\n */\nexport function configuracionOtlp(env: NodeJS.ProcessEnv = process.env): ConfiguracionOtlp {\n\tconst endpointBase = valor(env, VARIABLE_ENDPOINT_BASE);\n\tconst protocoloBase = valor(env, VARIABLE_PROTOCOLO_BASE);\n\n\tconst porSenal: ConfiguracionOtlp[\"porSenal\"] = {};\n\tconst problemas: string[] = [];\n\t/** Señales con protocolo declarado y ningún endpoint donde mandarlo. */\n\tconst protocoloHuerfano: SenalOtlp[] = [];\n\n\tfor (const senal of SENALES) {\n\t\tconst variables = VARIABLES_POR_SENAL[senal];\n\t\tconst endpoint = valor(env, variables.endpoint) ?? endpointBase;\n\t\tconst protocolo = valor(env, variables.protocolo) ?? protocoloBase;\n\n\t\tif (endpoint === undefined) {\n\t\t\tif (protocolo !== undefined) protocoloHuerfano.push(senal);\n\t\t\tcontinue;\n\t\t}\n\t\tif (!esUrlHttp(endpoint)) {\n\t\t\tproblemas.push(`${senal}: el endpoint recibido (${endpoint}) no es una URL http:// ni https://`);\n\t\t\tcontinue;\n\t\t}\n\t\tif (protocolo === undefined) {\n\t\t\tproblemas.push(\n\t\t\t\t`${senal}: hay endpoint (${endpoint}) y ningun protocolo declarado; ` +\n\t\t\t\t\t`declara ${variables.protocolo} o ${VARIABLE_PROTOCOLO_BASE} con ${PROTOCOLOS.join(\" o \")} ` +\n\t\t\t\t\t\"(no se asume ninguno por defecto)\",\n\t\t\t);\n\t\t\tcontinue;\n\t\t}\n\t\tif (!(PROTOCOLOS as readonly string[]).includes(protocolo)) {\n\t\t\tproblemas.push(\n\t\t\t\t`${senal}: el protocolo recibido (${protocolo}) no es valido; los unicos validos son ${PROTOCOLOS.join(\" y \")}`,\n\t\t\t);\n\t\t\tcontinue;\n\t\t}\n\t\tporSenal[senal] = { endpoint, protocolo: protocolo as Protocolo };\n\t}\n\n\t// Una señal mal configurada NO entra en `porSenal`: quien lea esto no puede\n\t// acabar exportando a un sitio que no supimos validar.\n\tif (problemas.length > 0) {\n\t\treturn { estado: \"invalida\", porSenal, motivo: problemas.join(\"; \") };\n\t}\n\n\tconst configuradas = Object.keys(porSenal) as SenalOtlp[];\n\tif (configuradas.length > 0) {\n\t\tconst detalle = configuradas.map((s) => `${s} -> ${porSenal[s]?.endpoint} (${porSenal[s]?.protocolo})`);\n\t\treturn { estado: \"configurada\", porSenal, motivo: `exportacion OTLP activa para ${detalle.join(\", \")}` };\n\t}\n\n\t// El tercer estado se dice entero: «no hay endpoint» y «hay protocolo pero\n\t// no hay endpoint» son dos situaciones distintas para quien la está montando.\n\tif (protocoloHuerfano.length > 0) {\n\t\treturn {\n\t\t\testado: \"sin-configurar\",\n\t\t\tporSenal,\n\t\t\tmotivo:\n\t\t\t\t`hay protocolo declarado para ${protocoloHuerfano.join(\", \")} pero ningun endpoint: ` +\n\t\t\t\t`sin ${VARIABLE_ENDPOINT_BASE} (o el especifico de la senal) no hay nada que exportar`,\n\t\t};\n\t}\n\treturn {\n\t\testado: \"sin-configurar\",\n\t\tporSenal,\n\t\tmotivo: `no hay ninguna variable ${VARIABLE_ENDPOINT_BASE} en el entorno: la exportacion OTLP esta apagada`,\n\t};\n}\n\n/**\n * LA LISTA BLANCA. Clave del suceso -> nombre del atributo OTLP.\n *\n * Todo lo que hay aquí es FORMA: qué pasó, con qué herramienta, cómo acabó,\n * cuánto ocupó. Nada de aquí puede llevar texto del usuario.\n *\n * Lo que NO está, y no por olvido:\n *\n *   · `argv` — el texto del comando. Es la clave más golosa y la que más caro\n *     sale: un comando lleva rutas, nombres de cliente y a veces un secreto\n *     pegado en la línea.\n *   · `ruta` — la ruta completa del fichero. El nombre de un fichero ya es un\n *     dato: `/casos/2024/despido-<nombre>.docx` identifica a una persona sin\n *     que haga falta abrirlo. Del fichero salen sus hashes y nada más.\n *   · `motivo` — texto libre de la política. Hoy son frases nuestras; mañana\n *     alguien mete ahí lo que el modelo dijo.\n *   · `extension` — ruta en disco de la extensión, mismo argumento que `ruta`.\n *   · `violaciones` — lista de texto libre del sandbox.\n *\n * Y nunca, en ninguna versión: el prompt, la respuesta del modelo o el\n * contenido de un fichero. No hay clave en `SucesoDeSesion` que los lleve, y\n * este módulo existe para que siga sin haberla.\n */\nconst LISTA_BLANCA: Readonly<Record<string, string>> = {\n\ttipo: \"ada.suceso.tipo\",\n\t// tool\n\tnombre: \"ada.tool.nombre\",\n\tok: \"ada.tool.ok\",\n\tdecision: \"ada.permiso.veredicto\",\n\t// comando\n\tcodigo: \"ada.comando.codigo\",\n\tsandbox: \"ada.comando.encierro\",\n\torigen: \"ada.comando.origen\",\n\t// modelo\n\tproveedor: \"ada.modelo.proveedor\",\n\tmodelo: \"ada.modelo.nombre\",\n\tentrada: \"ada.modelo.tokens_entrada\",\n\tsalida: \"ada.modelo.tokens_salida\",\n\tmotivoParada: \"ada.modelo.motivo_parada\",\n\t// fichero: solo los hashes, jamás la ruta\n\tantes: \"ada.fichero.hash_antes\",\n\tdespues: \"ada.fichero.hash_despues\",\n\ttool: \"ada.fichero.tool\",\n\t// red: el dominio, nunca la ruta ni los parametros (ahi viajan los tokens)\n\tdominio: \"ada.red.dominio\",\n\tpermitido: \"ada.red.permitido\",\n\t// credenciales: el identificador, jamas el valor\n\taccion: \"ada.credencial.accion\",\n\tcredencialId: \"ada.credencial.id\",\n\tresultado: \"ada.credencial.resultado\",\n\t// purga por retencion\n\tpolitica: \"ada.politica.nombre\",\n\tentradas: \"ada.purga.entradas\",\n\thashDeCierre: \"ada.purga.hash_de_cierre\",\n\t// medidas genericas, si el suceso las trae\n\tbytes: \"ada.bytes\",\n\tduracionMs: \"ada.duracion_ms\",\n};\n\n/** Nombre del contador de descartes. Se expone porque las pruebas lo miran. */\nexport const CLAVE_DESCARTADOS = \"ada.atributos_descartados\";\n\n/** Un valor de cadena más largo que esto ya no es forma: es texto. */\nconst LARGO_MAXIMO = 200;\n\n/**\n * Las claves sospechosas de llevar texto libre.\n *\n * Dos señales, las dos baratas y las dos difíciles de fingir por un dato de\n * forma: un salto de línea (un hash no los tiene, un diff sí) y una longitud\n * que ningún identificador nuestro alcanza.\n *\n * Es un cinturón POR ENCIMA de la lista blanca, no un sustituto. Sola dejaría\n * pasar una ruta de 40 caracteres; la lista blanca sola dejaría pasar lo que\n * alguien añada mañana sin pensarlo. Hacen falta las dos.\n */\nexport function sinContenido(atributos: Record<string, unknown>): string[] {\n\tconst sospechosas: string[] = [];\n\tfor (const [clave, valorDelAtributo] of Object.entries(atributos)) {\n\t\tif (typeof valorDelAtributo !== \"string\") continue;\n\t\tif (valorDelAtributo.length > LARGO_MAXIMO || /[\\r\\n]/.test(valorDelAtributo)) sospechosas.push(clave);\n\t}\n\treturn sospechosas;\n}\n\n/**\n * Los atributos de un suceso, filtrados y con el descarte contado.\n *\n * `ada.atributos_descartados` cuenta lo que se quedó fuera: claves que no están\n * en la lista blanca, claves cuyo valor no es un escalar exportable y claves\n * que `sinContenido` marcó. Sin ese número, un filtro que se comiera todo y un\n * suceso que no traía nada darían el mismo span.\n *\n * Una clave de la lista blanca con valor `null` no cuenta como descarte y no\n * sale: en el libro `null` significa «el fichero no existía» o «no había\n * credencial activa», y un atributo ausente en OTLP significa exactamente eso.\n */\nexport function atributosDeSuceso(entrada: EntradaDelLibro): Record<string, string | number | boolean> {\n\tconst candidatos: Record<string, string | number | boolean> = {\n\t\t\"ada.sesion\": entrada.sesion,\n\t\t\"ada.seq\": entrada.seq,\n\t};\n\tlet descartados = 0;\n\n\tfor (const [clave, valorCrudo] of Object.entries(entrada.suceso ?? {})) {\n\t\tconst nombre = LISTA_BLANCA[clave];\n\t\tif (nombre === undefined) {\n\t\t\tdescartados++;\n\t\t\tcontinue;\n\t\t}\n\t\tif (valorCrudo === null || valorCrudo === undefined) continue;\n\t\tif (typeof valorCrudo !== \"string\" && typeof valorCrudo !== \"number\" && typeof valorCrudo !== \"boolean\") {\n\t\t\t// Un objeto o un array en una clave blanca: no se aplana ni se\n\t\t\t// serializa, porque serializar es justo por donde entraría el texto.\n\t\t\tdescartados++;\n\t\t\tcontinue;\n\t\t}\n\t\tcandidatos[nombre] = valorCrudo;\n\t}\n\n\tfor (const clave of sinContenido(candidatos)) {\n\t\tdelete candidatos[clave];\n\t\tdescartados++;\n\t}\n\n\tcandidatos[CLAVE_DESCARTADOS] = descartados;\n\treturn candidatos;\n}\n\n/** Un identificador hexadecimal derivado del suceso, estable entre procesos. */\nfunction hex(material: string, bytes: number): string {\n\treturn createHash(\"sha256\")\n\t\t.update(material)\n\t\t.digest(\"hex\")\n\t\t.slice(0, bytes * 2);\n}\n\n/** El atributo tal y como lo espera OTLP/JSON: clave y valor etiquetado. */\nfunction atributoOtlp(clave: string, valorDelAtributo: string | number | boolean): object {\n\tif (typeof valorDelAtributo === \"boolean\") return { key: clave, value: { boolValue: valorDelAtributo } };\n\tif (typeof valorDelAtributo === \"number\") {\n\t\treturn Number.isInteger(valorDelAtributo)\n\t\t\t? { key: clave, value: { intValue: String(valorDelAtributo) } }\n\t\t\t: { key: clave, value: { doubleValue: valorDelAtributo } };\n\t}\n\treturn { key: clave, value: { stringValue: valorDelAtributo } };\n}\n\n/** Códigos de `SpanKind` de OTLP. Solo se usan estos dos. */\nconst SPAN_KIND_INTERNAL = 1;\nconst SPAN_KIND_CLIENT = 3;\n/** Códigos de `StatusCode`: 0 sin fijar, 2 error. El 1 (`OK`) se reserva. */\nconst STATUS_UNSET = 0;\nconst STATUS_ERROR = 2;\n\n/** ¿El suceso terminó mal? Se mira la forma, nunca el texto del error. */\nfunction fueError(suceso: Record<string, unknown>): boolean {\n\tif (suceso.ok === false) return true;\n\tif (typeof suceso.codigo === \"number\" && suceso.codigo !== 0) return true;\n\tif (suceso.permitido === false) return true;\n\treturn false;\n}\n\n/**\n * Un span de OTLP a partir de una entrada del libro.\n *\n * `traceId` sale de la sesión y `spanId` de la sesión más el número de\n * secuencia: los sucesos de una misma sesión cuelgan de la misma traza sin que\n * haya que guardar estado en ningún sitio, y dos procesos que exporten el mismo\n * libro producen los mismos identificadores en vez de duplicar la traza.\n *\n * Si el sello de tiempo no se puede leer, los dos tiempos van a cero y el span\n * lo dice en `ada.sello_ilegible`. Poner la hora actual sería inventarse un\n * dato: en un registro de cumplimiento, una hora inventada es peor que un cero.\n */\nexport function spanDeSuceso(entrada: EntradaDelLibro): object {\n\tconst suceso = (entrada.suceso ?? {}) as Record<string, unknown>;\n\tconst tipo = typeof suceso.tipo === \"string\" ? suceso.tipo : \"desconocido\";\n\tconst atributos = atributosDeSuceso(entrada);\n\n\tconst milis = Date.parse(entrada.ts);\n\tconst ilegible = Number.isNaN(milis);\n\tif (ilegible) atributos[\"ada.sello_ilegible\"] = true;\n\tconst inicio = ilegible ? 0n : BigInt(milis) * 1_000_000n;\n\tconst duracion =\n\t\ttypeof suceso.duracionMs === \"number\" && suceso.duracionMs > 0 ? BigInt(Math.round(suceso.duracionMs)) : 0n;\n\n\treturn {\n\t\ttraceId: hex(`traza:${entrada.sesion}`, 16),\n\t\tspanId: hex(`span:${entrada.sesion}:${entrada.seq}`, 8),\n\t\tname: `ada.${tipo}`,\n\t\tkind: tipo === \"red\" || tipo === \"modelo\" ? SPAN_KIND_CLIENT : SPAN_KIND_INTERNAL,\n\t\tstartTimeUnixNano: String(inicio),\n\t\tendTimeUnixNano: String(inicio + duracion * 1_000_000n),\n\t\tattributes: Object.entries(atributos).map(([clave, v]) => atributoOtlp(clave, v)),\n\t\t// El estado va sin `message`: el texto de un error es contenido, y este\n\t\t// es el hueco por donde se colaria.\n\t\tstatus: { code: fueError(suceso) ? STATUS_ERROR : STATUS_UNSET },\n\t};\n}\n\n/** Lo que se anuncia como productor de las trazas. Nada de esto es un dato del usuario. */\nconst RECURSO: readonly (readonly [string, string])[] = [\n\t[\"service.name\", \"ada\"],\n\t[\"telemetry.sdk.name\", \"ada-libro-de-sesion\"],\n\t[\"telemetry.sdk.language\", \"nodejs\"],\n];\n\n/**\n * El cuerpo `ResourceSpans` de OTLP/JSON, listo para que otro lo suba.\n *\n * La forma es la del estándar y no se improvisa:\n * `resourceSpans[] -> scopeSpans[] -> spans[]`, con `traceId` y `spanId` en\n * hexadecimal y los tiempos en nanosegundos desde epoch como cadena, porque son\n * enteros de 64 bits y un `number` de JavaScript no los sostiene.\n *\n * Una lista vacía devuelve un cuerpo con cero spans y NO un cuerpo vacío: el\n * colector tiene que poder distinguir «esta sesión no tuvo sucesos» de «no se\n * exportó nada».\n */\nexport function cuerpoOtlp(entradas: readonly EntradaDelLibro[]): object {\n\treturn {\n\t\tresourceSpans: [\n\t\t\t{\n\t\t\t\tresource: { attributes: RECURSO.map(([clave, v]) => atributoOtlp(clave, v)) },\n\t\t\t\tscopeSpans: [\n\t\t\t\t\t{\n\t\t\t\t\t\tscope: { name: \"ada.core.audit.libro\", version: \"1\" },\n\t\t\t\t\t\tspans: entradas.map(spanDeSuceso),\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t},\n\t\t],\n\t};\n}\n"]}

package/dist/core/tools/coercion-argumentos.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Coerción de argumentos para TODAS las herramientas, en el paquete que viaja.
+ *
+ * POR QUÉ EXISTE. `packages/ai` tiene la misma lógica dentro de
+ * `validateToolArguments`, pero ese paquete NO llega al cliente: el tarball de
+ * `@hoilab/ada-cli` resuelve `@earendil-works/pi-ai` del registro de npm, así
+ * que quien instala recibe el de upstream. Medido: 2.066 ficheros en el
+ * paquete, cero de `pi-ai`.
+ *
+ * `edit` ya quedó cubierto porque tiene su propio `prepareArguments`. Esto lo
+ * extiende al resto sin depender de que cada herramienta se acuerde: se aplica
+ * en los dos embudos por los que pasan todas.
+ *
+ * QUÉ ARREGLA, medido contra un modelo gratuito: el modelo manda un argumento
+ * que el esquema declara array u objeto **como cadena de JSON**, y encima con
+ * caracteres de control crudos dentro —18 tabuladores en la carga real— que el
+ * JSON prohíbe. Sin esto, la llamada se rechaza y se pierde el turno entero.
+ *
+ * LO QUE NO HACE, y es lo que la mantiene honesta:
+ *
+ *   · solo mira las propiedades de primer nivel, que es donde los modelos
+ *     ponen el JSON en cadena; no reescribe el argumento en profundidad;
+ *   · solo actúa si el esquema pide array u objeto. Una cadena que se quería
+ *     cadena no se toca — un comando de `bash` que empieza por `[` sigue
+ *     siendo un comando;
+ *   · solo acepta el resultado si parsea EXACTAMENTE al tipo pedido;
+ *   · si no parsea, devuelve el valor intacto para que el error de validación
+ *     siga siendo el que le dice al modelo qué forma esperábamos.
+ */
+/**
+ * Convierte las propiedades que llegaron como cadena de JSON y deberían ser
+ * array u objeto. Devuelve el MISMO objeto si no hubo nada que cambiar, para
+ * que quien compare por referencia siga pudiendo.
+ */
+export declare function coercionarArgumentos(args: unknown, parametros: unknown): unknown;
+/**
+ * Envuelve una herramienta para que sus argumentos pasen por la coerción.
+ *
+ * Se compone con el `prepareArguments` que la herramienta ya tuviera: primero
+ * la coerción genérica, después el suyo. El orden importa — el de `edit`
+ * convierte un edit suelto en una lista de uno, y para eso necesita que `edits`
+ * ya sea lo que dice ser.
+ */
+export declare function conCoercionDeArgumentos<T extends {
+    parameters?: unknown;
+    prepareArguments?: (x: unknown) => unknown;
+}>(herramienta: T): T;
+//# sourceMappingURL=coercion-argumentos.d.ts.map

package/dist/core/tools/coercion-argumentos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coercion-argumentos.d.ts","sourceRoot":"","sources":["../../../src/core/tools/coercion-argumentos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAgBH;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAgChF;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS;IAAE,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;CAAE,EACrH,WAAW,EAAE,CAAC,GACZ,CAAC,CASH","sourcesContent":["/**\n * Coerción de argumentos para TODAS las herramientas, en el paquete que viaja.\n *\n * POR QUÉ EXISTE. `packages/ai` tiene la misma lógica dentro de\n * `validateToolArguments`, pero ese paquete NO llega al cliente: el tarball de\n * `@hoilab/ada-cli` resuelve `@earendil-works/pi-ai` del registro de npm, así\n * que quien instala recibe el de upstream. Medido: 2.066 ficheros en el\n * paquete, cero de `pi-ai`.\n *\n * `edit` ya quedó cubierto porque tiene su propio `prepareArguments`. Esto lo\n * extiende al resto sin depender de que cada herramienta se acuerde: se aplica\n * en los dos embudos por los que pasan todas.\n *\n * QUÉ ARREGLA, medido contra un modelo gratuito: el modelo manda un argumento\n * que el esquema declara array u objeto **como cadena de JSON**, y encima con\n * caracteres de control crudos dentro —18 tabuladores en la carga real— que el\n * JSON prohíbe. Sin esto, la llamada se rechaza y se pierde el turno entero.\n *\n * LO QUE NO HACE, y es lo que la mantiene honesta:\n *\n *   · solo mira las propiedades de primer nivel, que es donde los modelos\n *     ponen el JSON en cadena; no reescribe el argumento en profundidad;\n *   · solo actúa si el esquema pide array u objeto. Una cadena que se quería\n *     cadena no se toca — un comando de `bash` que empieza por `[` sigue\n *     siendo un comando;\n *   · solo acepta el resultado si parsea EXACTAMENTE al tipo pedido;\n *   · si no parsea, devuelve el valor intacto para que el error de validación\n *     siga siendo el que le dice al modelo qué forma esperábamos.\n */\n\nimport { parsearJsonTolerante } from \"./json-tolerante.ts\";\n\n/** Lo mínimo que necesitamos de un esquema JSON para decidir. */\ninterface EsquemaMinimo {\n\tproperties?: Record<string, { type?: unknown } | undefined>;\n}\n\nfunction tipoDe(esquema: { type?: unknown } | undefined): string[] {\n\tconst t = esquema?.type;\n\tif (typeof t === \"string\") return [t];\n\tif (Array.isArray(t)) return t.filter((x): x is string => typeof x === \"string\");\n\treturn [];\n}\n\n/**\n * Convierte las propiedades que llegaron como cadena de JSON y deberían ser\n * array u objeto. Devuelve el MISMO objeto si no hubo nada que cambiar, para\n * que quien compare por referencia siga pudiendo.\n */\nexport function coercionarArgumentos(args: unknown, parametros: unknown): unknown {\n\tif (!args || typeof args !== \"object\" || Array.isArray(args)) return args;\n\tconst propiedades = (parametros as EsquemaMinimo | undefined)?.properties;\n\tif (!propiedades) return args;\n\n\tconst objeto = args as Record<string, unknown>;\n\tfor (const [clave, esquema] of Object.entries(propiedades)) {\n\t\tconst valor = objeto[clave];\n\t\tif (typeof valor !== \"string\") continue;\n\t\tconst tipos = tipoDe(esquema);\n\t\tconst quiereArray = tipos.includes(\"array\");\n\t\tconst quiereObjeto = tipos.includes(\"object\");\n\t\tif (!quiereArray && !quiereObjeto) continue;\n\n\t\tconst recortado = valor.trim();\n\t\t// El primer carácter descarta casi todo sin pagar un parseo, y evita\n\t\t// convertir `\"12\"` o `\"true\"` en algo que el esquema no pidió.\n\t\tconst abre = quiereArray ? \"[\" : \"{\";\n\t\tif (!recortado.startsWith(abre)) continue;\n\n\t\ttry {\n\t\t\tconst parsed = parsearJsonTolerante(recortado);\n\t\t\tconst encaja = quiereArray\n\t\t\t\t? Array.isArray(parsed)\n\t\t\t\t: typeof parsed === \"object\" && parsed !== null && !Array.isArray(parsed);\n\t\t\tif (encaja) objeto[clave] = parsed;\n\t\t} catch {\n\t\t\t// Intacto a propósito: el error de validación posterior es la pista que\n\t\t\t// el modelo necesita para reintentar con la forma correcta.\n\t\t}\n\t}\n\treturn objeto;\n}\n\n/**\n * Envuelve una herramienta para que sus argumentos pasen por la coerción.\n *\n * Se compone con el `prepareArguments` que la herramienta ya tuviera: primero\n * la coerción genérica, después el suyo. El orden importa — el de `edit`\n * convierte un edit suelto en una lista de uno, y para eso necesita que `edits`\n * ya sea lo que dice ser.\n */\nexport function conCoercionDeArgumentos<T extends { parameters?: unknown; prepareArguments?: (x: unknown) => unknown }>(\n\therramienta: T,\n): T {\n\tconst propio = herramienta.prepareArguments;\n\treturn {\n\t\t...herramienta,\n\t\tprepareArguments: (entrada: unknown) => {\n\t\t\tconst coercionado = coercionarArgumentos(entrada, herramienta.parameters);\n\t\t\treturn propio ? propio(coercionado) : coercionado;\n\t\t},\n\t};\n}\n"]}

package/dist/core/tools/coercion-argumentos.js

@@ -0,0 +1,99 @@
+/**
+ * Coerción de argumentos para TODAS las herramientas, en el paquete que viaja.
+ *
+ * POR QUÉ EXISTE. `packages/ai` tiene la misma lógica dentro de
+ * `validateToolArguments`, pero ese paquete NO llega al cliente: el tarball de
+ * `@hoilab/ada-cli` resuelve `@earendil-works/pi-ai` del registro de npm, así
+ * que quien instala recibe el de upstream. Medido: 2.066 ficheros en el
+ * paquete, cero de `pi-ai`.
+ *
+ * `edit` ya quedó cubierto porque tiene su propio `prepareArguments`. Esto lo
+ * extiende al resto sin depender de que cada herramienta se acuerde: se aplica
+ * en los dos embudos por los que pasan todas.
+ *
+ * QUÉ ARREGLA, medido contra un modelo gratuito: el modelo manda un argumento
+ * que el esquema declara array u objeto **como cadena de JSON**, y encima con
+ * caracteres de control crudos dentro —18 tabuladores en la carga real— que el
+ * JSON prohíbe. Sin esto, la llamada se rechaza y se pierde el turno entero.
+ *
+ * LO QUE NO HACE, y es lo que la mantiene honesta:
+ *
+ *   · solo mira las propiedades de primer nivel, que es donde los modelos
+ *     ponen el JSON en cadena; no reescribe el argumento en profundidad;
+ *   · solo actúa si el esquema pide array u objeto. Una cadena que se quería
+ *     cadena no se toca — un comando de `bash` que empieza por `[` sigue
+ *     siendo un comando;
+ *   · solo acepta el resultado si parsea EXACTAMENTE al tipo pedido;
+ *   · si no parsea, devuelve el valor intacto para que el error de validación
+ *     siga siendo el que le dice al modelo qué forma esperábamos.
+ */
+import { parsearJsonTolerante } from "./json-tolerante.js";
+function tipoDe(esquema) {
+    const t = esquema?.type;
+    if (typeof t === "string")
+        return [t];
+    if (Array.isArray(t))
+        return t.filter((x) => typeof x === "string");
+    return [];
+}
+/**
+ * Convierte las propiedades que llegaron como cadena de JSON y deberían ser
+ * array u objeto. Devuelve el MISMO objeto si no hubo nada que cambiar, para
+ * que quien compare por referencia siga pudiendo.
+ */
+export function coercionarArgumentos(args, parametros) {
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        return args;
+    const propiedades = parametros?.properties;
+    if (!propiedades)
+        return args;
+    const objeto = args;
+    for (const [clave, esquema] of Object.entries(propiedades)) {
+        const valor = objeto[clave];
+        if (typeof valor !== "string")
+            continue;
+        const tipos = tipoDe(esquema);
+        const quiereArray = tipos.includes("array");
+        const quiereObjeto = tipos.includes("object");
+        if (!quiereArray && !quiereObjeto)
+            continue;
+        const recortado = valor.trim();
+        // El primer carácter descarta casi todo sin pagar un parseo, y evita
+        // convertir `"12"` o `"true"` en algo que el esquema no pidió.
+        const abre = quiereArray ? "[" : "{";
+        if (!recortado.startsWith(abre))
+            continue;
+        try {
+            const parsed = parsearJsonTolerante(recortado);
+            const encaja = quiereArray
+                ? Array.isArray(parsed)
+                : typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+            if (encaja)
+                objeto[clave] = parsed;
+        }
+        catch {
+            // Intacto a propósito: el error de validación posterior es la pista que
+            // el modelo necesita para reintentar con la forma correcta.
+        }
+    }
+    return objeto;
+}
+/**
+ * Envuelve una herramienta para que sus argumentos pasen por la coerción.
+ *
+ * Se compone con el `prepareArguments` que la herramienta ya tuviera: primero
+ * la coerción genérica, después el suyo. El orden importa — el de `edit`
+ * convierte un edit suelto en una lista de uno, y para eso necesita que `edits`
+ * ya sea lo que dice ser.
+ */
+export function conCoercionDeArgumentos(herramienta) {
+    const propio = herramienta.prepareArguments;
+    return {
+        ...herramienta,
+        prepareArguments: (entrada) => {
+            const coercionado = coercionarArgumentos(entrada, herramienta.parameters);
+            return propio ? propio(coercionado) : coercionado;
+        },
+    };
+}
+//# sourceMappingURL=coercion-argumentos.js.map

package/dist/core/tools/coercion-argumentos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coercion-argumentos.js","sourceRoot":"","sources":["../../../src/core/tools/coercion-argumentos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAO3D,SAAS,MAAM,CAAC,OAAuC,EAAY;IAClE,MAAM,CAAC,GAAG,OAAO,EAAE,IAAI,CAAC;IACxB,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACtC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC;IACjF,OAAO,EAAE,CAAC;AAAA,CACV;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAa,EAAE,UAAmB,EAAW;IACjF,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1E,MAAM,WAAW,GAAI,UAAwC,EAAE,UAAU,CAAC;IAC1E,IAAI,CAAC,WAAW;QAAE,OAAO,IAAI,CAAC;IAE9B,MAAM,MAAM,GAAG,IAA+B,CAAC;IAC/C,KAAK,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;QAC5D,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,SAAS;QACxC,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QAC9B,MAAM,WAAW,GAAG,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAC5C,MAAM,YAAY,GAAG,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAI,CAAC,WAAW,IAAI,CAAC,YAAY;YAAE,SAAS;QAE5C,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;QAC/B,sEAAqE;QACrE,gEAA+D;QAC/D,MAAM,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;QACrC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,SAAS;QAE1C,IAAI,CAAC;YACJ,MAAM,MAAM,GAAG,oBAAoB,CAAC,SAAS,CAAC,CAAC;YAC/C,MAAM,MAAM,GAAG,WAAW;gBACzB,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;gBACvB,CAAC,CAAC,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAC3E,IAAI,MAAM;gBAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC;QACpC,CAAC;QAAC,MAAM,CAAC;YACR,0EAAwE;YACxE,4DAA4D;QAC7D,CAAC;IACF,CAAC;IACD,OAAO,MAAM,CAAC;AAAA,CACd;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CACtC,WAAc,EACV;IACJ,MAAM,MAAM,GAAG,WAAW,CAAC,gBAAgB,CAAC;IAC5C,OAAO;QACN,GAAG,WAAW;QACd,gBAAgB,EAAE,CAAC,OAAgB,EAAE,EAAE,CAAC;YACvC,MAAM,WAAW,GAAG,oBAAoB,CAAC,OAAO,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;YAC1E,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;QAAA,CAClD;KACD,CAAC;AAAA,CACF","sourcesContent":["/**\n * Coerción de argumentos para TODAS las herramientas, en el paquete que viaja.\n *\n * POR QUÉ EXISTE. `packages/ai` tiene la misma lógica dentro de\n * `validateToolArguments`, pero ese paquete NO llega al cliente: el tarball de\n * `@hoilab/ada-cli` resuelve `@earendil-works/pi-ai` del registro de npm, así\n * que quien instala recibe el de upstream. Medido: 2.066 ficheros en el\n * paquete, cero de `pi-ai`.\n *\n * `edit` ya quedó cubierto porque tiene su propio `prepareArguments`. Esto lo\n * extiende al resto sin depender de que cada herramienta se acuerde: se aplica\n * en los dos embudos por los que pasan todas.\n *\n * QUÉ ARREGLA, medido contra un modelo gratuito: el modelo manda un argumento\n * que el esquema declara array u objeto **como cadena de JSON**, y encima con\n * caracteres de control crudos dentro —18 tabuladores en la carga real— que el\n * JSON prohíbe. Sin esto, la llamada se rechaza y se pierde el turno entero.\n *\n * LO QUE NO HACE, y es lo que la mantiene honesta:\n *\n *   · solo mira las propiedades de primer nivel, que es donde los modelos\n *     ponen el JSON en cadena; no reescribe el argumento en profundidad;\n *   · solo actúa si el esquema pide array u objeto. Una cadena que se quería\n *     cadena no se toca — un comando de `bash` que empieza por `[` sigue\n *     siendo un comando;\n *   · solo acepta el resultado si parsea EXACTAMENTE al tipo pedido;\n *   · si no parsea, devuelve el valor intacto para que el error de validación\n *     siga siendo el que le dice al modelo qué forma esperábamos.\n */\n\nimport { parsearJsonTolerante } from \"./json-tolerante.ts\";\n\n/** Lo mínimo que necesitamos de un esquema JSON para decidir. */\ninterface EsquemaMinimo {\n\tproperties?: Record<string, { type?: unknown } | undefined>;\n}\n\nfunction tipoDe(esquema: { type?: unknown } | undefined): string[] {\n\tconst t = esquema?.type;\n\tif (typeof t === \"string\") return [t];\n\tif (Array.isArray(t)) return t.filter((x): x is string => typeof x === \"string\");\n\treturn [];\n}\n\n/**\n * Convierte las propiedades que llegaron como cadena de JSON y deberían ser\n * array u objeto. Devuelve el MISMO objeto si no hubo nada que cambiar, para\n * que quien compare por referencia siga pudiendo.\n */\nexport function coercionarArgumentos(args: unknown, parametros: unknown): unknown {\n\tif (!args || typeof args !== \"object\" || Array.isArray(args)) return args;\n\tconst propiedades = (parametros as EsquemaMinimo | undefined)?.properties;\n\tif (!propiedades) return args;\n\n\tconst objeto = args as Record<string, unknown>;\n\tfor (const [clave, esquema] of Object.entries(propiedades)) {\n\t\tconst valor = objeto[clave];\n\t\tif (typeof valor !== \"string\") continue;\n\t\tconst tipos = tipoDe(esquema);\n\t\tconst quiereArray = tipos.includes(\"array\");\n\t\tconst quiereObjeto = tipos.includes(\"object\");\n\t\tif (!quiereArray && !quiereObjeto) continue;\n\n\t\tconst recortado = valor.trim();\n\t\t// El primer carácter descarta casi todo sin pagar un parseo, y evita\n\t\t// convertir `\"12\"` o `\"true\"` en algo que el esquema no pidió.\n\t\tconst abre = quiereArray ? \"[\" : \"{\";\n\t\tif (!recortado.startsWith(abre)) continue;\n\n\t\ttry {\n\t\t\tconst parsed = parsearJsonTolerante(recortado);\n\t\t\tconst encaja = quiereArray\n\t\t\t\t? Array.isArray(parsed)\n\t\t\t\t: typeof parsed === \"object\" && parsed !== null && !Array.isArray(parsed);\n\t\t\tif (encaja) objeto[clave] = parsed;\n\t\t} catch {\n\t\t\t// Intacto a propósito: el error de validación posterior es la pista que\n\t\t\t// el modelo necesita para reintentar con la forma correcta.\n\t\t}\n\t}\n\treturn objeto;\n}\n\n/**\n * Envuelve una herramienta para que sus argumentos pasen por la coerción.\n *\n * Se compone con el `prepareArguments` que la herramienta ya tuviera: primero\n * la coerción genérica, después el suyo. El orden importa — el de `edit`\n * convierte un edit suelto en una lista de uno, y para eso necesita que `edits`\n * ya sea lo que dice ser.\n */\nexport function conCoercionDeArgumentos<T extends { parameters?: unknown; prepareArguments?: (x: unknown) => unknown }>(\n\therramienta: T,\n): T {\n\tconst propio = herramienta.prepareArguments;\n\treturn {\n\t\t...herramienta,\n\t\tprepareArguments: (entrada: unknown) => {\n\t\t\tconst coercionado = coercionarArgumentos(entrada, herramienta.parameters);\n\t\t\treturn propio ? propio(coercionado) : coercionado;\n\t\t},\n\t};\n}\n"]}

package/dist/core/tools/edit-diff.d.ts

@@ -4,13 +4,6 @@
 export declare function detectLineEnding(content: string): "\r\n" | "\n";
 export declare function normalizeToLF(text: string): string;
 export declare function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string;
-/**
- * Normalize text for fuzzy matching. Applies progressive transformations:
- * - Strip trailing whitespace from each line
- * - Normalize smart quotes to ASCII equivalents
- * - Normalize Unicode dashes/hyphens to ASCII hyphen
- * - Normalize special Unicode spaces to regular space
- */
 export declare function normalizeForFuzzyMatch(text: string): string;
 interface MatchedEdit {
     editIndex: number;