@hostwebhook/node-types 1.68.0 → 1.70.0

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

@@ -0,0 +1,81 @@
+/**
+ * Slack Web API operation enum — single source of truth across the
+ * api, dashboard, and downstream consumers (Message Broker, MCP server).
+ * Used by:
+ *   - slackAction entity / DTO (api): operation field + validation
+ *   - dashboard SlackAction operation picker + form generation
+ *   - MCP toolkit-specs expansion (one aiEnabled slackAction → N tools)
+ *
+ * v1 covers 16 ops — messaging, channel CRUD, members, reactions, files.
+ * Future additions (pin / unpin, files.list, conversations.archive, app
+ * publish, scheduled.list, etc.) extend this list — bump the package and
+ * re-install in consumers, same pattern as Gmail / Calendar / Discord.
+ */
+import { type CapacidadesPorCredencial } from './capacidad-de-credencial.js';
+export declare const SLACK_OPERATIONS: readonly ["sendMessage", "updateMessage", "deleteMessage", "sendEphemeral", "scheduleMessage", "getMessage", "listChannels", "getChannelHistory", "getThreadReplies", "createChannel", "inviteToChannel", "addReaction", "removeReaction", "listUsers", "getUserInfo", "uploadFile"];
+export type SlackOperation = (typeof SLACK_OPERATIONS)[number];
+/** Type guard — useful when validating untrusted input (DTOs, AI tool calls). */
+export declare function isSlackOperation(value: unknown): value is SlackOperation;
+/**
+ * Per-operation parameter schema. Drives:
+ *   1. Form auto-generation in the SlackAction detail page (dashboard).
+ *   2. AI tool argument schema when `aiEnabled === true`.
+ *   3. MCP tools/list expansion (one slackAction → N MCP tools).
+ *
+ * Field types kept narrow on purpose so the dashboard form picker can
+ * render the right control (channel-picker vs free text vs number).
+ * The api side `SlackOperationsService` accepts the same shapes.
+ */
+export interface SlackParamSpec {
+    /** Field key — also the property name on operationConfig / payload. */
+    name: string;
+    /** UI label. */
+    label: string;
+    /** Param type for form rendering + AI tool schema. */
+    type: 'channel' | 'user' | 'string' | 'text' | 'number' | 'boolean' | 'emoji' | 'blocks' | 'json' | 'fileUrl';
+    /** Required at submit time. */
+    required?: boolean;
+    /** Human description — also used as the AI tool param description. */
+    description: string;
+    /** Hint shown under the input. */
+    placeholder?: string;
+}
+export interface SlackOperationSpec {
+    /** UI label for the operation picker. */
+    label: string;
+    /** Description shown in the picker + reused by the AI tool description
+     *  when the user hasn't set a custom one on the entity. */
+    description: string;
+    /** Verb the operation maps to in Slack's docs (slack.com/methods/...). */
+    apiMethod: string;
+    /** Parameter schema. Order matters for form rendering. */
+    params: SlackParamSpec[];
+}
+export declare const SLACK_OPERATION_SPECS: Record<SlackOperation, SlackOperationSpec>;
+/**
+ * Lo que puede hacer una credencial de Slack que NO es OAuth.
+ *
+ * Medido contra la documentación de Slack, no de memoria:
+ * https://docs.slack.dev/messaging/sending-messages-using-incoming-webhooks
+ *
+ * Es el caso extremo, y conviene que se lea así de crudo: **una** operación de
+ * las 16. Un incoming webhook publica y nada más. Textualmente: «Incoming
+ * webhooks do not allow you to delete a message after it's been posted», no
+ * lee, no sube ficheros, y editar exige `chat.update`, que es token.
+ *
+ * Y el campo que se cae es el que más duele, porque no parece una restricción
+ * hasta que lo es: **`channel` no se puede elegir**. «You cannot override the
+ * default channel (chosen by the user who installed your app)». El destino se
+ * decide al crear la credencial, así que ofrecer el campo sería ofrecer una
+ * pregunta cuya respuesta se ignora — que es peor que no ofrecerla.
+ *
+ * `text` y `blocks` se quedan (Block Kit está soportado), y `threadTs` también:
+ * la doc lo admite si ya tienes el `ts` del padre por otra vía.
+ */
+export declare const SLACK_CAPACIDADES_POR_CREDENCIAL: CapacidadesPorCredencial<SlackOperation>;
+/** Las operaciones que ofrecer para una credencial de Slack. */
+export declare function operacionesDeSlackPara(tipoDeCredencial: string | null | undefined): readonly SlackOperation[];
+/** Si esa credencial puede ejecutar esa operación de Slack. */
+export declare function slackPuedeEjecutar(tipoDeCredencial: string | null | undefined, operacion: SlackOperation): boolean;
+/** Los campos que esa credencial de Slack no deja elegir. */
+export declare function camposDeSlackNoDisponibles(tipoDeCredencial: string | null | undefined): ReadonlySet<string>;

