@hostwebhook/node-types 1.86.0 → 1.87.0

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

@@ -38,9 +38,8 @@ export interface DiscordToolkitSpec {
     /** Descripción (más reglas de uso) que ve el LLM. */
     description: string;
     parameters: DiscordToolkitParameter[];
-    /** 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 DISCORD_TOOLKIT_SPECS: DiscordToolkitSpec[];

package/dist/esm/discord-toolkit.js

@@ -23,8 +23,9 @@
  * y quien mire la lista de herramientas del servidor MCP.
  */
 import { camposDeDiscordNoDisponibles, operacionesDeDiscordPara, } from './discord-operations.js';
+import { marcarDestructivas } from './clase-de-herramienta.js';
 const p = (name, description, required = true, type = 'string') => ({ name, type, description, required });
-export const DISCORD_TOOLKIT_SPECS = [
+export const DISCORD_TOOLKIT_SPECS = marcarDestructivas([
     // ── Messages ───────────────────────────────────────────────────
     {
         operation: 'sendMessage',
@@ -63,7 +64,6 @@ export const DISCORD_TOOLKIT_SPECS = [
             p('channelId', 'Channel snowflake where the message lives.'),
             p('messageId', 'Snowflake of the message to delete.'),
         ],
-        destructive: true,
     },
     {
         operation: 'getMessage',
@@ -149,7 +149,6 @@ export const DISCORD_TOOLKIT_SPECS = [
         toolName: 'delete_discord_channel',
         description: 'Permanently delete a Discord channel and ALL its messages. Irreversible. ALWAYS confirm with the user before calling — Discord does not provide a recovery window.',
         parameters: [p('channelId', 'Channel snowflake to delete.')],
-        destructive: true,
     },
     {
         operation: 'getChannel',
@@ -205,7 +204,6 @@ export const DISCORD_TOOLKIT_SPECS = [
             p('userId', 'Member snowflake.'),
             p('roleId', 'Role snowflake to grant.'),
         ],
-        destructive: true,
     },
     {
         operation: 'removeRole',
@@ -217,7 +215,6 @@ export const DISCORD_TOOLKIT_SPECS = [
             p('userId', 'Member snowflake.'),
             p('roleId', 'Role snowflake to remove.'),
         ],
-        destructive: true,
     },
     {
         operation: 'getMember',
@@ -229,7 +226,7 @@ export const DISCORD_TOOLKIT_SPECS = [
             p('userId', 'Member snowflake.'),
         ],
     },
-];
+]);
 export const DISCORD_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(DISCORD_TOOLKIT_SPECS.map((s) => [s.toolName, s]));
 /**
  * Las herramientas que ofrecerle al modelo con ESTA credencial.

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

@@ -27,7 +27,8 @@ export interface DocsToolkitSpec {
     toolName: string;
     description: string;
     parameters: DocsToolkitParameter[];
-    /** Escribe en el documento 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 DOCS_TOOLKIT_SPECS: DocsToolkitSpec[];

package/dist/esm/docs-toolkit.js

@@ -13,6 +13,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 });
 /*
  * El documento del nodo va como **defecto** y el modelo puede cambiarlo — la
@@ -31,7 +32,7 @@ const p = (name, description, required = true, type = 'string') => ({ name, type
  * documento nuevo nacería con el id del viejo por título.
  */
 const documento = () => p('documentId', 'Id of the Google Docs document — the long chunk of its URL, between /d/ and /edit.');
-export const DOCS_TOOLKIT_SPECS = [
+export const DOCS_TOOLKIT_SPECS = marcarDestructivas([
     {
         operation: 'readDoc',
         label: 'Read document',
@@ -48,7 +49,6 @@ export const DOCS_TOOLKIT_SPECS = [
             p('title', 'Name of the new document.'),
             p('content', 'Initial body, as HTML. Basic tags work (<p>, <b>, <i>, <ul>, <li>, <h1>…). Plain text is fine too. Leave it out for an empty document.', false),
         ],
-        destructive: true,
     },
     {
         operation: 'appendText',
@@ -59,7 +59,6 @@ export const DOCS_TOOLKIT_SPECS = [
             p('content', 'What to add, as HTML. Basic tags work (<p>, <b>, <i>, <ul>, <li>, <h1>…). Plain text is fine too.'),
             documento(),
         ],
-        destructive: true,
     },
     {
         operation: 'replaceText',
@@ -71,7 +70,6 @@ export const DOCS_TOOLKIT_SPECS = [
             p('replaceWith', 'Text to put in its place. An empty string deletes the matches.'),
             documento(),
         ],
-        destructive: true,
     },
     {
         operation: 'insertTable',
@@ -83,9 +81,8 @@ export const DOCS_TOOLKIT_SPECS = [
             p('cols', 'Number of columns.', true, 'number'),
             documento(),
         ],
-        destructive: true,
     },
-];
+]);
 /** Las herramientas por nombre, para despachar una llamada del modelo. */
 export const DOCS_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(DOCS_TOOLKIT_SPECS.map((s) => [s.toolName, s]));
 /**

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

@@ -42,10 +42,15 @@ export interface DriveToolkitSpec {
     /** Encabezado de grupo de la página de detalle. El orden es el que agrupa. */
     group?: string;
     /**
-     * Marca que la herramienta cambia algo difícil de deshacer, para que la página
-     * lo enseñe y el AI Node pida confirmación. Son **dos**, las mismas que ya
-     * estaban marcadas: `delete_drive_file` y `share_drive_file`. `move` no lo
-     * lleva, y es defendible — deshacerlo es otro move.
+     * Pisa o borra. Lo pone `marcarDestructivas` leyendo el verbo del nombre
+     * (ver `clase-de-herramienta.ts`), no se escribe a mano.
+     *
+     * ⚠️ Hasta el 2026-09-24 aquí se decía que `move` no lo llevaba —«deshacerlo
+     * es otro move»—, mientras la tabla de anotaciones MCP de la api decía lo
+     * contrario: sacar el fichero de su carpeta es quitarlo de donde estaba. Eran
+     * dos criterios para lo mismo; se queda el de la tabla, que es el único que
+     * estaba escrito como regla. `share_drive_file` sigue marcada, ahora como
+     * excepción explícita: compartir expone, y eso no se deshace.
      */
     destructive?: boolean;
 }

package/dist/esm/drive-toolkit.js

@@ -19,11 +19,12 @@
  * herramientas del mismo grupo tienen que ir seguidas. Los tres grupos son los
  * que ya inventaba el JSX que sustituye.
  */
+import { marcarDestructivas } from './clase-de-herramienta.js';
 const p = (name, description, required = true, type = 'string') => ({ name, type, description, required });
 const ENTRAN_Y_SALEN = 'Files in / out';
 const DESCUBRIR = 'Discovery';
 const MUTACIONES = 'Mutations (LLM confirms first)';
-export const DRIVE_TOOLKIT_SPECS = [
+export const DRIVE_TOOLKIT_SPECS = marcarDestructivas([
     /* ── Files in / out ─────────────────────────────────────────────────── */
     {
         operation: 'upload',
@@ -154,7 +155,6 @@ export const DRIVE_TOOLKIT_SPECS = [
             p('fileId', 'The Drive file ID to delete.'),
             p('permanent', 'Optional. true = bypass trash and erase forever (irreversible). Default false.', false, 'boolean'),
         ],
-        destructive: true,
     },
     {
         operation: 'share',
@@ -170,8 +170,7 @@ export const DRIVE_TOOLKIT_SPECS = [
             p('domain', 'Required when type=domain.', false),
             p('sendNotificationEmail', 'Optional. true = email the recipient about the share.', false, 'boolean'),
         ],
-        destructive: true,
     },
-];
+]);
 /** Índice por nombre de herramienta, para enrutar un `tools/call` sin recorrer. */
 export const DRIVE_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(DRIVE_TOOLKIT_SPECS.map((s) => [s.toolName, s]));

package/dist/esm/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/esm/gmail-operations.js

@@ -12,6 +12,7 @@
  * dashboard owns the UI form schema, the api owns the dispatch logic),
  * but the canonical list of valid operation strings lives here.
  */
