@hostwebhook/node-types 1.85.0 → 1.87.0

package/dist/esm/sentiment.js

@@ -0,0 +1,53 @@
+/**
+ * Sentiment analysis en el AI Node — las etiquetas, los puertos y el orden.
+ *
+ * ## Por qué vive aquí y no en cada repo
+ *
+ * Las tres etiquetas son a la vez TRES cosas: el `enum` del esquema que se le
+ * da al modelo, el nombre de los puertos por los que el nodo despacha, y las
+ * pastillas de la tarjeta del lienzo. Si el api, hw-nodes y el dashboard
+ * escriben su propia lista, la primera que alguien reordene o rebautice deja
+ * una arista apuntando a un puerto que ya no existe — y eso no lo dice ningún
+ * compilador. Es el mismo motivo por el que las operaciones de cada nodo
+ * viven en este paquete.
+ *
+ * ## Por qué `unclear` no es una etiqueta más
+ *
+ * El modelo elige entre las TRES de `SENTIMENT_LABELS`; `unclear` no se le
+ * ofrece nunca. Es lo que hace el NODO cuando la confianza queda por debajo
+ * del umbral (`sentimentThreshold`) o cuando la respuesta no se puede leer.
+ * Ofrecérsela al modelo sería darle una salida cómoda para no mojarse, que es
+ * justo lo contrario de lo que se busca al poner un umbral.
+ *
+ * A diferencia del `other` del clasificador, `unclear` SÍ tiene puerto: el
+ * caso de uso es mandar a revisión humana lo que el modelo no ve claro, y sin
+ * puerto eso obligaba a adivinar por qué un item no salió por ninguna rama.
+ */
+/** Lo que el modelo puede contestar, en orden de peor a mejor. */
+export const SENTIMENT_LABELS = ['negative', 'neutral', 'positive'];
+/** La salida del nodo cuando no hay etiqueta fiable. No se le ofrece al modelo. */
+export const SENTIMENT_UNCLEAR = 'unclear';
+/** Los cuatro puertos del modo sentiment, en el orden en que se pintan. */
+export const SENTIMENT_PORTS = [
+    ...SENTIMENT_LABELS,
+    SENTIMENT_UNCLEAR,
+];
+/** El nombre que ve la persona, por puerto. */
+export const SENTIMENT_PORT_LABEL = {
+    negative: 'Negative',
+    neutral: 'Neutral',
+    positive: 'Positive',
+    unclear: 'Unclear',
+};
+/** Qué significa cada puerto, para el modal de conexión y la doc. */
+export const SENTIMENT_PORT_SUMMARY = {
+    negative: 'Complaints, frustration, criticism',
+    neutral: 'Factual, mixed, or no clear feeling',
+    positive: 'Praise, satisfaction, enthusiasm',
+    unclear: 'Below the confidence floor, or unreadable',
+};
+/** ¿Es una de las tres que el modelo puede contestar? */
+export function esEtiquetaDeSentimiento(v) {
+    return (typeof v === 'string' &&
+        SENTIMENT_LABELS.includes(v));
+}

package/dist/esm/sheets-toolkit.d.ts

@@ -34,7 +34,8 @@ export interface SheetsToolkitSpec {
     toolName: string;
     description: string;
     parameters: SheetsToolkitParameter[];
-    /** Escribe en la hoja del usuario. Lo usa la confirmación previa del AI Node. */
+    /** Pisa o borra. Lo pone `marcarDestructivas` leyendo el verbo del
+     *  nombre (ver `clase-de-herramienta.ts`), no se escribe a mano. */
     destructive?: boolean;
 }
 export declare const SHEETS_TOOLKIT_SPECS: SheetsToolkitSpec[];

package/dist/esm/sheets-toolkit.js

@@ -19,6 +19,7 @@
  * pueda usarse sin adaptador. Los textos van en inglés porque los lee el modelo
  * y quien mire la lista de herramientas del servidor MCP.
  */