package/dist/esm/slack-operations.js

@@ -0,0 +1,244 @@
+/**
+ * Slack Web API operation enum — single source of truth across the
+ * api, dashboard, and downstream consumers (Message Broker, MCP server).
+ * Used by:
+ *   - slackAction entity / DTO (api): operation field + validation
+ *   - dashboard SlackAction operation picker + form generation
+ *   - MCP toolkit-specs expansion (one aiEnabled slackAction → N tools)
+ *
+ * v1 covers 16 ops — messaging, channel CRUD, members, reactions, files.
+ * Future additions (pin / unpin, files.list, conversations.archive, app
+ * publish, scheduled.list, etc.) extend this list — bump the package and
+ * re-install in consumers, same pattern as Gmail / Calendar / Discord.
+ */
+import { camposNoDisponiblesPara, operacionesPara, puedeEjecutar, } from './capacidad-de-credencial.js';
+export const SLACK_OPERATIONS = [
+    // Messages
+    'sendMessage',
+    'updateMessage',
+    'deleteMessage',
+    'sendEphemeral',
+    'scheduleMessage',
+    'getMessage',
+    // Channels
+    'listChannels',
+    'getChannelHistory',
+    'getThreadReplies',
+    'createChannel',
+    'inviteToChannel',
+    // Reactions
+    'addReaction',
+    'removeReaction',
+    // Users
+    'listUsers',
+    'getUserInfo',
+    // Files
+    'uploadFile',
+];
+/** Type guard — useful when validating untrusted input (DTOs, AI tool calls). */
+export function isSlackOperation(value) {
+    return (typeof value === 'string' &&
+        SLACK_OPERATIONS.includes(value));
+}
+export const SLACK_OPERATION_SPECS = {
+    sendMessage: {
+        label: 'Send message',
+        description: 'Post a message to a channel, group, or DM.',
+        apiMethod: 'chat.postMessage',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel id (C…) or DM id (D…) where the message will be posted.' },
+            { name: 'text', label: 'Text', type: 'text', description: 'Message text. Supports Slack mrkdwn. Required when blocks is empty.' },
+            { name: 'blocks', label: 'Blocks (optional)', type: 'blocks', description: 'Slack Block Kit JSON for rich layouts. Overrides text rendering when set.' },
+            { name: 'threadTs', label: 'Thread ts (optional)', type: 'string', description: 'When set, the message replies inside an existing thread. Use the parent message timestamp.' },
+        ],
+    },
+    updateMessage: {
+        label: 'Update message',
+        description: 'Edit a message the bot posted earlier.',
+        apiMethod: 'chat.update',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel where the original message lives.' },
+            { name: 'ts', label: 'Message ts', type: 'string', required: true, description: 'Timestamp of the message to edit (returned by sendMessage).' },
+            { name: 'text', label: 'New text', type: 'text', description: 'Replacement text. Required when blocks is empty.' },
+            { name: 'blocks', label: 'New blocks (optional)', type: 'blocks', description: 'Replacement Block Kit layout.' },
+        ],
+    },
+    deleteMessage: {
+        label: 'Delete message',
+        description: 'Delete a message the bot posted earlier.',
+        apiMethod: 'chat.delete',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel where the message lives.' },
+            { name: 'ts', label: 'Message ts', type: 'string', required: true, description: 'Timestamp of the message to delete.' },
+        ],
+    },
+    sendEphemeral: {
+        label: 'Send ephemeral',
+        description: 'Post a message visible only to a single user (the rest of the channel does not see it).',
+        apiMethod: 'chat.postEphemeral',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel where the ephemeral message will appear.' },
+            { name: 'user', label: 'User', type: 'user', required: true, description: 'User id (U…) — only this user sees the message.' },
+            { name: 'text', label: 'Text', type: 'text', description: 'Message text. Required when blocks is empty.' },
+            { name: 'blocks', label: 'Blocks (optional)', type: 'blocks', description: 'Block Kit layout.' },
+        ],
+    },
+    scheduleMessage: {
+        label: 'Schedule message',
+        description: 'Schedule a message to be posted at a future time.',
+        apiMethod: 'chat.scheduleMessage',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel where the scheduled message will be posted.' },
+            { name: 'postAt', label: 'Post at (unix sec)', type: 'number', required: true, description: 'When Slack should post the message — unix timestamp in seconds.' },
+            { name: 'text', label: 'Text', type: 'text', description: 'Message text. Required when blocks is empty.' },
+            { name: 'blocks', label: 'Blocks (optional)', type: 'blocks', description: 'Block Kit layout.' },
+        ],
+    },
+    getMessage: {
+        label: 'Get message',
+        description: 'Fetch a single message by its timestamp.',
+        apiMethod: 'conversations.history',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel where the message lives.' },
+            { name: 'ts', label: 'Message ts', type: 'string', required: true, description: 'Timestamp of the message to fetch.' },
+        ],
+    },
+    listChannels: {
+        label: 'List channels',
+        description: 'List public + private channels the bot can see in the workspace.',
+        apiMethod: 'conversations.list',
+        params: [
+            { name: 'limit', label: 'Limit', type: 'number', description: 'Max channels to return (1-1000). Default 200.' },
+            { name: 'excludeArchived', label: 'Exclude archived', type: 'boolean', description: 'Hide archived channels. Default true.' },
+        ],
+    },
+    getChannelHistory: {
+        label: 'Get channel history',
+        description: 'Read recent messages from a channel.',
+        apiMethod: 'conversations.history',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel to read from.' },
+            { name: 'limit', label: 'Limit', type: 'number', description: 'Max messages to return (1-200). Default 50.' },
+            { name: 'oldest', label: 'Oldest ts', type: 'string', description: 'Only messages after this timestamp.' },
+            { name: 'latest', label: 'Latest ts', type: 'string', description: 'Only messages before this timestamp.' },
+        ],
+    },
+    getThreadReplies: {
+        label: 'Get thread replies',
+        description: 'Fetch replies to a thread.',
+        apiMethod: 'conversations.replies',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel where the thread lives.' },
+            { name: 'ts', label: 'Parent ts', type: 'string', required: true, description: 'Timestamp of the thread parent message.' },
+            { name: 'limit', label: 'Limit', type: 'number', description: 'Max replies to return (1-1000). Default 100.' },
+        ],
+    },
+    createChannel: {
+        label: 'Create channel',
+        description: 'Create a new public or private channel.',
+        apiMethod: 'conversations.create',
+        params: [
+            { name: 'name', label: 'Name', type: 'string', required: true, description: 'Channel name (lowercase, no spaces, < 80 chars).' },
+            { name: 'isPrivate', label: 'Private', type: 'boolean', description: 'Create a private channel instead of public. Default false.' },
+        ],
+    },
+    inviteToChannel: {
+        label: 'Invite to channel',
+        description: 'Invite one or more users to a channel.',
+        apiMethod: 'conversations.invite',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel id to invite users to.' },
+            { name: 'users', label: 'Users', type: 'string', required: true, description: 'Comma-separated user ids (U…) to invite.' },
+        ],
+    },
+    addReaction: {
+        label: 'Add reaction',
+        description: 'Add an emoji reaction to a message.',
+        apiMethod: 'reactions.add',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel where the message lives.' },
+            { name: 'ts', label: 'Message ts', type: 'string', required: true, description: 'Timestamp of the message to react to.' },
+            { name: 'name', label: 'Emoji name', type: 'emoji', required: true, description: 'Emoji name without colons (e.g. thumbsup, white_check_mark).' },
+        ],
+    },
+    removeReaction: {
+        label: 'Remove reaction',
+        description: 'Remove an emoji reaction from a message.',
+        apiMethod: 'reactions.remove',
+        params: [
+            { name: 'channel', label: 'Channel', type: 'channel', required: true, description: 'Channel where the message lives.' },
+            { name: 'ts', label: 'Message ts', type: 'string', required: true, description: 'Timestamp of the message.' },
+            { name: 'name', label: 'Emoji name', type: 'emoji', required: true, description: 'Emoji name without colons.' },
+        ],
+    },
+    listUsers: {
+        label: 'List users',
+        description: 'List human members of the workspace (excludes deleted users + bots by default).',
+        apiMethod: 'users.list',
+        params: [
+            { name: 'limit', label: 'Limit', type: 'number', description: 'Max users to return (1-1000). Default 200.' },
+            { name: 'includeDeleted', label: 'Include deleted', type: 'boolean', description: 'Include deactivated users. Default false.' },
+            { name: 'includeBots', label: 'Include bots', type: 'boolean', description: 'Include bot users + app users. Default false.' },
+        ],
+    },
+    getUserInfo: {
+        label: 'Get user info',
+        description: 'Fetch a user profile (name, email, timezone, status).',
+        apiMethod: 'users.info',
+        params: [
+            { name: 'user', label: 'User', type: 'user', required: true, description: 'User id (U…) to look up.' },
+        ],
+    },
+    uploadFile: {
+        label: 'Upload file',
+        description: 'Upload a file (PDF, image, anything) and optionally share it in a channel.',
+        apiMethod: 'files.uploadV2',
+        params: [
+            { name: 'url', label: 'File URL', type: 'fileUrl', description: 'Public URL or HW file _file.downloadUrl that HW will fetch and re-upload.' },
+            { name: 'contentBase64', label: 'File content (base64)', type: 'text', description: 'Inline file content as base64 — alternative to url for small payloads.' },
+            { name: 'filename', label: 'Filename', type: 'string', description: 'Display name in Slack. Auto-derived from URL when omitted.' },
+            { name: 'channel', label: 'Channel (optional)', type: 'channel', description: 'Channel to share the uploaded file in.' },
+            { name: 'title', label: 'Title (optional)', type: 'string', description: 'Title shown above the file in Slack.' },
+            { name: 'initialComment', label: 'Initial comment (optional)', type: 'text', description: 'Message Slack posts together with the file.' },
+            { name: 'threadTs', label: 'Thread ts (optional)', type: 'string', description: 'Attach the file to an existing thread.' },
+        ],
+    },
+};
+/**
+ * Lo que puede hacer una credencial de Slack que NO es OAuth.
+ *
+ * Medido contra la documentación de Slack, no de memoria:
+ * https://docs.slack.dev/messaging/sending-messages-using-incoming-webhooks
+ *
+ * Es el caso extremo, y conviene que se lea así de crudo: **una** operación de
+ * las 16. Un incoming webhook publica y nada más. Textualmente: «Incoming
+ * webhooks do not allow you to delete a message after it's been posted», no
+ * lee, no sube ficheros, y editar exige `chat.update`, que es token.
+ *
+ * Y el campo que se cae es el que más duele, porque no parece una restricción
+ * hasta que lo es: **`channel` no se puede elegir**. «You cannot override the
+ * default channel (chosen by the user who installed your app)». El destino se
+ * decide al crear la credencial, así que ofrecer el campo sería ofrecer una
+ * pregunta cuya respuesta se ignora — que es peor que no ofrecerla.
+ *
+ * `text` y `blocks` se quedan (Block Kit está soportado), y `threadTs` también:
+ * la doc lo admite si ya tienes el `ts` del padre por otra vía.
+ */
+export const SLACK_CAPACIDADES_POR_CREDENCIAL = {
+    slack_webhook: {
+        operaciones: ['sendMessage'],
+        camposNoDisponibles: ['channel'],
+    },
+};
+/** Las operaciones que ofrecer para una credencial de Slack. */
+export function operacionesDeSlackPara(tipoDeCredencial) {
+    return operacionesPara(SLACK_OPERATIONS, SLACK_CAPACIDADES_POR_CREDENCIAL, tipoDeCredencial);
+}
+/** Si esa credencial puede ejecutar esa operación de Slack. */
+export function slackPuedeEjecutar(tipoDeCredencial, operacion) {
+    return puedeEjecutar(SLACK_OPERATIONS, SLACK_CAPACIDADES_POR_CREDENCIAL, tipoDeCredencial, operacion);
+}
+/** Los campos que esa credencial de Slack no deja elegir. */
+export function camposDeSlackNoDisponibles(tipoDeCredencial) {
+    return camposNoDisponiblesPara(SLACK_CAPACIDADES_POR_CREDENCIAL, tipoDeCredencial);
+}

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

