@hostwebhook/node-types 1.69.0 → 1.70.0

package/dist/calendar-toolkit.d.ts

@@ -28,7 +28,7 @@
  * El array se generó desde la copia de la api para que las descripciones largas
  * salieran idénticas, no tecleadas.
  */
-import type { GoogleCalendarOperation } from './calendar-operations';
+import type { GoogleCalendarOperation } from './calendar-operations.js';
 export interface GoogleCalendarToolkitParameter {
     name: string;
     type: 'string' | 'number' | 'boolean';

package/dist/connections.d.ts

@@ -6,7 +6,7 @@
  *
  * Adding a new node type = add 1 entry here. All repos import from this package.
  */
-import type { NodeType, NodeConnectionConfig } from './types';
+import type { NodeType, NodeConnectionConfig } from './types.js';
 export declare const NODE_CONNECTIONS: Record<NodeType, NodeConnectionConfig>;
 export declare function canReceiveFrom(targetType: NodeType, sourceType: NodeType): boolean;
 export declare function canReceiveFromNodes(nodeType: NodeType): boolean;

package/dist/discord-operations.d.ts

@@ -17,7 +17,7 @@
  * forum-post create) extend this list — bump the package and re-install
  * in consumers, same pattern as Gmail / Calendar / Drive / Telegram.
  */
-import { type CapacidadesPorCredencial } from './capacidad-de-credencial';
+import { type CapacidadesPorCredencial } from './capacidad-de-credencial.js';
 export declare const DISCORD_OPERATIONS: readonly ["sendMessage", "editMessage", "deleteMessage", "getMessage", "addReaction", "removeReaction", "pinMessage", "createChannel", "editChannel", "deleteChannel", "getChannel", "listChannels", "createThread", "sendDM", "addRole", "removeRole", "getMember"];
 export type DiscordOperation = (typeof DISCORD_OPERATIONS)[number];
 /** Type guard — useful when validating untrusted input (DTOs, tool calls). */

package/dist/discord-operations.js

@@ -24,7 +24,7 @@ exports.camposDeDiscordNoDisponibles = camposDeDiscordNoDisponibles;
  * forum-post create) extend this list — bump the package and re-install
  * in consumers, same pattern as Gmail / Calendar / Drive / Telegram.
  */