+import { marcarDestructivas } from './clase-de-herramienta.js';
 const p = (name, description, required = true, type = 'string') => ({ name, type, description, required });
 /*
  * La hoja y la pestaña del nodo van como **defecto**, y el modelo puede
@@ -41,14 +42,13 @@ const p = (name, description, required = true, type = 'string') => ({ name, type
 const hoja = () => p('spreadsheetId', "Id of the Google Sheets document — the long chunk of its URL, between /d/ and /edit.");
 const pestana = () => p('sheetName', 'Name of the tab inside the document, exactly as it reads on its tab strip.');
 const fila = (que) => p('row', `JSON object holding ${que}. Keys are the sheet's **header names**, spelled exactly as they appear in its title row: {"Name": "Ariel", "Email": "a@b.c"}. A key that is not a header makes the call fail, so when you do not know the headers, call get_rows first.`);
-export const SHEETS_TOOLKIT_SPECS = [
+export const SHEETS_TOOLKIT_SPECS = marcarDestructivas([
     {
         operation: 'appendRow',
         label: 'Append row',
         toolName: 'append_row',
         description: 'Add a new row at the bottom of the tab. It does not check whether the row already exists — when it might, use append_or_update_row instead so you do not duplicate it.',
         parameters: [fila('the values of the new row'), hoja(), pestana()],
-        destructive: true,
     },
     {
         operation: 'updateRow',
@@ -62,7 +62,6 @@ export const SHEETS_TOOLKIT_SPECS = [
             hoja(),
             pestana(),
         ],
-        destructive: true,
     },
     {
         operation: 'appendOrUpdateRow',
@@ -76,7 +75,6 @@ export const SHEETS_TOOLKIT_SPECS = [
             hoja(),
             pestana(),
         ],
-        destructive: true,
     },
     {
         operation: 'readRange',
@@ -113,9 +111,8 @@ export const SHEETS_TOOLKIT_SPECS = [
          * en el nodo, y la api la aplica.
          */
         parameters: [p('title', 'Name of the new document.')],
-        destructive: true,
     },
-];
+]);
 /** Las herramientas por nombre, para despachar una llamada del modelo. */
 export const SHEETS_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(SHEETS_TOOLKIT_SPECS.map((s) => [s.toolName, s]));
 /**

package/dist/esm/slack-toolkit.d.ts

@@ -38,9 +38,8 @@ export interface SlackToolkitSpec {
     /** Descripción (más reglas de uso) que ve el LLM. */
     description: string;
     parameters: SlackToolkitParameter[];
-    /** Operaciones irreversibles o que cambian privilegios. La capa MCP las
-     *  bloquea cuando el nodo de IA lleva `requireConfirmationForDestructive`,
-     *  salvo que la llamada traiga confirmación explícita. */
+    /** Pisa o borra. Lo pone `marcarDestructivas` leyendo el verbo del
+     *  nombre (ver `clase-de-herramienta.ts`), no se escribe a mano. */
     destructive?: boolean;
 }
 export declare const SLACK_TOOLKIT_SPECS: SlackToolkitSpec[];

package/dist/esm/slack-toolkit.js

@@ -23,8 +23,9 @@
  * y quien mire la lista de herramientas del servidor MCP.
  */
 import { camposDeSlackNoDisponibles, operacionesDeSlackPara, } from './slack-operations.js';
+import { marcarDestructivas } from './clase-de-herramienta.js';
 const p = (name, description, required = true, type = 'string') => ({ name, type, description, required });
-export const SLACK_TOOLKIT_SPECS = [
+export const SLACK_TOOLKIT_SPECS = marcarDestructivas([
     // ── Messages ─────────────────────────────────────────────────────
     {
         operation: 'sendMessage',
@@ -63,7 +64,6 @@ export const SLACK_TOOLKIT_SPECS = [
             p('channel', 'Channel where the message lives.'),
             p('ts', 'Timestamp of the message to delete.'),
         ],
-        destructive: true,
     },
     {
         operation: 'sendEphemeral',
@@ -142,7 +142,6 @@ export const SLACK_TOOLKIT_SPECS = [
             p('name', 'Channel name — lowercase, no spaces, max 80 chars.'),
             p('isPrivate', 'Create a private channel instead of public. Default false.', false, 'boolean'),
         ],
-        destructive: true,
     },
     {
         operation: 'inviteToChannel',
@@ -212,7 +211,7 @@ export const SLACK_TOOLKIT_SPECS = [
             p('threadTs', 'Thread to attach the file to.', false),
         ],
     },
-];
+]);
 export const SLACK_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(SLACK_TOOLKIT_SPECS.map((s) => [s.toolName, s]));
 /**
  * Las herramientas que ofrecerle al modelo con ESTA credencial.

package/dist/esm/telegram-toolkit.d.ts

@@ -39,6 +39,9 @@ export interface TelegramToolkitSpec {
     /** Descripción (más reglas de uso) que ve el LLM. */
     description: string;
     parameters: TelegramToolkitParameter[];
+    /** Pisa o borra. Lo pone `marcarDestructivas` leyendo el verbo del
+     *  nombre (ver `clase-de-herramienta.ts`), no se escribe a mano. */
+    destructive?: boolean;
     /**
      * Encabezado de grupo para la lista de la página de detalle. Las filas
      * consecutivas que comparten grupo se pintan bajo un único título, así que el

package/dist/esm/telegram-toolkit.js

@@ -19,6 +19,7 @@
  * usarse sin adaptador. Los textos van en inglés porque los lee el modelo y
  * quien mire la lista de herramientas del servidor MCP.
  */