@@ -0,0 +1,60 @@
+/**
+ * Slack AI Toolkit — las herramientas que un slackAction expone cuando
+ * `aiEnabled` está encendido.
+ *
+ * **Se escribe una sola vez.** Antes vivía dos veces: una copia en
+ * `dashboard/components/slack-actions/slack-operations-schemas.ts` y otra en
+ * `api/src/mcp-servers/toolkit-specs.ts`, las dos a mano y en repos distintos,
+ * así que ningún test podía compararlas. Es la octava y novena mudanza de esta
+ * serie; de las siete anteriores, la de Contacts salió de que una copia
+ * anunciara 15 herramientas y expusiera una.
+ *
+ * La deriva aquí era gorda: **14 de las 16 descripciones** diferían. Gana la de
+ * la api en todas —es sistemáticamente la más completa y es la que sirve el MCP
+ * hoy—, y una no era cosmética: en `deleteMessage` la api nombra el permiso que
+ * hace falta (`chat:write.public` + admin) y el dashboard sólo decía «admin
+ * perms». Operaciones, nombres de herramienta y parámetros sí coincidían.
+ *
+ * Los nombres llevan `_slack_` para no chocar con los de Telegram y Discord
+ * cuando un mismo AI Node tiene varios toolkits encendidos.
+ *
+ * La forma es la que ya consume `toolkitSpecToMcpTool` en la api, para que
+ * 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 type { SlackOperation } from './slack-operations.js';
+export interface SlackToolkitParameter {
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+    description: string;
+    required: boolean;
+}
+export interface SlackToolkitSpec {
+    operation: SlackOperation;
+    /** Etiqueta corta de la fila en la lista de herramientas. */
+    label: string;
+    /** Nombre con el que el LLM llama a la herramienta. */
+    toolName: string;
+    /** 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. */
+    destructive?: boolean;
+}
+export declare const SLACK_TOOLKIT_SPECS: SlackToolkitSpec[];
+export declare const SLACK_TOOLKIT_BY_TOOL_NAME: Record<string, SlackToolkitSpec>;
+/**
+ * Las herramientas que ofrecerle al modelo con ESTA credencial.
+ *
+ * Gemelo de `herramientasDeDiscordPara`, y por la misma razón: los dos
+ * consumidores —la expansión MCP de la api y el selector del AI Node del
+ * dashboard— filtrarían por su cuenta y acabarían discrepando.
+ *
+ * En Slack el recorte es brutal y conviene verlo escrito: con un webhook el
+ * modelo pasa de **16 herramientas a una**, y esa una pierde el `channel`,
+ * porque el destino lo fijó quien instaló la credencial. Dejarle el campo sería
+ * invitarle a elegir un canal que Slack va a ignorar sin decir nada.
+ */
+export declare function herramientasDeSlackPara(tipoDeCredencial: string | null | undefined): SlackToolkitSpec[];