-const capacidad_de_credencial_1 = require("./capacidad-de-credencial");
+const capacidad_de_credencial_js_1 = require("./capacidad-de-credencial.js");
 exports.DISCORD_OPERATIONS = [
     // Messages
     'sendMessage',
@@ -402,13 +402,13 @@ exports.DISCORD_CAPACIDADES_POR_CREDENCIAL = {
 };
 /** Las operaciones que ofrecer para una credencial de Discord. */
 function operacionesDeDiscordPara(tipoDeCredencial) {
-    return (0, capacidad_de_credencial_1.operacionesPara)(exports.DISCORD_OPERATIONS, exports.DISCORD_CAPACIDADES_POR_CREDENCIAL, tipoDeCredencial);
+    return (0, capacidad_de_credencial_js_1.operacionesPara)(exports.DISCORD_OPERATIONS, exports.DISCORD_CAPACIDADES_POR_CREDENCIAL, tipoDeCredencial);
 }
 /** Si esa credencial puede ejecutar esa operación de Discord. */
 function discordPuedeEjecutar(tipoDeCredencial, operacion) {
-    return (0, capacidad_de_credencial_1.puedeEjecutar)(exports.DISCORD_OPERATIONS, exports.DISCORD_CAPACIDADES_POR_CREDENCIAL, tipoDeCredencial, operacion);
+    return (0, capacidad_de_credencial_js_1.puedeEjecutar)(exports.DISCORD_OPERATIONS, exports.DISCORD_CAPACIDADES_POR_CREDENCIAL, tipoDeCredencial, operacion);
 }
 /** Los campos que esa credencial de Discord no deja elegir. */
 function camposDeDiscordNoDisponibles(tipoDeCredencial) {
-    return (0, capacidad_de_credencial_1.camposNoDisponiblesPara)(exports.DISCORD_CAPACIDADES_POR_CREDENCIAL, tipoDeCredencial);
+    return (0, capacidad_de_credencial_js_1.camposNoDisponiblesPara)(exports.DISCORD_CAPACIDADES_POR_CREDENCIAL, tipoDeCredencial);
 }

package/dist/discord-toolkit.d.ts

@@ -22,7 +22,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 type { DiscordOperation } from './discord-operations';
+import type { DiscordOperation } from './discord-operations.js';
 export interface DiscordToolkitParameter {
     name: string;
     type: 'string' | 'number' | 'boolean';

package/dist/discord-toolkit.js

@@ -26,7 +26,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DISCORD_TOOLKIT_BY_TOOL_NAME = exports.DISCORD_TOOLKIT_SPECS = void 0;
 exports.herramientasDeDiscordPara = herramientasDeDiscordPara;
-const discord_operations_1 = require("./discord-operations");
+const discord_operations_js_1 = require("./discord-operations.js");
 const p = (name, description, required = true, type = 'string') => ({ name, type, description, required });
 exports.DISCORD_TOOLKIT_SPECS = [
     // ── Messages ───────────────────────────────────────────────────
@@ -252,8 +252,8 @@ exports.DISCORD_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(exports.DISCORD_TOOLKI
  *      fallar, porque parece que funcionó.
  */
 function herramientasDeDiscordPara(tipoDeCredencial) {
-    const permitidas = new Set((0, discord_operations_1.operacionesDeDiscordPara)(tipoDeCredencial));
-    const fuera = (0, discord_operations_1.camposDeDiscordNoDisponibles)(tipoDeCredencial);
+    const permitidas = new Set((0, discord_operations_js_1.operacionesDeDiscordPara)(tipoDeCredencial));
+    const fuera = (0, discord_operations_js_1.camposDeDiscordNoDisponibles)(tipoDeCredencial);
     return exports.DISCORD_TOOLKIT_SPECS.filter((s) => permitidas.has(s.operation)).map((s) => 
     /* Se devuelve una copia sólo cuando hay algo que quitar: así el camino
        normal —el bot, que puede con todo— sigue entregando las MISMAS

package/dist/dispatch.d.ts

@@ -8,7 +8,7 @@
  * orphan the node (the symptom Vector Store / AI / Markdown / Code /
  * File Transform all hit before this refactor).
  */
-import type { NodeType, NodeDispatchConfig } from './types';
+import type { NodeType, NodeDispatchConfig } from './types.js';
 export declare const NODE_DISPATCH: Record<NodeType, NodeDispatchConfig>;
 /** Get all MongoDB collection names for cascade cleanup */
 export declare function getAllNodeCollections(): string[];

package/dist/docs-toolkit.d.ts

@@ -13,7 +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 type { DocsOperation } from './docs-operations';
+import type { DocsOperation } from './docs-operations.js';
 export interface DocsToolkitParameter {
     name: string;
     /** El esquema MCP sólo admite estos tres. */

package/dist/drive-toolkit.d.ts

@@ -19,7 +19,7 @@
  * herramientas del mismo grupo tienen que ir seguidas. Los tres grupos son los
  * que ya inventaba el JSX que sustituye.
  */
-import type { DriveOperation } from './drive-operations';
+import type { DriveOperation } from './drive-operations.js';
 export interface DriveToolkitParameter {
     name: string;
     type: 'string' | 'number' | 'boolean';

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

@@ -0,0 +1,67 @@
+/**
+ * Google Calendar operation enum — single source of truth across the API,
+ * Dashboard, and Message Broker. Used by:
+ *   - calendarAction entity / DTO (api): operation field + validation
+ *   - dashboard CalendarActionGoogleOperation type
+ *   - broker hostwebhook types + tool schemas
+ *   - any future calendar-related node
+ *
+ * Adding a new Calendar operation = add it here, bump this package's
+ * version, publish to npm, and re-install in the consuming repos.
+ * Each consumer still owns its operation-specific config schema (the
+ * dashboard owns the UI form schema, the api owns the dispatch logic),
+ * but the canonical list of valid operation strings lives here.
+ */
+export declare const GOOGLE_CALENDAR_OPERATIONS: readonly ["createEvent", "updateEvent", "deleteEvent", "listEvents", "getEvent", "listCalendars", "findFreeSlots", "proposeEvent", "confirmEvent"];
+export type GoogleCalendarOperation = (typeof GOOGLE_CALENDAR_OPERATIONS)[number];
+/** Type guard — useful when validating untrusted input (DTOs, tool calls). */
+export declare function isGoogleCalendarOperation(value: unknown): value is GoogleCalendarOperation;
+export type GoogleCalendarParamTarget = 'eventConfig' | 'listConfig' | 'root';
+export type GoogleCalendarParamType = 
+/** Campo de texto con autocompletado de `{{payload.*}}`. */
+'template' | 'number' | 'select'
+/** El `TimezonePicker` que ya existe en el dashboard. */
+ | 'timezone';
+export interface GoogleCalendarParamSpec {
+    /** La clave DENTRO de `target`. Es la del cable, no un nombre de UI. */
+    name: string;
+    /** Dónde vive en la entidad. */
+    target: GoogleCalendarParamTarget;
+    label: string;
+    type: GoogleCalendarParamType;
+    required?: boolean;
+    /** Texto de ayuda. Llano: el paquete no lleva React. */
+    description?: string;
+    placeholder?: string;
+    default?: string | number;
+    options?: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>;
+    min?: number;
+    max?: number;
+    /**
+     * Cómo se llama esta misma cosa en el `config` que espera el ejecutor
+     * compartido (`google-calendar-operations.service.ts`). El ejecutor está
+     * escrito para la ruta del toolkit, donde el LLM manda los nombres **sin**
+     * sufijo, así que `summaryTemplate` viaja como `summary`. Sólo lo llevan los
+     * params de las operaciones que van por ese despachador.
+     */
+    execKey?: string;
+}
+export interface GoogleCalendarOperationSpec {
+    /** Etiqueta del desplegable, y la misma que pinta el lienzo y el panel. */
+    label: string;
+    /** Sub-línea del desplegable. */
+    description: string;
+    /** Método de la API de Google al que corresponde. */
+    apiMethod: string;
+    /**
+     * Si se ejecuta por el despachador genérico (`calendarOps.run`) en vez de por
+     * un `case` escrito a mano. Son las cuatro que se abrieron el 2026-08-11.
+     */
+    viaExecutor?: boolean;
+    /** Orden de pantalla. */
+    params: GoogleCalendarParamSpec[];
+}
+export declare const GOOGLE_CALENDAR_OPERATION_SPECS: Record<GoogleCalendarOperation, GoogleCalendarOperationSpec>;

package/dist/esm/calendar-operations.js

@@ -0,0 +1,176 @@
+/**
+ * Google Calendar operation enum — single source of truth across the API,
+ * Dashboard, and Message Broker. Used by:
+ *   - calendarAction entity / DTO (api): operation field + validation
+ *   - dashboard CalendarActionGoogleOperation type
+ *   - broker hostwebhook types + tool schemas
+ *   - any future calendar-related node
+ *
+ * Adding a new Calendar operation = add it here, bump this package's
+ * version, publish to npm, and re-install in the consuming repos.
+ * Each consumer still owns its operation-specific config schema (the
+ * dashboard owns the UI form schema, the api owns the dispatch logic),
+ * but the canonical list of valid operation strings lives here.
+ */
+export const GOOGLE_CALENDAR_OPERATIONS = [
+    'createEvent',
+    'updateEvent',
+    'deleteEvent',
+    'listEvents',
+    'getEvent',
+    /** List all calendars the user can write to. Lets the LLM discover
+     *  ids before passing `calendarId` to other ops. */
+    'listCalendars',
+    /** freebusy.query — returns free windows in a date range. Optionally
+     *  combine across attendees to find common availability. */
+    'findFreeSlots',
+    /** Create a tentative event (status: tentative, no invites sent). The
+     *  user sees it greyed out in their calendar; LLM follows up with
+     *  confirmEvent to promote. Mirrors emailAction's createDraft → sendDraft. */
+    'proposeEvent',
+    /** Promote a tentative event to confirmed + send invites. Mirrors
+     *  emailAction's sendDraft. */
+    'confirmEvent',
+];
+/** Type guard — useful when validating untrusted input (DTOs, tool calls). */
+export function isGoogleCalendarOperation(value) {
+    return (typeof value === 'string' &&
+        GOOGLE_CALENDAR_OPERATIONS.includes(value));
+}
+/* Fábricas de los campos que se repiten entre operaciones. */
+const eventIdParam = (label, description) => ({
+    name: 'eventIdTemplate',
+    target: 'root',
+    label,
+    type: 'template',
+    required: true,
+    placeholder: '{{payload.eventId}}',
+    description,
+    execKey: 'eventId',
+});
+/** Los siete de `eventConfig`, que comparten `createEvent`, `updateEvent` y
+    `proposeEvent`. */
+const eventConfigParams = () => [
+    { name: 'summaryTemplate', target: 'eventConfig', label: 'Summary', type: 'template', placeholder: '{{payload.title}}', execKey: 'summary' },
+    { name: 'descriptionTemplate', target: 'eventConfig', label: 'Description', type: 'template', placeholder: 'Event description... (supports {{templates}})', execKey: 'description' },
+    { name: 'locationTemplate', target: 'eventConfig', label: 'Location', type: 'template', placeholder: '{{payload.location}}', execKey: 'location' },
+    { name: 'startTemplate', target: 'eventConfig', label: 'Start Date', type: 'template', placeholder: '{{payload.startTime}}', execKey: 'start' },
+    { name: 'endTemplate', target: 'eventConfig', label: 'End Date', type: 'template', placeholder: '{{payload.endTime}}', execKey: 'end' },
+    {
+        name: 'attendeesTemplate',
+        target: 'eventConfig',
+        label: 'Attendees (comma-separated emails)',
+        type: 'template',
+        placeholder: '{{payload.attendees}}',
+        description: 'e.g. user@example.com, other@example.com',
+        execKey: 'attendees',
+    },
+    { name: 'timeZone', target: 'eventConfig', label: 'Time Zone', type: 'timezone', execKey: 'timeZone' },
+];
+export const GOOGLE_CALENDAR_OPERATION_SPECS = {
+    createEvent: {
+        label: 'Create Event',
+        description: 'Create a new calendar event',
+        apiMethod: 'events.insert',
+        params: eventConfigParams(),
+    },
+    updateEvent: {
+        label: 'Update Event',
+        description: 'Update an existing event by ID',
+        apiMethod: 'events.patch',
+        params: [
+            eventIdParam('Event ID', 'Template to resolve the Google Calendar event ID'),
+            ...eventConfigParams(),
+        ],
+    },
+    deleteEvent: {
+        label: 'Delete Event',
+        description: 'Delete an event by ID',
+        apiMethod: 'events.delete',
+        params: [eventIdParam('Event ID', 'Template to resolve the Google Calendar event ID')],
+    },
+    listEvents: {
+        label: 'List Events',
+        description: 'List events in a date range',
+        apiMethod: 'events.list',
+        params: [
+            { name: 'timeMinTemplate', target: 'listConfig', label: 'Start Date', type: 'template', placeholder: '{{payload.from}}', execKey: 'timeMin' },
+            { name: 'timeMaxTemplate', target: 'listConfig', label: 'End Date', type: 'template', placeholder: '{{payload.to}}', execKey: 'timeMax' },
+            { name: 'maxResults', target: 'listConfig', label: 'Max Results', type: 'number', min: 1, max: 2500, default: 10 },
+            { name: 'query', target: 'listConfig', label: 'Search Query', type: 'template', placeholder: 'meeting' },
+        ],
+    },
+    getEvent: {
+        label: 'Get Event',
+        description: 'Get a single event by ID',
+        apiMethod: 'events.get',
+        params: [eventIdParam('Event ID', 'Template to resolve the Google Calendar event ID')],
+    },
+    /* ── Las cuatro que se abrieron al modo directo el 2026-08-11 ── */
+    listCalendars: {
+        label: 'List Calendars',
+        description: 'List the calendars you can write to (iterable output)',
+        apiMethod: 'calendarList.list',
+        viaExecutor: true,
+        /* Sin campos: no toma nada. Es de descubrimiento, así que en un pipeline
+           determinista aporta poco; está por completitud del enum. */
+        params: [],
+    },
+    findFreeSlots: {
+        label: 'Find Free Slots',
+        description: 'Find open windows in a date range (iterable output)',
+        apiMethod: 'freebusy.query',
+        viaExecutor: true,
+        params: [
+            { name: 'timeMinTemplate', target: 'listConfig', label: 'Window Start', type: 'template', required: true, placeholder: '{{payload.from}}', description: 'ISO 8601. Start of the window to search.', execKey: 'timeMin' },
+            { name: 'timeMaxTemplate', target: 'listConfig', label: 'Window End', type: 'template', required: true, placeholder: '{{payload.to}}', description: 'ISO 8601. End of the window to search.', execKey: 'timeMax' },
+            { name: 'durationMinutes', target: 'listConfig', label: 'Slot Length (minutes)', type: 'number', min: 15, max: 480, default: 30, description: 'Only windows at least this long are returned.', execKey: 'durationMinutes' },
+            { name: 'calendarIds', target: 'listConfig', label: 'Extra Calendars (comma-separated ids)', type: 'template', placeholder: 'primary, team@example.com', description: 'Combine availability across these. Empty = just the calendar configured above.', execKey: 'calendarIds' },
+            { name: 'timeZone', target: 'listConfig', label: 'Time Zone', type: 'timezone', description: 'IANA zone used to read the window bounds.', execKey: 'timeZone' },
+        ],
+    },
+    proposeEvent: {
+        label: 'Propose Event (tentative)',
+        description: 'Create a tentative event — no invites sent',
+        apiMethod: 'events.insert (status: tentative)',
+        viaExecutor: true,
+        params: [
+            ...eventConfigParams(),
+            /* `recurrence` sólo entra aquí, que va por el ejecutor. `createEvent` y
+               `updateEvent` siguen sin él porque su ruta es el `buildEventBody`
+               escrito a mano del servicio: es una asimetría entre modos que ya
+               existía y que esto no crea ni arregla. */
+            {
+                name: 'recurrenceTemplate',
+                target: 'eventConfig',
+                label: 'Recurrence (RRULE)',
+                type: 'template',
+                placeholder: 'RRULE:FREQ=WEEKLY;BYDAY=MO',
+                description: 'One RFC 5545 rule. Empty = a one-off event.',
+                execKey: 'recurrence',
+            },
+        ],
+    },
+    confirmEvent: {
+        label: 'Confirm Proposed Event',
+        description: 'Promote a tentative event and send invites',
+        apiMethod: 'events.patch (status: confirmed)',
+        viaExecutor: true,
+        params: [
+            eventIdParam('Proposal ID', 'The proposalId a Propose Event run returned. Normally {{payload.proposalId}} from an upstream node — this op is meant to sit downstream of a Propose Event.'),
+            {
+                name: 'sendUpdates',
+                target: 'root',
+                label: 'Invite Policy',
+                type: 'select',
+                default: 'all',
+                options: [
+                    { value: 'all', label: 'All attendees' },
+                    { value: 'externalOnly', label: 'External attendees only' },
+                    { value: 'none', label: "Don't send invites" },
+                ],
+                execKey: 'sendUpdates',
+            },
+        ],
+    },
+};

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

@@ -0,0 +1,50 @@
+/**
+ * Calendar AI Toolkit — las nueve herramientas que un calendarAction expone
+ * cuando `aiEnabled` está encendido.
+ *
+ * **Se escribe una sola vez.** Antes vivía dos veces —aquí y en
+ * `api/src/mcp-servers/toolkit-specs.ts`— y las dos copias YA habían derivado:
+ * las **siete** operaciones que aceptan `calendarId` describían el parámetro de
+ * dos maneras distintas. Gana la de la api, que es la única que dice cuál es el
+ * defecto:
+ *
+ *     api        "Optional calendar id. Defaults to the configured calendar
+ *                 (usually 'primary'). Use list_my_calendars to discover ids."
+ *     dashboard  "Optional override of the configured calendar. Use
+ *                 list_my_calendars first to discover ids when the user
+ *                 mentions a non-default calendar."
+ *
+ * Esa deriva estaba en la descripción de un PARÁMETRO, así que el conteo de la
+ * auditoría del 2026-08-10 no la veía y daba Calendar por limpio. Con las
+ * descripciones de parámetro incluidas, la deriva real de los ocho toolkits
+ * duplicados eran 32 y no 18.
+ *
+ * Dos cosas que **no** se añaden, a propósito:
+ *   - `group`: Calendar nunca tuvo cabeceras de grupo en su lista, y meterlas
+ *     es estructura visible nueva.
+ *   - `destructive` en `delete_calendar_event`: cambiaría el comportamiento de
+ *     `requireConfirmationForDestructive`. Mismo criterio que en Telegram.
+ *
+ * El array se generó desde la copia de la api para que las descripciones largas
+ * salieran idénticas, no tecleadas.
+ */
+import type { GoogleCalendarOperation } from './calendar-operations.js';
+export interface GoogleCalendarToolkitParameter {
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+    description: string;
+    required: boolean;
+}
+export interface GoogleCalendarToolkitSpec {
+    operation: GoogleCalendarOperation;
+    /** Etiqueta corta de la fila en la lista de herramientas. */
+    label: string;
+    /** El nombre con el que el LLM llama a la herramienta. */
+    toolName: string;
+    /** Descripción y reglas de uso que ve el LLM. */
+    description: string;
+    parameters: GoogleCalendarToolkitParameter[];
+}
+export declare const GOOGLE_CALENDAR_TOOLKIT_SPECS: GoogleCalendarToolkitSpec[];
+/** Índice por nombre de herramienta, para enrutar un `tools/call` sin recorrer. */
+export declare const GOOGLE_CALENDAR_TOOLKIT_BY_TOOL_NAME: Record<string, GoogleCalendarToolkitSpec>;

package/dist/esm/calendar-toolkit.js

@@ -0,0 +1,152 @@
+/**
+ * Calendar AI Toolkit — las nueve herramientas que un calendarAction expone
+ * cuando `aiEnabled` está encendido.
+ *
+ * **Se escribe una sola vez.** Antes vivía dos veces —aquí y en
+ * `api/src/mcp-servers/toolkit-specs.ts`— y las dos copias YA habían derivado:
+ * las **siete** operaciones que aceptan `calendarId` describían el parámetro de
+ * dos maneras distintas. Gana la de la api, que es la única que dice cuál es el
+ * defecto:
+ *
+ *     api        "Optional calendar id. Defaults to the configured calendar
+ *                 (usually 'primary'). Use list_my_calendars to discover ids."
+ *     dashboard  "Optional override of the configured calendar. Use
+ *                 list_my_calendars first to discover ids when the user
+ *                 mentions a non-default calendar."
+ *
+ * Esa deriva estaba en la descripción de un PARÁMETRO, así que el conteo de la
+ * auditoría del 2026-08-10 no la veía y daba Calendar por limpio. Con las
+ * descripciones de parámetro incluidas, la deriva real de los ocho toolkits
+ * duplicados eran 32 y no 18.
+ *
+ * Dos cosas que **no** se añaden, a propósito:
+ *   - `group`: Calendar nunca tuvo cabeceras de grupo en su lista, y meterlas
+ *     es estructura visible nueva.
+ *   - `destructive` en `delete_calendar_event`: cambiaría el comportamiento de
+ *     `requireConfirmationForDestructive`. Mismo criterio que en Telegram.
+ *
+ * El array se generó desde la copia de la api para que las descripciones largas
+ * salieran idénticas, no tecleadas.
+ */
+const p = (name, description, required = true, type = 'string') => ({ name, type, description, required });
+export const GOOGLE_CALENDAR_TOOLKIT_SPECS = [
+    {
+        operation: "createEvent",
+        label: "Create event",
+        toolName: "create_calendar_event",
+        description: "Create a new event on the user's calendar. USAGE RULES: (1) Always include start AND end (ISO 8601 datetime or YYYY-MM-DD for all-day). (2) For ALL-DAY events the `end` date is EXCLUSIVE — to cover Apr 19+20 send start=2026-04-19 end=2026-04-21. A single-day all-day event needs end = start + 1 day. (3) Confirm date + time + timezone in your reply (the user lives in Mexico City UTC-6 unless told otherwise). (4) Compose the summary fresh from the user's CURRENT request — never reuse content recalled from memory unless the user explicitly references it. (5) For events with external attendees or significant impact, prefer propose_calendar_event (tentative, no invites) so the user can preview before invites go out.",
+        parameters: [
+            p("summary", "Short event title.", true),
+            p("start", "Event start. ISO 8601 datetime (e.g. 2026-04-19T15:00:00) or date (YYYY-MM-DD) for all-day.", true),
+            p("end", "Event end. Same format as start. For all-day events this is EXCLUSIVE: an event that covers Apr 19+20 needs end=2026-04-21.", true),
+            p("description", "Optional longer description.", false),
+            p("location", "Optional physical or virtual location.", false),
+            p("attendees", "Comma-separated emails to invite.", false),
+            p("timeZone", "IANA timezone (e.g. America/Mexico_City). Defaults to UTC.", false),
+            p("recurrence", "Optional RFC 5545 RRULE string for repeating events (e.g. \"RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;COUNT=10\"). Daily=\"RRULE:FREQ=DAILY\"; weekly Mon=\"RRULE:FREQ=WEEKLY;BYDAY=MO\"; monthly first=\"RRULE:FREQ=MONTHLY;BYDAY=1MO\". Confirm the recurrence pattern in your reply.", false),
+            p("calendarId", "Optional calendar id. Defaults to the configured calendar (usually 'primary'). Use list_my_calendars to discover ids.", false),
+        ],
+    },
+    {
+        operation: "updateEvent",
+        label: "Update event",
+        toolName: "update_calendar_event",
+        description: "Update an existing event by id. Only fields you provide are changed (PATCH semantics). USAGE RULES: (1) Use eventId from a getEvent / listEvents call earlier in THIS conversation, never from memory. (2) When changing time, confirm the new time + timezone in your reply. (3) EXTENDING an all-day event across more days: send the new `end` as the day AFTER the last day (Google's all-day end is EXCLUSIVE). To make an event cover Apr 19+20, set end=2026-04-21. (4) When you change one of start/end on an all-day event, send BOTH so the new range is unambiguous (otherwise PATCH may leave a stale boundary).",
+        parameters: [
+            p("eventId", "Event id from listEvents / getEvent in THIS conversation.", true),
+            p("summary", "Optional new title.", false),
+            p("start", "Optional new start. For all-day events use YYYY-MM-DD.", false),
+            p("end", "Optional new end. For all-day events this is EXCLUSIVE: to cover through Apr 20 send end=2026-04-21.", false),
+            p("description", "Optional new description.", false),
+            p("location", "Optional new location.", false),
+            p("attendees", "Optional new attendee list (REPLACES existing).", false),
+            p("timeZone", "Optional timezone.", false),
+            p("recurrence", "Optional RFC 5545 RRULE string for repeating events (e.g. \"RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;COUNT=10\"). Daily=\"RRULE:FREQ=DAILY\"; weekly Mon=\"RRULE:FREQ=WEEKLY;BYDAY=MO\"; monthly first=\"RRULE:FREQ=MONTHLY;BYDAY=1MO\". Confirm the recurrence pattern in your reply.", false),
+            p("calendarId", "Optional calendar id. Defaults to the configured calendar (usually 'primary'). Use list_my_calendars to discover ids.", false),
+        ],
+    },
+    {
+        operation: "deleteEvent",
+        label: "Delete event",
+        toolName: "delete_calendar_event",
+        description: "Permanently delete an event. USAGE RULES: (1) ALWAYS confirm with the user before calling this — calendar deletes are silent and irreversible. (2) Use eventId from a tool call earlier in THIS conversation.",
+        parameters: [
+            p("eventId", "Event id to delete.", true),
+            p("calendarId", "Optional calendar id. Defaults to the configured calendar (usually 'primary'). Use list_my_calendars to discover ids.", false),
+        ],
+    },
+    {
+        operation: "listEvents",
+        label: "List events",
+        toolName: "list_calendar_events",
+        description: "Search the user's calendar. Returns headers (summary, start, end, attendees) per match. USAGE RULES: (1) Default to next 7 days when the user doesn't specify a window. (2) Use ISO datetimes for timeMin / timeMax. (3) For full event details (description, location), call getEvent with the specific id.",
+        parameters: [
+            p("timeMin", "Start of window (ISO 8601). Defaults to now.", false),
+            p("timeMax", "End of window (ISO 8601). Defaults to 7 days from now.", false),
+            p("maxResults", "Default 25, max 250.", false, "number"),
+            p("query", "Free-text search across summary/description/attendees.", false),
+            p("timeZone", "IANA timezone for parsing timeMin/timeMax.", false),
+            p("calendarId", "Optional calendar id. Defaults to the configured calendar (usually 'primary'). Use list_my_calendars to discover ids.", false),
+        ],
+    },
+    {
+        operation: "getEvent",
+        label: "Get event",
+        toolName: "get_calendar_event",
+        description: "Fetch a single event by id. Returns full details including description, attendees, organizer, recurrence.",
+        parameters: [
+            p("eventId", "Event id to fetch.", true),
+            p("calendarId", "Optional calendar id. Defaults to the configured calendar (usually 'primary'). Use list_my_calendars to discover ids.", false),
+        ],
+    },
+    {
+        operation: "listCalendars",
+        label: "List my calendars",
+        toolName: "list_my_calendars",
+        description: "Return all calendars the user can write to (primary + shared + secondary). USAGE RULES: (1) Call this when the user mentions a non-default calendar by name (e.g. 'add this to my Work calendar') and you don't yet know its id. (2) After listing, pass the matching `id` as `calendarId` on subsequent ops to target that calendar.",
+        parameters: [],
+    },
+    {
+        operation: "findFreeSlots",
+        label: "Find free slots",
+        toolName: "find_calendar_free_slots",
+        description: "Return open windows in a date range across one or more calendars. USAGE RULES: (1) Call this BEFORE proposing / creating an event when the user asks 'when am I free' or wants you to pick a time. (2) Default window: next 7 days, business hours 8am-6pm in the user's timezone. (3) Suggest the top 2-3 slots in your reply, then ask which they prefer.",
+        parameters: [
+            p("timeMin", "Start of window (ISO 8601).", true),
+            p("timeMax", "End of window (ISO 8601).", true),
+            p("durationMinutes", "Required slot length in minutes. Default 30, min 15, max 480.", false, "number"),
+            p("calendarIds", "Comma-separated calendar ids to combine availability across. Defaults to the configured calendar.", false),
+            p("timeZone", "IANA timezone for parsing timeMin/timeMax.", false),
+        ],
+    },
+    {
+        operation: "proposeEvent",
+        label: "Propose event (tentative)",
+        toolName: "propose_calendar_event",
+        description: "Create a TENTATIVE event (status: tentative, NO invites sent). The user sees it greyed out in their calendar. USAGE RULES: (1) Use this instead of create_calendar_event for events with external attendees or significant impact — the user previews before invites fire. (2) Show the proposalId in your reply ('I drafted: <details>. Confirm with proposalId X to send invites.'). (3) After the user confirms, call confirm_calendar_event with that proposalId. If they reject, call delete_calendar_event with it.",
+        parameters: [
+            p("summary", "Short event title.", true),
+            p("start", "Event start (ISO 8601 or YYYY-MM-DD for all-day).", true),
+            p("end", "Event end. For all-day events this is EXCLUSIVE: to cover through Apr 20 send end=2026-04-21.", true),
+            p("description", "Optional longer description.", false),
+            p("location", "Optional location.", false),
+            p("attendees", "Optional comma-separated emails (NOT invited yet — only saved on the tentative event).", false),
+            p("timeZone", "IANA timezone.", false),
+            p("recurrence", "Optional RFC 5545 RRULE string for repeating events (e.g. \"RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;COUNT=10\"). Daily=\"RRULE:FREQ=DAILY\"; weekly Mon=\"RRULE:FREQ=WEEKLY;BYDAY=MO\"; monthly first=\"RRULE:FREQ=MONTHLY;BYDAY=1MO\". Confirm the recurrence pattern in your reply.", false),
+            p("calendarId", "Optional calendar id. Defaults to the configured calendar (usually 'primary'). Use list_my_calendars to discover ids.", false),
+        ],
+    },
+    {
+        operation: "confirmEvent",
+        label: "Confirm proposed event",
+        toolName: "confirm_calendar_event",
+        description: "Promote a tentative event to confirmed and (by default) send invites to attendees. Pairs with propose_calendar_event for the preview-then-commit flow. USAGE RULES: (1) Use the proposalId from your most recent propose_calendar_event call in THIS conversation — never from memory. (2) sendUpdates default 'all' fires invites; pass 'externalOnly' for just non-org attendees, or 'none' to silently confirm.",
+        parameters: [
+            p("eventId", "Proposal id (returned by propose_calendar_event as proposalId).", true),
+            p("sendUpdates", "Invite policy: 'all' (default), 'externalOnly', or 'none'.", false),
+            p("calendarId", "Optional calendar id. Defaults to the configured calendar (usually 'primary'). Use list_my_calendars to discover ids.", false),
+        ],
+    },
+];
+/** Índice por nombre de herramienta, para enrutar un `tools/call` sin recorrer. */
+export const GOOGLE_CALENDAR_TOOLKIT_BY_TOOL_NAME = Object.fromEntries(GOOGLE_CALENDAR_TOOLKIT_SPECS.map((s) => [s.toolName, s]));

package/dist/esm/capacidad-de-credencial.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Qué puede hacer un nodo según el TIPO de credencial que lleva puesta.
+ *
+ * Hasta ahora un nodo ofrecía siempre todas sus operaciones, porque todas sus
+ * credenciales podían hacerlas todas. Con los webhooks deja de ser cierto, y de
+ * una forma muy desigual:
+ *
+ *   - Un webhook de Discord ejecuta 4 de las 17 —publicar, y leer/editar/borrar
+ *     **sus propios** mensajes—, siempre en el único canal para el que se creó.
+ *   - Un webhook de Slack ejecuta **1 de 16**, y ni siquiera puede elegir el
+ *     canal: lo fija quien instala la credencial.
+ *
+ * Esa desigualdad es la que decide la forma de este fichero. No basta con
+ * esconder operaciones: hay que esconder **campos dentro de** una operación,
+ * porque el destino deja de ser una pregunta. Por eso son dos listas y no una.
+ *
+ * ── Dónde vive esto y por qué ──
+ *
+ * Aquí, en el paquete, y no en cada consumidor. Lo mismo tienen que saberlo
+ * CUATRO sitios, y si cada uno lo deduce por su cuenta acaban discrepando sin
+ * que nada falle al compilar:
+ *
+ *   1. el selector de operación de la pantalla de detalle;
+ *   2. el renderizador de campos de esa misma pantalla;
+ *   3. la validación al guardar, en la api;
+ *   4. **la expansión del toolkit de IA** — que es el que se rompe más callado:
+ *      sin esto, a un nodo con credencial de webhook se le entregan al modelo
+ *      17 herramientas de las que 13 fallan siempre.
+ *
+ * Es la misma razón por la que los toolkits se mudaron aquí en 1.66.0. Tener el
+ * dato dos veces es tenerlo mal a la vuelta de unas semanas.
+ */
+/**
+ * Lo que una credencial concreta deja hacer.
+ *
+ * `operaciones` ausente significa «todas»: así el caso normal —un bot, que
+ * puede con todo— no necesita enumerarse ni mantenerse, y sólo se escribe lo
+ * que está ACOTADO. Añadir una operación nueva al nodo no obliga a tocar este
+ * fichero salvo que el webhook también pueda ejecutarla, que es justo la
+ * decisión que uno quiere tener que tomar a mano.
+ */
+export interface CapacidadDeCredencial<Op extends string = string> {
+    /** Las que puede ejecutar. Ausente = todas las del nodo. */
+    operaciones?: readonly Op[];
+    /**
+     * Campos que desaparecen del formulario y que la validación rechaza.
+     *
+     * Se juntan aquí dos motivos que para el usuario son el mismo —«esto no lo
+     * eliges tú»— aunque por dentro no lo sean: el que viene FIJADO por la
+     * credencial (el canal de un webhook) y el que el endpoint sencillamente NO
+     * ADMITE (responder a un mensaje: `Execute Webhook` no acepta
+     * `message_reference`). Separarlos daría dos listas que se consultan siempre
+     * juntas.
+     */
+    camposNoDisponibles?: readonly string[];
+}
+/** Mapa de un proveedor: tipo de credencial → lo que deja hacer. */
+export type CapacidadesPorCredencial<Op extends string = string> = Readonly<Record<string, CapacidadDeCredencial<Op>>>;
+/**
+ * Qué operaciones ofrecer para esta credencial.
+ *
+ * Sin tipo de credencial —el nodo todavía no tiene ninguna elegida— se
+ * devuelven todas: es un hueco por rellenar, no una restricción, y esconder
+ * operaciones ahí haría creer que el nodo no sabe hacerlas.
+ */
+export declare function operacionesPara<Op extends string>(todas: readonly Op[], mapa: CapacidadesPorCredencial<Op>, tipoDeCredencial: string | null | undefined): readonly Op[];
+/** Si esta credencial puede ejecutar esta operación. */
+export declare function puedeEjecutar<Op extends string>(todas: readonly Op[], mapa: CapacidadesPorCredencial<Op>, tipoDeCredencial: string | null | undefined, operacion: Op): boolean;
+/**
+ * Campos que esta credencial no deja elegir.
+ *
+ * Devuelve un `Set` porque quien lo usa siempre pregunta «¿este campo sí o
+ * no?», nunca recorre la lista.
+ */
+export declare function camposNoDisponiblesPara(mapa: CapacidadesPorCredencial, tipoDeCredencial: string | null | undefined): ReadonlySet<string>;