+import { marcarDestructivas } from './clase-de-herramienta.js';
 const p = (name, description, required = true, type = 'string') => ({ name, type, description, required });
 /*
  * `sendAndWaitForResponse` NO está aquí, y es una decisión, no un olvido: la op
@@ -33,7 +34,7 @@ const p = (name, description, required = true, type = 'string') => ({ name, type
  * campo en ninguna de las dos capas, y añadirlo cambiaría cuándo el AI Node pide
  * confirmación. Eso es otra decisión, no parte de mudar el esquema de sitio.
  */
-export const TELEGRAM_TOOLKIT_SPECS = [
+export const TELEGRAM_TOOLKIT_SPECS = marcarDestructivas([
     {
         operation: 'sendMessage',
         label: 'Send message',
@@ -178,6 +179,6 @@ export const TELEGRAM_TOOLKIT_SPECS = [
             p('showAlert', 'Optional. true = modal alert; false (default) = toast notification.', false, 'boolean'),
         ],
     },
-];
+]);
 /** Las herramientas por nombre, para despachar una llamada del modelo. */
 export const TELEGRAM_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(TELEGRAM_TOOLKIT_SPECS.map((s) => [s.toolName, s]));

package/dist/esm/toolkits.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Los toolkits por tipo de nodo: qué herramientas expone cada nodo en modo
+ * AI toolkit, en un solo sitio.
+ *
+ * ## Para qué (2026-09-24)
+ *
+ * Para que el gate «Block destructive tool calls» del AI Node pueda preguntar
+ * por la OPERACIÓN y no sólo por el nombre. Hasta hoy sólo miraba el nombre
+ * contra unos patrones (`delete_*`, `drop_*`…), así que `update_row` de Sheets
+ * —que pisa una fila— pasaba con el gate encendido. Con esto, la herramienta
+ * que el AI Node guardó al conectar (`nodeRefType` + `operationOverride`) se
+ * resuelve aquí a su operación, y su `destructive` —que sale del verbo, ver
+ * `clase-de-herramienta.ts`— decide.
+ *
+ * ## Lo que falta aquí, a propósito
+ *
+ * WhatsApp y Contacts siguen con sus specs escritos a mano en la api y en el
+ * dashboard, no en este paquete. Hasta que se muden, quien consulte este
+ * registro tiene que componerlos por su lado — {@link esOperacionDestructiva}
+ * devuelve `null` para ellos, que significa «no lo sé», no «no es
+ * destructiva».
+ */
+/** Lo mínimo de una herramienta de toolkit que hace falta para decidir. */
+export interface OperacionDeToolkit {
+    operation: string;
+    toolName: string;
+    label: string;
+    destructive?: boolean;
+}
+export declare const TOOLKITS_POR_TIPO: Readonly<Record<string, readonly OperacionDeToolkit[]>>;
+/**
+ * La operación de un toolkit, buscada por su nombre interno (`updateRow`) O
+ * por el nombre de su herramienta (`update_row`).
+ *
+ * Las dos formas porque las dos llegan: el AI Node guarda `operationOverride`
+ * con el nombre interno, y el servidor MCP recibe el nombre de la herramienta.
+ */
+export declare function operacionDeToolkit(nodeType: string | undefined | null, operacionONombre: string | undefined | null): OperacionDeToolkit | null;
+/**
+ * ¿Es destructiva esta operación de toolkit?
+ *
+ * `null` cuando no se sabe —el tipo no es un toolkit de este paquete, o la
+ * operación no existe en él—. Quien llama decide qué hace con el «no sé»; el
+ * gate del AI Node lo combina con los patrones de nombre, que siguen ahí para
+ * las herramientas que no son de toolkit (MCP, HTTP…).
+ */
+export declare function esOperacionDestructiva(nodeType: string | undefined | null, operacionONombre: string | undefined | null): boolean | null;

package/dist/esm/toolkits.js