package/dist/esm/slack-toolkit.js

@@ -0,0 +1,235 @@
+/**
+ * Slack AI Toolkit — las herramientas que un slackAction expone cuando
+ * `aiEnabled` está encendido.
+ *
+ * **Se escribe una sola vez.** Antes vivía dos veces: una copia en
+ * `dashboard/components/slack-actions/slack-operations-schemas.ts` y otra en
+ * `api/src/mcp-servers/toolkit-specs.ts`, las dos a mano y en repos distintos,
+ * así que ningún test podía compararlas. Es la octava y novena mudanza de esta
+ * serie; de las siete anteriores, la de Contacts salió de que una copia
+ * anunciara 15 herramientas y expusiera una.
+ *
+ * La deriva aquí era gorda: **14 de las 16 descripciones** diferían. Gana la de
+ * la api en todas —es sistemáticamente la más completa y es la que sirve el MCP
+ * hoy—, y una no era cosmética: en `deleteMessage` la api nombra el permiso que
+ * hace falta (`chat:write.public` + admin) y el dashboard sólo decía «admin
+ * perms». Operaciones, nombres de herramienta y parámetros sí coincidían.
+ *
+ * Los nombres llevan `_slack_` para no chocar con los de Telegram y Discord
+ * cuando un mismo AI Node tiene varios toolkits encendidos.
+ *
+ * La forma es la que ya consume `toolkitSpecToMcpTool` en la api, para que
+ * 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 { camposDeSlackNoDisponibles, operacionesDeSlackPara, } from './slack-operations.js';
+const p = (name, description, required = true, type = 'string') => ({ name, type, description, required });
+export const SLACK_TOOLKIT_SPECS = [
+    // ── Messages ─────────────────────────────────────────────────────
+    {
+        operation: 'sendMessage',
+        label: 'Send message',
+        toolName: 'send_slack_message',
+        description: 'Post a message to a Slack channel, group, or DM. ' +
+            'USAGE RULES: ' +
+            '(1) `channel` is a Slack channel id (C…), group id (G…), or DM id (D…). Get it from the trigger payload, listChannels, or the user. Never invent one. ' +
+            '(2) For a thread reply, set `threadTs` to the parent message timestamp. ' +
+            '(3) Either `text` or `blocks` is required. Use blocks for rich layouts.',
+        parameters: [
+            p('channel', 'Channel/group/DM id where the message will be posted.'),
+            p('text', 'Message text. Slack mrkdwn supported. Required when blocks is empty.', false),
+            p('blocks', 'Block Kit JSON for rich layouts. Stringified JSON or JSON array.', false),
+            p('threadTs', 'Parent message timestamp to reply inside an existing thread.', false),
+        ],
+    },
+    {
+        operation: 'updateMessage',
+        label: 'Update message',
+        toolName: 'update_slack_message',
+        description: 'Edit a message previously posted by the bot. The bot can only edit its own messages — editing another user/bot message returns cant_update_message.',
+        parameters: [
+            p('channel', 'Channel where the original message lives.'),
+            p('ts', 'Timestamp of the message to edit (returned by sendMessage).'),
+            p('text', 'New message text. Required when blocks is empty.', false),
+            p('blocks', 'New Block Kit JSON. Replaces the existing layout.', false),
+        ],
+    },
+    {
+        operation: 'deleteMessage',
+        label: 'Delete message',
+        toolName: 'delete_slack_message',
+        description: "Delete a message the bot posted. Other users' messages need chat:write.public + admin perms — usually fails for AI-driven calls. Confirm before destructive use.",
+        parameters: [
+            p('channel', 'Channel where the message lives.'),
+            p('ts', 'Timestamp of the message to delete.'),
+        ],
+        destructive: true,
+    },
+    {
+        operation: 'sendEphemeral',
+        label: 'Send ephemeral',
+        toolName: 'send_slack_ephemeral',
+        description: 'Post a message visible only to a specific user — the rest of the channel does not see it. Useful for per-user prompts, errors, or warnings.',
+        parameters: [
+            p('channel', 'Channel where the ephemeral message will appear.'),
+            p('user', 'User id (U…) — the only viewer of the message.'),
+            p('text', 'Message text. Required when blocks is empty.', false),
+            p('blocks', 'Block Kit JSON for rich layouts.', false),
+        ],
+    },
+    {
+        operation: 'scheduleMessage',
+        label: 'Schedule message',
+        toolName: 'schedule_slack_message',
+        description: 'Schedule a Slack message to be posted at a future time. Returns a scheduled_message_id useful for cancellation later.',
+        parameters: [
+            p('channel', 'Channel where the message will be posted.'),
+            p('postAt', 'When to post — unix timestamp in SECONDS, not milliseconds.', true, 'number'),
+            p('text', 'Message text. Required when blocks is empty.', false),
+            p('blocks', 'Block Kit JSON for rich layouts.', false),
+        ],
+    },
+    {
+        operation: 'getMessage',
+        label: 'Get message',
+        toolName: 'get_slack_message',
+        description: 'Fetch a single message by its timestamp. Returns the message text + author + reactions + attachments. Use BEFORE editing or reacting to verify state.',
+        parameters: [
+            p('channel', 'Channel where the message lives.'),
+            p('ts', 'Timestamp of the message to fetch.'),
+        ],
+    },
+    // ── Channels ─────────────────────────────────────────────────────
+    {
+        operation: 'listChannels',
+        label: 'List channels',
+        toolName: 'list_slack_channels',
+        description: 'List public + private channels the bot can see in the workspace. Returns id, name, isMember, memberCount per channel. Pre-pick a channel before sendMessage.',
+        parameters: [
+            p('limit', 'Max channels to return (1-1000). Default 200.', false, 'number'),
+            p('excludeArchived', 'Hide archived channels. Default true.', false, 'boolean'),
+        ],
+    },
+    {
+        operation: 'getChannelHistory',
+        label: 'Get channel history',
+        toolName: 'get_slack_channel_history',
+        description: 'Read recent messages from a Slack channel. Useful for summarization, context retrieval, or finding a message by content before editing/reacting.',
+        parameters: [
+            p('channel', 'Channel id to read from.'),
+            p('limit', 'Max messages to return (1-200). Default 50.', false, 'number'),
+            p('oldest', 'Only messages newer than this timestamp.', false),
+            p('latest', 'Only messages older than this timestamp.', false),
+        ],
+    },
+    {
+        operation: 'getThreadReplies',
+        label: 'Get thread replies',
+        toolName: 'get_slack_thread_replies',
+        description: 'Fetch the replies inside a Slack thread, given the parent message timestamp. Use for summarizing or continuing a thread.',
+        parameters: [
+            p('channel', 'Channel where the thread lives.'),
+            p('ts', 'Timestamp of the thread parent message.'),
+            p('limit', 'Max replies to return (1-1000). Default 100.', false, 'number'),
+        ],
+    },
+    {
+        operation: 'createChannel',
+        label: 'Create channel',
+        toolName: 'create_slack_channel',
+        description: 'Create a new public or private Slack channel. Names must be lowercase, no spaces, max 80 chars. Confirm with the user before creating channels — they are usually long-lived org artifacts.',
+        parameters: [
+            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',
+        label: 'Invite to channel',
+        toolName: 'invite_to_slack_channel',
+        description: 'Invite one or more users to a Slack channel by user id. Comma-separated `users` argument.',
+        parameters: [
+            p('channel', 'Channel id to invite users to.'),
+            p('users', 'Comma-separated user ids (U…) to invite.'),
+        ],
+    },
+    // ── Reactions ────────────────────────────────────────────────────
+    {
+        operation: 'addReaction',
+        label: 'Add reaction',
+        toolName: 'add_slack_reaction',
+        description: 'Add an emoji reaction to a Slack message as the bot. Use the emoji NAME without colons (e.g. `thumbsup`, `white_check_mark`, `eyes`).',
+        parameters: [
+            p('channel', 'Channel where the message lives.'),
+            p('ts', 'Timestamp of the message to react to.'),
+            p('name', 'Emoji name without colons.'),
+        ],
+    },
+    {
+        operation: 'removeReaction',
+        label: 'Remove reaction',
+        toolName: 'remove_slack_reaction',
+        description: "Remove the bot's own emoji reaction from a Slack message. Cannot remove other users' reactions.",
+        parameters: [
+            p('channel', 'Channel where the message lives.'),
+            p('ts', 'Timestamp of the message.'),
+            p('name', 'Emoji name without colons.'),
+        ],
+    },
+    // ── Users ────────────────────────────────────────────────────────
+    {
+        operation: 'listUsers',
+        label: 'List users',
+        toolName: 'list_slack_users',
+        description: 'List human members of the Slack workspace. Returns id, name, real_name, email, avatarUrl. Excludes deleted users + bots by default.',
+        parameters: [
+            p('limit', 'Max users to return (1-1000). Default 200.', false, 'number'),
+            p('includeDeleted', 'Include deactivated users. Default false.', false, 'boolean'),
+            p('includeBots', 'Include bot users + app users. Default false.', false, 'boolean'),
+        ],
+    },
+    {
+        operation: 'getUserInfo',
+        label: 'Get user info',
+        toolName: 'get_slack_user_info',
+        description: 'Fetch a Slack user profile (real_name, email, timezone, status, avatar). Use BEFORE sendEphemeral to confirm the user id is valid.',
+        parameters: [p('user', 'User id (U…) to look up.')],
+    },
+    // ── Files ────────────────────────────────────────────────────────
+    {
+        operation: 'uploadFile',
+        label: 'Upload file',
+        toolName: 'upload_slack_file',
+        description: 'Upload a file to Slack and optionally share it in a channel. Provide either a public `url` to fetch or inline `contentBase64` for small payloads. Optionally attach to a thread via `threadTs`.',
+        parameters: [
+            p('url', 'Public URL or HW _file.downloadUrl that HW will fetch and re-upload.', false),
+            p('contentBase64', 'Inline base64 file content (alternative to url).', false),
+            p('filename', 'Display name in Slack. Auto-derived from URL when omitted.', false),
+            p('channel', 'Channel id to share the uploaded file in.', false),
+            p('title', 'Title shown above the file.', false),
+            p('initialComment', 'Message Slack posts together with the file.', false),
+            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.
+ *
+ * Gemelo de `herramientasDeDiscordPara`, y por la misma razón: los dos
+ * consumidores —la expansión MCP de la api y el selector del AI Node del
+ * dashboard— filtrarían por su cuenta y acabarían discrepando.
+ *
+ * En Slack el recorte es brutal y conviene verlo escrito: con un webhook el
+ * modelo pasa de **16 herramientas a una**, y esa una pierde el `channel`,
+ * porque el destino lo fijó quien instaló la credencial. Dejarle el campo sería
+ * invitarle a elegir un canal que Slack va a ignorar sin decir nada.
+ */
+export function herramientasDeSlackPara(tipoDeCredencial) {
+    const permitidas = new Set(operacionesDeSlackPara(tipoDeCredencial));
+    const fuera = camposDeSlackNoDisponibles(tipoDeCredencial);
+    return SLACK_TOOLKIT_SPECS.filter((s) => permitidas.has(s.operation)).map((s) => fuera.size === 0
+        ? s
+        : { ...s, parameters: s.parameters.filter((p) => !fuera.has(p.name)) });
+}