+import { marcarDestructivas } from './clase-de-herramienta.js';
 export const GMAIL_OPERATIONS = [
     'send',
     // Pause-the-pipeline op — sends an email with Approve / (optional)
@@ -296,7 +297,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);
-export const GMAIL_TOOLKIT_SPECS = [
+export const GMAIL_TOOLKIT_SPECS = marcarDestructivas([
     {
         operation: 'send',
         label: 'Send message',
@@ -505,7 +506,7 @@ export const 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
@@ -535,12 +536,12 @@ export const GMAIL_SEND_AND_WAIT_TOOL_SPEC = {
     ],
 };
 /** Todo lo que el nodo sabe ejecutar, se ofrezca o no como herramienta. */
-export const GMAIL_ALL_TOOLKIT_SPECS = [
+export const GMAIL_ALL_TOOLKIT_SPECS = marcarDestructivas([
     ...GMAIL_TOOLKIT_SPECS,
     GMAIL_SEND_AND_WAIT_TOOL_SPEC,
-];
+]);
 /** El toolkit del proveedor nativo (Resend): una sola herramienta. */
-export const NATIVE_EMAIL_TOOLKIT_SPECS = [
+export const NATIVE_EMAIL_TOOLKIT_SPECS = marcarDestructivas([
     {
         operation: 'send',
         label: 'Send email',
@@ -559,7 +560,7 @@ export const 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),
         ],
     },
-];
+]);
 export const GMAIL_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(GMAIL_ALL_TOOLKIT_SPECS.map((s) => [s.toolName, s]));
 export const NATIVE_EMAIL_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(NATIVE_EMAIL_TOOLKIT_SPECS.map((s) => [s.toolName, s]));
 /** Los tres campos que un día vivieron en la raíz. */

package/dist/esm/index.d.ts

@@ -70,6 +70,14 @@ export { DOCS_OPERATIONS, DOCS_OPERATION_SPECS, isDocsOperation, } from './docs-
 export type { DocsOperation, DocsParamType, DocsParamSlot, DocsParamSpec, DocsOperationSpec, } from './docs-operations.js';
 export { DOCS_TOOLKIT_SPECS, DOCS_TOOLKIT_BY_TOOL_NAME, DOCS_TOOLKIT_DEFAULTABLE, } from './docs-toolkit.js';
 export type { DocsToolkitSpec, DocsToolkitParameter, } from './docs-toolkit.js';
+export { MONGO_TOOLKIT_SPECS, MONGO_TOOLKIT_BY_TOOL_NAME, } from './mongo-toolkit.js';
+export type { MongoToolkitSpec, MongoToolkitParameter, } from './mongo-toolkit.js';
+export { POSTGRES_TOOLKIT_SPECS, POSTGRES_TOOLKIT_BY_TOOL_NAME, } from './postgres-toolkit.js';
+export type { PostgresToolkitSpec, PostgresToolkitParameter, } from './postgres-toolkit.js';
+export { claseDeHerramienta, esHerramientaDestructiva, marcarDestructivas, } from './clase-de-herramienta.js';
+export type { ClaseDeHerramienta } from './clase-de-herramienta.js';
+export { TOOLKITS_POR_TIPO, operacionDeToolkit, esOperacionDestructiva, } from './toolkits.js';
+export type { OperacionDeToolkit } from './toolkits.js';
 export type { LlmProvider, LlmProviderOption, LlmModelOption, } from './llm-models.js';
 export { LLM_PROVIDERS, LLM_MODELS, MODEL_CONTEXT_WINDOWS, getModelsFor, getDefaultModel, getModelLabel, } from './llm-models.js';
 export type { ModeloDeOpenRouter, PrecioDeOpenRouter, RespuestaDeModelosDeOpenRouter, } from './openrouter.js';

package/dist/esm/index.js

@@ -53,6 +53,11 @@ export { POSTGRES_OPERATIONS, POSTGRES_MODES, POSTGRES_OPERATION_SPECS, isPostgr
 export { MONGO_OPERATIONS, MONGO_OPERATION_SPECS, isMongoOperation, } from './mongo-operations.js';
 export { DOCS_OPERATIONS, DOCS_OPERATION_SPECS, isDocsOperation, } from './docs-operations.js';
 export { DOCS_TOOLKIT_SPECS, DOCS_TOOLKIT_BY_TOOL_NAME, DOCS_TOOLKIT_DEFAULTABLE, } from './docs-toolkit.js';
+// ── Toolkits de bases de datos, y la clase de cada herramienta (2026-09-24) ──
+export { MONGO_TOOLKIT_SPECS, MONGO_TOOLKIT_BY_TOOL_NAME, } from './mongo-toolkit.js';
+export { POSTGRES_TOOLKIT_SPECS, POSTGRES_TOOLKIT_BY_TOOL_NAME, } from './postgres-toolkit.js';
+export { claseDeHerramienta, esHerramientaDestructiva, marcarDestructivas, } from './clase-de-herramienta.js';
+export { TOOLKITS_POR_TIPO, operacionDeToolkit, esOperacionDestructiva, } from './toolkits.js';
 export { LLM_PROVIDERS, LLM_MODELS, MODEL_CONTEXT_WINDOWS, getModelsFor, getDefaultModel, getModelLabel, } from './llm-models.js';
 export { URL_DE_MODELOS_DE_OPENROUTER, opcionesDeModelosDeOpenRouter, ventanaDeContextoDeOpenRouter, } from './openrouter.js';
 export { CREDENTIAL_TYPES, CREDENTIAL_TYPE_VALUES, credentialTypeValues, getCredentialType, isCredentialType, } from './credentials.js';

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

@@ -0,0 +1,47 @@
+/**
+ * MongoDB AI Toolkit — las herramientas que un mongoAction expone cuando
+ * `aiEnabled` está encendido.
+ *
+ * ## Lo que el modelo NO elige (2026-09-24, decisiones de Ariel)
+ *
+ * - **La colección.** Es la del nodo y no hay parámetro para cambiarla: para
+ *   tocar otra se conecta otro nodo. Una herramienta de base de datos que deja
+ *   al modelo nombrar la colección le da acceso a todo lo que la credencial
+ *   alcanza, y eso no se ve al mirar el lienzo.
+ * - **El JavaScript del servidor.** `$where`, `$function` y `$accumulator`
+ *   ejecutan código dentro de Mongo; el handler los rechaza en cualquier
+ *   filtro o pipeline que venga del modelo.
+ * - **Escribir desde una agregación.** `$out` y `$merge` son las dos etapas que
+ *   escriben; `aggregate_documents` las rechaza, y por eso cuenta como lectura.
+ *
+ * ## Los nombres
+ *
+ * Cada nombre empieza por el verbo que dice lo que hace, porque el `destructive`
+ * de cada operación lo pone `marcarDestructivas` leyendo ese verbo (ver
+ * `clase-de-herramienta.ts`). Por eso `findOneAndUpdate` se ofrece como
+ * `update_and_return_document` y no como `find_and_update_document`: con el
+ * segundo nombre el verbo diría «lectura» de algo que pisa un documento.
+ *
+ * Los textos van en inglés porque los lee el modelo.
+ */
+import type { MongoOperation } from './mongo-operations';
+export interface MongoToolkitParameter {
+    name: string;
+    /** El esquema MCP sólo admite estos tres; lo estructurado viaja como JSON
+     *  en un `string`, igual que las filas de Sheets. */
+    type: 'string' | 'number' | 'boolean';
+    description: string;
+    required: boolean;
+}
+export interface MongoToolkitSpec {
+    operation: MongoOperation;
+    label: string;
+    toolName: string;
+    description: string;
+    parameters: MongoToolkitParameter[];
+    /** Pisa o borra. Lo pone `marcarDestructivas`, no se escribe a mano. */
+    destructive?: boolean;
+}
+export declare const MONGO_TOOLKIT_SPECS: MongoToolkitSpec[];
+/** Las herramientas por nombre, para despachar una llamada del modelo. */
+export declare const MONGO_TOOLKIT_BY_TOOL_NAME: Record<string, MongoToolkitSpec>;

package/dist/esm/mongo-toolkit.js

@@ -0,0 +1,98 @@
+/**
+ * MongoDB AI Toolkit — las herramientas que un mongoAction expone cuando
+ * `aiEnabled` está encendido.
+ *
+ * ## Lo que el modelo NO elige (2026-09-24, decisiones de Ariel)
+ *
+ * - **La colección.** Es la del nodo y no hay parámetro para cambiarla: para
+ *   tocar otra se conecta otro nodo. Una herramienta de base de datos que deja
+ *   al modelo nombrar la colección le da acceso a todo lo que la credencial
+ *   alcanza, y eso no se ve al mirar el lienzo.
+ * - **El JavaScript del servidor.** `$where`, `$function` y `$accumulator`
+ *   ejecutan código dentro de Mongo; el handler los rechaza en cualquier
+ *   filtro o pipeline que venga del modelo.
+ * - **Escribir desde una agregación.** `$out` y `$merge` son las dos etapas que
+ *   escriben; `aggregate_documents` las rechaza, y por eso cuenta como lectura.
+ *
+ * ## Los nombres
+ *
+ * Cada nombre empieza por el verbo que dice lo que hace, porque el `destructive`
+ * de cada operación lo pone `marcarDestructivas` leyendo ese verbo (ver
+ * `clase-de-herramienta.ts`). Por eso `findOneAndUpdate` se ofrece como
+ * `update_and_return_document` y no como `find_and_update_document`: con el
+ * segundo nombre el verbo diría «lectura» de algo que pisa un documento.
+ *
+ * Los textos van en inglés porque los lee el modelo.
+ */
+import { marcarDestructivas } from './clase-de-herramienta.js';
+const p = (name, description, required = true, type = 'string') => ({ name, type, description, required });
+const filtro = (para, required = true) => p('filter', `JSON object with a MongoDB query filter that selects ${para}, e.g. {"email": "a@b.c"} or {"total": {"$gt": 100}}. Server-side JavaScript operators ($where, $function, $accumulator) are rejected.`, required);
+const proyeccion = () => p('projection', 'Optional JSON object choosing the fields to return, e.g. {"name": 1, "email": 1}. Leave it out to return whole documents.', false);
+export const MONGO_TOOLKIT_SPECS = marcarDestructivas([
+    {
+        operation: 'findAll',
+        label: 'Find documents',
+        toolName: 'find_documents',
+        description: "Return the documents of this node's collection that match a filter. Returns at most `limit` documents — use a filter that narrows the result instead of reading the whole collection.",
+        parameters: [
+            filtro('the documents to return. {} matches every document', false),
+            proyeccion(),
+            p('sort', 'Optional JSON object with the sort order, e.g. {"createdAt": -1} for newest first.', false),
+            p('limit', 'Maximum number of documents to return (default 20, maximum 100).', false, 'number'),
+        ],
+    },
+    {
+        operation: 'findOne',
+        label: 'Find one document',
+        toolName: 'find_one_document',
+        description: "Return the first document of this node's collection that matches a filter, or nothing when none does.",
+        parameters: [filtro('the document'), proyeccion()],
+    },
+    {
+        operation: 'aggregate',
+        label: 'Aggregate documents',
+        toolName: 'aggregate_documents',
+        description: "Run an aggregation pipeline over this node's collection and return its result — for counts, sums, groupings and joins with $lookup. It only reads: the $out and $merge stages, which write, are rejected.",
+        parameters: [
+            p('pipeline', 'JSON array of aggregation stages, e.g. [{"$match": {"status": "paid"}}, {"$group": {"_id": "$customer", "total": {"$sum": "$amount"}}}].'),
+        ],
+    },
+    {
+        operation: 'insertOne',
+        label: 'Insert document',
+        toolName: 'insert_document',
+        description: "Insert one new document into this node's collection and return its _id. It does not check for duplicates — when the document might already exist, find it first.",
+        parameters: [
+            p('document', 'JSON object with the new document, e.g. {"name": "Ariel", "email": "a@b.c"}.'),
+        ],
+    },
+    {
+        operation: 'updateOne',
+        label: 'Update document',
+        toolName: 'update_document',
+        description: "Update the first document of this node's collection that matches a filter. It overwrites the fields you set. When nothing matches it changes nothing — it does not create a document.",
+        parameters: [
+            filtro('the document to update. It cannot be empty'),
+            p('update', 'JSON object with MongoDB update operators, e.g. {"$set": {"status": "shipped"}} or {"$inc": {"stock": -1}}. A plain object without operators is rejected, because it would replace the whole document.'),
+        ],
+    },
+    {
+        operation: 'findOneAndUpdate',
+        label: 'Update and return document',
+        toolName: 'update_and_return_document',
+        description: "Update the first document of this node's collection that matches a filter and return it as it is AFTER the update. Use it when you need the updated values in your reply; otherwise update_document is enough.",
+        parameters: [
+            filtro('the document to update. It cannot be empty'),
+            p('update', 'JSON object with MongoDB update operators, e.g. {"$set": {"status": "shipped"}}. A plain object without operators is rejected.'),
+        ],
+    },
+    {
+        operation: 'deleteOne',
+        label: 'Delete document',
+        toolName: 'delete_document',
+        description: "Delete the first document of this node's collection that matches a filter. This cannot be undone. When you are not sure which document the filter selects, call find_one_document first.",
+        parameters: [filtro('the document to delete. It cannot be empty')],
+    },
+]);
+/** Las herramientas por nombre, para despachar una llamada del modelo. */
+export const MONGO_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(MONGO_TOOLKIT_SPECS.map((s) => [s.toolName, s]));

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

@@ -0,0 +1,52 @@
+/**
+ * PostgreSQL AI Toolkit — las herramientas que un postgresAction expone cuando
+ * `aiEnabled` está encendido.
+ *
+ * ## Por qué las escrituras NO reciben SQL (2026-09-24, decisión de Ariel)
+ *
+ * El nodo, en modo de una operación, ejecuta el SQL que se le escribe: sus
+ * cinco operaciones son una etiqueta encima del mismo SQL crudo. Si el toolkit
+ * hiciera lo mismo, bloquear una herramienta no bloquearía nada — un
+ * `insert_rows` puede llevar un `DELETE` dentro de un `WITH`, y quien bloqueó
+ * `delete_rows` seguiría viendo desaparecer filas.
+ *
+ * Así que las tres escrituras reciben la tabla del nodo y JSON, y el SQL lo
+ * genera el handler, parametrizado y con los identificadores entrecomillados:
+ * el modelo no escribe SQL que se ejecute como escritura.
+ *
+ * ## Lo que queda con SQL, y cómo se contiene
+ *
+ * - `query_rows` recibe SQL, y corre dentro de una transacción **READ ONLY**:
+ *   un `DELETE`, un `UPDATE` o un `CREATE` los rechaza el propio Postgres, no
+ *   una expresión regular nuestra. Puede leer otras tablas —un JOIN hace
+ *   falta a menudo—; el límite ahí lo pone el usuario de base de datos de la
+ *   credencial.
+ * - `execute_sql` recibe SQL cualquiera, DDL incluido. Es la excepción
+ *   consciente a «sólo la tabla del nodo»: SQL crudo no se puede vallar a una
+ *   tabla. La contienen tres cosas: es siempre destructiva (el gate del AI
+ *   Node la para si está encendido), se puede bloquear en el nodo, y el
+ *   usuario de base de datos.
+ *
+ * Los textos van en inglés porque los lee el modelo.
+ */
+import type { PostgresOperation } from './postgres-operations';
+export interface PostgresToolkitParameter {
+    name: string;
+    /** El esquema MCP sólo admite estos tres; lo estructurado viaja como JSON
+     *  en un `string`. */
+    type: 'string' | 'number' | 'boolean';
+    description: string;
+    required: boolean;
+}
+export interface PostgresToolkitSpec {
+    operation: PostgresOperation;
+    label: string;
+    toolName: string;
+    description: string;
+    parameters: PostgresToolkitParameter[];
+    /** Pisa o borra. Lo pone `marcarDestructivas`, no se escribe a mano. */
+    destructive?: boolean;
+}
+export declare const POSTGRES_TOOLKIT_SPECS: PostgresToolkitSpec[];
+/** Las herramientas por nombre, para despachar una llamada del modelo. */
+export declare const POSTGRES_TOOLKIT_BY_TOOL_NAME: Record<string, PostgresToolkitSpec>;

package/dist/esm/postgres-toolkit.js

@@ -0,0 +1,85 @@
+/**
+ * PostgreSQL AI Toolkit — las herramientas que un postgresAction expone cuando
+ * `aiEnabled` está encendido.
+ *
+ * ## Por qué las escrituras NO reciben SQL (2026-09-24, decisión de Ariel)
+ *
+ * El nodo, en modo de una operación, ejecuta el SQL que se le escribe: sus
+ * cinco operaciones son una etiqueta encima del mismo SQL crudo. Si el toolkit
+ * hiciera lo mismo, bloquear una herramienta no bloquearía nada — un
+ * `insert_rows` puede llevar un `DELETE` dentro de un `WITH`, y quien bloqueó
+ * `delete_rows` seguiría viendo desaparecer filas.
+ *
+ * Así que las tres escrituras reciben la tabla del nodo y JSON, y el SQL lo
+ * genera el handler, parametrizado y con los identificadores entrecomillados:
+ * el modelo no escribe SQL que se ejecute como escritura.
+ *
+ * ## Lo que queda con SQL, y cómo se contiene
+ *
+ * - `query_rows` recibe SQL, y corre dentro de una transacción **READ ONLY**:
+ *   un `DELETE`, un `UPDATE` o un `CREATE` los rechaza el propio Postgres, no
+ *   una expresión regular nuestra. Puede leer otras tablas —un JOIN hace
+ *   falta a menudo—; el límite ahí lo pone el usuario de base de datos de la
+ *   credencial.
+ * - `execute_sql` recibe SQL cualquiera, DDL incluido. Es la excepción
+ *   consciente a «sólo la tabla del nodo»: SQL crudo no se puede vallar a una
+ *   tabla. La contienen tres cosas: es siempre destructiva (el gate del AI
+ *   Node la para si está encendido), se puede bloquear en el nodo, y el
+ *   usuario de base de datos.
+ *
+ * Los textos van en inglés porque los lee el modelo.
+ */
+import { marcarDestructivas } from './clase-de-herramienta.js';
+const p = (name, description, required = true, type = 'string') => ({ name, type, description, required });
+const donde = (que) => p('where', `JSON object selecting the rows ${que}: each key is a column and each value the value it must equal, all of them at once, e.g. {"id": 42} or {"status": "pending", "customer_id": 7}. It cannot be empty — an empty condition would touch every row.`);
+const parametros = () => p('params', 'Optional JSON array with the values for the $1, $2… placeholders in the SQL, e.g. ["paid", 100]. Always pass values this way instead of writing them into the SQL.', false);
+export const POSTGRES_TOOLKIT_SPECS = marcarDestructivas([
+    {
+        operation: 'query',
+        label: 'Query rows',
+        toolName: 'query_rows',
+        description: 'Run a read-only SQL query (SELECT, WITH … SELECT) and return its rows, at most 200. It runs inside a READ ONLY transaction: a statement that writes is rejected by the database. Use it for lookups, counts, sums and joins.',
+        parameters: [
+            p('sql', 'The SELECT statement, with $1, $2… placeholders for values, e.g. SELECT * FROM orders WHERE status = $1 LIMIT 20.'),
+            parametros(),
+        ],
+    },
+    {
+        operation: 'insertOne',
+        label: 'Insert rows',
+        toolName: 'insert_rows',
+        description: "Insert one or more rows into this node's table and return them as stored, with the values the database filled in (ids, defaults). It does not check for duplicates.",
+        parameters: [
+            p('rows', 'JSON object with one row, or a JSON array of rows. Keys are column names, e.g. {"name": "Ariel", "email": "a@b.c"}. A key that is not a column makes the call fail.'),
+        ],
+    },
+    {
+        operation: 'update',
+        label: 'Update rows',
+        toolName: 'update_rows',
+        description: "Update the rows of this node's table that match a condition, overwriting the columns you set, and return them after the update. When no row matches it changes nothing.",
+        parameters: [
+            p('set', 'JSON object with the columns to overwrite and their new values, e.g. {"status": "shipped"}.'),
+            donde('to update'),
+        ],
+    },
+    {
+        operation: 'delete',
+        label: 'Delete rows',
+        toolName: 'delete_rows',
+        description: "Delete the rows of this node's table that match a condition and return them as they were. This cannot be undone: when you are not sure which rows match, check with query_rows first.",
+        parameters: [donde('to delete')],
+    },
+    {
+        operation: 'execute',
+        label: 'Execute SQL',
+        toolName: 'execute_sql',
+        description: 'Run any SQL statement — including ones that change the schema (CREATE, ALTER, DROP) — and return what it produces. It is not limited to this node\'s table. Prefer query_rows, insert_rows, update_rows or delete_rows whenever one of them can do the job.',
+        parameters: [
+            p('sql', 'The SQL statement, with $1, $2… placeholders for values.'),
+            parametros(),
+        ],
+    },
+]);
+/** Las herramientas por nombre, para despachar una llamada del modelo. */
+export const POSTGRES_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(POSTGRES_TOOLKIT_SPECS.map((s) => [s.toolName, s]));

package/dist/esm/registry.js

@@ -401,6 +401,11 @@ export const NODE_REGISTRY = {
         allStateKey: "allMongoActions",
         color: "#34d399",
         testable: true,
+        /* Modo AI toolkit (2026-09-24): con `aiEnabled` el nodo sólo lo llama un
+           AI Node —como el resto de toolkits—, y una arista del lienzo no le
+           llevaría nada. Hasta que la api y el dashboard le den `aiEnabled`, el
+           campo no existe y esto devuelve `false`: no cambia nada. */
+        isToolOnly: (e) => e.aiEnabled === true,
     },
     postgresAction: {
         type: "postgresAction",
@@ -413,6 +418,11 @@ export const NODE_REGISTRY = {
         allStateKey: "allPostgresActions",
         color: "#336791",
         testable: true,
+        /* Modo AI toolkit (2026-09-24): con `aiEnabled` el nodo sólo lo llama un
+           AI Node —como el resto de toolkits—, y una arista del lienzo no le
+           llevaría nada. Hasta que la api y el dashboard le den `aiEnabled`, el
+           campo no existe y esto devuelve `false`: no cambia nada. */
+        isToolOnly: (e) => e.aiEnabled === true,
     },
     notificationAction: {
         type: "notificationAction",

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]));
 /**