@@ -0,0 +1,74 @@
+/**
+ * Los toolkits por tipo de nodo: qué herramientas expone cada nodo en modo
+ * AI toolkit, en un solo sitio.
+ *
+ * ## Para qué (2026-09-24)
+ *
+ * Para que el gate «Block destructive tool calls» del AI Node pueda preguntar
+ * por la OPERACIÓN y no sólo por el nombre. Hasta hoy sólo miraba el nombre
+ * contra unos patrones (`delete_*`, `drop_*`…), así que `update_row` de Sheets
+ * —que pisa una fila— pasaba con el gate encendido. Con esto, la herramienta
+ * que el AI Node guardó al conectar (`nodeRefType` + `operationOverride`) se
+ * resuelve aquí a su operación, y su `destructive` —que sale del verbo, ver
+ * `clase-de-herramienta.ts`— decide.
+ *
+ * ## Lo que falta aquí, a propósito
+ *
+ * WhatsApp y Contacts siguen con sus specs escritos a mano en la api y en el
+ * dashboard, no en este paquete. Hasta que se muden, quien consulte este
+ * registro tiene que componerlos por su lado — {@link esOperacionDestructiva}
+ * devuelve `null` para ellos, que significa «no lo sé», no «no es
+ * destructiva».
+ */
+import { GMAIL_ALL_TOOLKIT_SPECS, NATIVE_EMAIL_TOOLKIT_SPECS } from './gmail-operations.js';
+import { GOOGLE_CALENDAR_TOOLKIT_SPECS } from './calendar-toolkit.js';
+import { DRIVE_TOOLKIT_SPECS } from './drive-toolkit.js';
+import { TELEGRAM_TOOLKIT_SPECS } from './telegram-toolkit.js';
+import { DISCORD_TOOLKIT_SPECS } from './discord-toolkit.js';
+import { SLACK_TOOLKIT_SPECS } from './slack-toolkit.js';
+import { SHEETS_TOOLKIT_SPECS } from './sheets-toolkit.js';
+import { DOCS_TOOLKIT_SPECS } from './docs-toolkit.js';
+import { MONGO_TOOLKIT_SPECS } from './mongo-toolkit.js';
+import { POSTGRES_TOOLKIT_SPECS } from './postgres-toolkit.js';
+export const TOOLKITS_POR_TIPO = Object.freeze({
+    gmailAction: GMAIL_ALL_TOOLKIT_SPECS,
+    emailAction: NATIVE_EMAIL_TOOLKIT_SPECS,
+    calendarAction: GOOGLE_CALENDAR_TOOLKIT_SPECS,
+    driveAction: DRIVE_TOOLKIT_SPECS,
+    telegramAction: TELEGRAM_TOOLKIT_SPECS,
+    discordAction: DISCORD_TOOLKIT_SPECS,
+    slackAction: SLACK_TOOLKIT_SPECS,
+    sheetsAction: SHEETS_TOOLKIT_SPECS,
+    docsAction: DOCS_TOOLKIT_SPECS,
+    mongoAction: MONGO_TOOLKIT_SPECS,
+    postgresAction: POSTGRES_TOOLKIT_SPECS,
+});
+/**
+ * La operación de un toolkit, buscada por su nombre interno (`updateRow`) O
+ * por el nombre de su herramienta (`update_row`).
+ *
+ * Las dos formas porque las dos llegan: el AI Node guarda `operationOverride`
+ * con el nombre interno, y el servidor MCP recibe el nombre de la herramienta.
+ */
+export function operacionDeToolkit(nodeType, operacionONombre) {
+    if (!nodeType || !operacionONombre)
+        return null;
+    const toolkit = TOOLKITS_POR_TIPO[nodeType];
+    if (!toolkit)
+        return null;
+    return (toolkit.find((s) => s.operation === operacionONombre) ??
+        toolkit.find((s) => s.toolName === operacionONombre) ??
+        null);
+}
+/**
+ * ¿Es destructiva esta operación de toolkit?
+ *
+ * `null` cuando no se sabe —el tipo no es un toolkit de este paquete, o la
+ * operación no existe en él—. Quien llama decide qué hace con el «no sé»; el
+ * gate del AI Node lo combina con los patrones de nombre, que siguen ahí para
+ * las herramientas que no son de toolkit (MCP, HTTP…).
+ */
+export function esOperacionDestructiva(nodeType, operacionONombre) {
+    const op = operacionDeToolkit(nodeType, operacionONombre);
+    return op ? op.destructive === true : null;
+}

package/dist/esm/types.d.ts

@@ -54,83 +54,15 @@ export interface NodeUIConfig {
         connectModal?: 'branch' | 'output-group';
         routerTargetLabel?: string;
         /**
-         * Generic named output groups — used by connectModal: 'output-group'.
-         * The modal reads entity[outputGroupsField] as an array of groups,
-         * each with a name (outputGroupNameField), a summary (outputGroupSummaryField),
-         * and its own outputNodes[].
-         * Works for Split (outputs[]), Conditional (branches[]), or any future branching node.
+         * Los juegos de salidas de un nodo que ramifica: UNO, o VARIOS con su
+         * `gate` cada uno [2026-09-22]. Con varios, quien pregunta se queda con
+         * el PRIMERO cuya puerta pasa — ver `outputGroupsFor`. El AI Node los
+         * necesita porque ramifica de dos maneras según el modo: por las
+         * categorías que escribe el usuario (`classifier`) o por los cuatro
+         * puertos fijos del análisis de sentimiento (`sentiment`). La forma
+         * vieja (un objeto suelto) sigue valiendo y significa «sin alternativas».
          */
-        outputGroups?: {
-            /** Entity field containing the array of groups (e.g. 'outputs', 'branches') */
-            field?: string;
-            /** Field within each group for display name (e.g. 'name') */
-            nameField?: string;
-            /** Field within each group for summary/description (e.g. 'field', 'filterMode') */
-            summaryField?: string;
-            /**
-             * Varios campos del grupo, unidos por espacios, cuando el resumen que
-             * de verdad identifica al grupo no cabe en uno solo.
-             *
-             * Existe por las reglas del router: su condición son TRES campos
-             * (`field`, `operator`, `value`) y el modal a medida que se retiró las
-             * pintaba juntas — «status eq active». Con un único `summaryField` una
-             * regla sin `label` quedaba en «rule 1» y «status», que no dice a qué
-             * se está conectando uno.
-             *
-             * Los campos vacíos se saltan, para que una regla con operador
-             * `exists` no salga con un espacio colgando al final.
-             */
-            summaryFields?: string[];
-            /** Label shown in the modal (e.g. 'output', 'branch') */
-            label: string;
-            /** Entity field for the fallback/else path (e.g. 'elseOutputNodes') */
-            elseField?: string;
-            /**
-             * Fixed output groups — for nodes with a static set of outputs (e.g. approval: approve/reject).
-             * Each entry maps to a top-level entity field that holds outputNodes[].
-             * When set, `field`/`nameField` are ignored — modal shows these fixed options.
-             */
-            fixedGroups?: Array<{
-                name: string;
-                field: string;
-            }>;
-            /**
-             * Optional content-aware gate — the output-group modal only opens
-             * when `entity[gate.field] === gate.value`. Lets a node opt into
-             * multi-branch routing only in some modes (e.g. AI Node in
-             * classifier mode) without trapping every connection in the
-             * picker the rest of the time. When the gate fails, the
-             * FlowCanvas falls through to the universal
-             * `entity.outputNodes` connect path.
-             */
-            gate?: {
-                field: string;
-                value: unknown;
-            };
-            /**
-             * Qué es el puerto `main` de este nodo MIENTRAS su contenedor está
-             * vacío. Sin esto, conectar a un nodo que ramifica y todavía no tiene
-             * ninguna salida escribía una arista en `main` **en silencio**, y el
-             * usuario no tenía forma de saber qué había pasado con ella.
-             *
-             * No hay una respuesta única, y por eso es un dato y no una regla.
-             * Medido en `api/src/common/pipeline-run.service.ts`:
-             *
-             *   'passthrough'       — router sin reglas: `rules.length === 0
-             *                         ? refsForPort(entity, MAIN_PORT) : []`. La
-             *                         arista SÍ dispara... hasta que se cree la
-             *                         primera regla, y entonces deja de hacerlo
-             *                         sin avisar.
-             *   'never-dispatched'  — split: no tiene salida `main`, y el propio
-             *                         despachador registra un warning por cada
-             *                         arista que se quedó en ese puerto.
-             *
-             * Se declara sólo donde se ha medido. Sin declarar, el lienzo se
-             * comporta como siempre: conecta por el camino universal y no dice
-             * nada, que es lo que hacía antes de existir este campo.
-             */
-            emptyContainerMain?: 'passthrough' | 'never-dispatched';
-        };
+        outputGroups?: OutputGroupsConfig | OutputGroupsConfig[];
         /**
          * Maps output fields to alternate payload fields on the source entity.
          * When a downstream node is connected via a specific output field,
@@ -224,3 +156,106 @@ export interface PrefixMapping {
     /** Canvas node type used in React Flow nodeTypes map (e.g. "cache-node", "email-action") */
     canvasType: string;
 }
+/**
+ * Un juego de salidas de un nodo que ramifica.
+ *
+ * Vivía dentro de `NodeUIConfig.special` como un objeto anónimo; sale aquí
+ * [2026-09-22] para poder declarar varios por nodo y para que quien los lea
+ * nombre el tipo en vez de repetir su forma.
+ */
+export interface OutputGroupsConfig {
+    /** Entity field containing the array of groups (e.g. 'outputs', 'branches') */
+    field?: string;
+    /** Field within each group for display name (e.g. 'name') */
+    nameField?: string;
+    /** Field within each group for summary/description (e.g. 'field', 'filterMode') */
+    summaryField?: string;
+    /**
+     * Varios campos del grupo, unidos por espacios, cuando el resumen que
+     * de verdad identifica al grupo no cabe en uno solo.
+     *
+     * Existe por las reglas del router: su condición son TRES campos
+     * (`field`, `operator`, `value`) y el modal a medida que se retiró las
+     * pintaba juntas — «status eq active». Con un único `summaryField` una
+     * regla sin `label` quedaba en «rule 1» y «status», que no dice a qué
+     * se está conectando uno.
+     *
+     * Los campos vacíos se saltan, para que una regla con operador
+     * `exists` no salga con un espacio colgando al final.
+     */
+    summaryFields?: string[];
+    /** Label shown in the modal (e.g. 'output', 'branch') */
+    label: string;
+    /** Entity field for the fallback/else path (e.g. 'elseOutputNodes') */
+    elseField?: string;
+    /**
+     * Fixed output groups — for nodes with a static set of outputs (e.g. approval: approve/reject).
+     * When set, `field`/`nameField` are ignored — modal shows these fixed options.
+     *
+     * Cada entrada nombra su puerto de una de dos formas, y sólo una:
+     *   · `field` — un campo de primer nivel de los de ANTES de que los puertos
+     *     existieran (`rejectionOutputNodes` → puerto `rejected`); se traduce
+     *     con el mapa de campos heredados.
+     *   · `port`  — el puerto, tal cual. Es lo que usan las salidas nacidas ya
+     *     con puertos (las cuatro de sentiment): inventarles un campo heredado
+     *     que nunca existió sería mentir en el registro.
+     */
+    fixedGroups?: Array<{
+        name: string;
+        field?: string;
+        port?: string;
+        /** Una línea de qué entrega ese puerto, para el modal de conexión. */
+        summary?: string;
+    }>;
+    /**
+     * Optional content-aware gate — the output-group modal only opens
+     * when `entity[gate.field] === gate.value`. Lets a node opt into
+     * multi-branch routing only in some modes (e.g. AI Node in
+     * classifier mode) without trapping every connection in the
+     * picker the rest of the time. When the gate fails, the
+     * FlowCanvas falls through to the universal
+     * `entity.outputNodes` connect path.
+     */
+    gate?: {
+        field: string;
+        value: unknown;
+    };
+    /**
+     * Qué es el puerto `main` de este nodo MIENTRAS su contenedor está
+     * vacío. Sin esto, conectar a un nodo que ramifica y todavía no tiene
+     * ninguna salida escribía una arista en `main` **en silencio**, y el
+     * usuario no tenía forma de saber qué había pasado con ella.
+     *
+     * No hay una respuesta única, y por eso es un dato y no una regla.
+     * Medido en `api/src/common/pipeline-run.service.ts`:
+     *
+     *   'passthrough'       — router sin reglas: `rules.length === 0
+     *                         ? refsForPort(entity, MAIN_PORT) : []`. La
+     *                         arista SÍ dispara... hasta que se cree la
+     *                         primera regla, y entonces deja de hacerlo
+     *                         sin avisar.
+     *   'never-dispatched'  — split: no tiene salida `main`, y el propio
+     *                         despachador registra un warning por cada
+     *                         arista que se quedó en ese puerto.
+     *
+     * Se declara sólo donde se ha medido. Sin declarar, el lienzo se
+     * comporta como siempre: conecta por el camino universal y no dice
+     * nada, que es lo que hacía antes de existir este campo.
+     */
+    emptyContainerMain?: 'passthrough' | 'never-dispatched';
+}
+/**
+ * El juego de salidas que aplica AHORA a esta entidad, o `undefined` si el
+ * nodo no ramifica en este momento.
+ *
+ * Es la única lectura de `special.outputGroups` que entiende las dos formas
+ * (uno o varios) y las dos puertas (con `gate` o sin ella). Todo el que
+ * pregunte tiene que pasar por aquí: el lienzo, el modal de conexión y el
+ * despachador. Escribirlo cada uno a su manera es como el router acabó con un
+ * camino propio que nadie arregló al arreglar el de los demás.
+ */
+export declare function outputGroupsFor(config: NodeUIConfig | undefined | null, entity: Record<string, unknown> | undefined | null): OutputGroupsConfig | undefined;
+/** Todos los juegos declarados, pasen o no su puerta. Para quien necesita el
+ *  UNIVERSO de puertos que un tipo puede emitir (la auditoría de puertos),
+ *  no el de ahora mismo. */
+export declare function todosLosOutputGroups(config: NodeUIConfig | undefined | null): OutputGroupsConfig[];

package/dist/esm/types.js

@@ -6,3 +6,29 @@ export function singleMeta() {
 export function iterableMeta(field, count) {
     return { iterable: true, iterateField: field, count };
 }
+/**
+ * El juego de salidas que aplica AHORA a esta entidad, o `undefined` si el
+ * nodo no ramifica en este momento.
+ *
+ * Es la única lectura de `special.outputGroups` que entiende las dos formas
+ * (uno o varios) y las dos puertas (con `gate` o sin ella). Todo el que
+ * pregunte tiene que pasar por aquí: el lienzo, el modal de conexión y el
+ * despachador. Escribirlo cada uno a su manera es como el router acabó con un
+ * camino propio que nadie arregló al arreglar el de los demás.
+ */
+export function outputGroupsFor(config, entity) {
+    const declarado = config?.special?.outputGroups;
+    if (!declarado)
+        return undefined;
+    const lista = Array.isArray(declarado) ? declarado : [declarado];
+    return lista.find((c) => !c.gate || entity?.[c.gate.field] === c.gate.value);
+}
+/** Todos los juegos declarados, pasen o no su puerta. Para quien necesita el
+ *  UNIVERSO de puertos que un tipo puede emitir (la auditoría de puertos),
+ *  no el de ahora mismo. */
+export function todosLosOutputGroups(config) {
+    const declarado = config?.special?.outputGroups;
+    if (!declarado)
+        return [];
+    return Array.isArray(declarado) ? declarado : [declarado];
+}

package/dist/esm/ui.js

@@ -2,6 +2,7 @@
  * Dashboard UI config — handle positions, dot visibility, canvas prefixes.
  * Only imported by the Dashboard. Broker and API don't need this.
  */
+import { SENTIMENT_PORTS, SENTIMENT_PORT_LABEL, SENTIMENT_PORT_SUMMARY, } from './sentiment.js';
 export const NODE_UI = {
     // ── Source nodes ──
     // Una fuente arranca el flujo: `fromNodes: false` significa que nada puede
@@ -45,7 +46,15 @@ export const NODE_UI = {
     // no handle and no route. In any other outputMode the node falls back to
     // the single right-out handle NodeShell renders when no dynamic outputs
     // materialize.
-    ai: { fromNodes: true, toNodes: true, outputHandles: ['right'], special: { loopBackAllowed: true, connectModal: 'output-group', outputGroups: { field: 'categories', nameField: 'name', summaryField: 'description', label: 'category', gate: { field: 'outputMode', value: 'classifier' } } } },
+    // En modo `sentiment` (2026-09-22) el abanico son CUATRO puertos fijos
+    // —negative / neutral / positive / unclear— y no un contenedor del usuario:
+    // el modelo elige entre las tres primeras y el nodo manda a `unclear` lo que
+    // no llega al umbral de confianza. Por eso el AI Node declara DOS juegos de
+    // salidas, uno por modo; `outputGroupsFor` elige el que toca.
+    ai: { fromNodes: true, toNodes: true, outputHandles: ['right'], special: { loopBackAllowed: true, connectModal: 'output-group', outputGroups: [
+                { field: 'categories', nameField: 'name', summaryField: 'description', label: 'category', gate: { field: 'outputMode', value: 'classifier' } },
+                { label: 'sentiment', gate: { field: 'outputMode', value: 'sentiment' }, fixedGroups: SENTIMENT_PORTS.map((p) => ({ name: SENTIMENT_PORT_LABEL[p], port: p, summary: SENTIMENT_PORT_SUMMARY[p] })) },
+            ] } },
     markdown: { fromNodes: true, toNodes: true, special: { loopBackAllowed: true } },
     fileTransform: { fromNodes: true, toNodes: true },
     limit: { fromNodes: true, toNodes: true, special: { loopBackAllowed: true } },

package/dist/gmail-operations.d.ts

@@ -151,6 +151,8 @@ export interface GmailToolkitSpec {
     toolName: string;
     description: string;
     parameters: GmailToolkitParameter[];
+    /** Pisa o borra. Lo pone `marcarDestructivas` leyendo el verbo del
+     *  nombre (ver `clase-de-herramienta.ts`), no se escribe a mano. */
     destructive?: boolean;
 }
 export declare const GMAIL_TOOLKIT_SPECS: GmailToolkitSpec[];

package/dist/gmail-operations.js

@@ -1,8 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GMAIL_SEND_LEGACY_FIELDS = exports.NATIVE_EMAIL_TOOLKIT_BY_TOOL_NAME = exports.GMAIL_TOOLKIT_BY_TOOL_NAME = exports.NATIVE_EMAIL_TOOLKIT_SPECS = exports.GMAIL_ALL_TOOLKIT_SPECS = exports.GMAIL_SEND_AND_WAIT_TOOL_SPEC = exports.GMAIL_TOOLKIT_SPECS = exports.GMAIL_TOOLKIT_OPERATIONS = exports.GMAIL_DROPDOWN_OPERATIONS = exports.GMAIL_OPERATION_SPECS = exports.GMAIL_OPERATION_GROUPS = exports.GMAIL_OPERATIONS = void 0;
-exports.isGmailOperation = isGmailOperation;
-exports.resolveGmailSendFields = resolveGmailSendFields;
 /**
  * Gmail operation enum — single source of truth across the API, Dashboard,
  * and Message Broker. Used by:
@@ -17,6 +13,11 @@ exports.resolveGmailSendFields = resolveGmailSendFields;
  * dashboard owns the UI form schema, the api owns the dispatch logic),
  * but the canonical list of valid operation strings lives here.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GMAIL_SEND_LEGACY_FIELDS = exports.NATIVE_EMAIL_TOOLKIT_BY_TOOL_NAME = exports.GMAIL_TOOLKIT_BY_TOOL_NAME = exports.NATIVE_EMAIL_TOOLKIT_SPECS = exports.GMAIL_ALL_TOOLKIT_SPECS = exports.GMAIL_SEND_AND_WAIT_TOOL_SPEC = exports.GMAIL_TOOLKIT_SPECS = exports.GMAIL_TOOLKIT_OPERATIONS = exports.GMAIL_DROPDOWN_OPERATIONS = exports.GMAIL_OPERATION_SPECS = exports.GMAIL_OPERATION_GROUPS = exports.GMAIL_OPERATIONS = void 0;
+exports.isGmailOperation = isGmailOperation;
+exports.resolveGmailSendFields = resolveGmailSendFields;
+const clase_de_herramienta_js_1 = require("./clase-de-herramienta.js");
 exports.GMAIL_OPERATIONS = [
     'send',
     // Pause-the-pipeline op — sends an email with Approve / (optional)
@@ -301,7 +302,7 @@ const p = (name, description, required = true, type = 'string') => ({ name, type
 const ADJUNTOS = p('attachments', 'Optional. Files to attach, taken from the payload: pass the `_file` reference object(s) ' +
     'exactly as they appear (a single `_file`, or the `_files` / `files` array), as a JSON ' +
     'string. Never invent one. Up to 5 files, 25 MB in total.', false);
-exports.GMAIL_TOOLKIT_SPECS = [
+exports.GMAIL_TOOLKIT_SPECS = (0, clase_de_herramienta_js_1.marcarDestructivas)([
     {
         operation: 'send',
         label: 'Send message',
@@ -510,7 +511,7 @@ exports.GMAIL_TOOLKIT_SPECS = [
             p('threadId', 'Gmail thread id.'),
         ],
     },
-];
+]);
 /**
  * La op que espera, **fuera** del toolkit y aparte a propósito. Sigue haciendo
  * falta para dos cosas que no son el toolkit: reconocer la operación de una
@@ -540,12 +541,12 @@ exports.GMAIL_SEND_AND_WAIT_TOOL_SPEC = {
     ],
 };
 /** Todo lo que el nodo sabe ejecutar, se ofrezca o no como herramienta. */
-exports.GMAIL_ALL_TOOLKIT_SPECS = [
+exports.GMAIL_ALL_TOOLKIT_SPECS = (0, clase_de_herramienta_js_1.marcarDestructivas)([
     ...exports.GMAIL_TOOLKIT_SPECS,
     exports.GMAIL_SEND_AND_WAIT_TOOL_SPEC,
-];
+]);
 /** El toolkit del proveedor nativo (Resend): una sola herramienta. */
-exports.NATIVE_EMAIL_TOOLKIT_SPECS = [
+exports.NATIVE_EMAIL_TOOLKIT_SPECS = (0, clase_de_herramienta_js_1.marcarDestructivas)([
     {
         operation: 'send',
         label: 'Send email',
@@ -564,7 +565,7 @@ exports.NATIVE_EMAIL_TOOLKIT_SPECS = [
             p('attachment_file_ids', 'Optional. Comma-separated list of file IDs from `_file.id` refs in the upstream payload (e.g., a File Transform output or a webhook multipart upload). Max 5 files, 30MB total. Do NOT invent IDs — only use values actually present in the current payload.', false),
         ],
     },
-];
+]);
 exports.GMAIL_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(exports.GMAIL_ALL_TOOLKIT_SPECS.map((s) => [s.toolName, s]));
 exports.NATIVE_EMAIL_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(exports.NATIVE_EMAIL_TOOLKIT_SPECS.map((s) => [s.toolName, s]));
 /** Los tres campos que un día vivieron en la raíz. */