@hostwebhook/node-types 1.68.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/credentials.d.ts

@@ -36,7 +36,89 @@ export interface CredentialTypeRegistration {
  * Registry — order matters for fallthrough behavior in pickers (most
  * common types first), but not for correctness.
  */
-export declare const CREDENTIAL_TYPES: readonly CredentialTypeRegistration[];
+export declare const CREDENTIAL_TYPES: readonly [{
+    readonly type: "google_service_account";
+}, {
+    readonly type: "oauth2_google";
+}, {
+    readonly type: "oauth2_atlassian";
+}, {
+    readonly type: "mongodb";
+    readonly ssrfValidated: true;
+    readonly tunnelable: true;
+}, {
+    readonly type: "postgres";
+    readonly ssrfValidated: true;
+    readonly tunnelable: true;
+}, {
+    readonly type: "slack_webhook";
+}, {
+    readonly type: "slack_oauth";
+}, {
+    readonly type: "discord_webhook";
+}, {
+    readonly type: "llm_anthropic";
+}, {
+    readonly type: "llm_openai";
+}, {
+    readonly type: "llm_google";
+}, {
+    readonly type: "llm_groq";
+}, {
+    readonly type: "llm_openrouter";
+}, {
+    readonly type: "llm_ollama";
+}, {
+    readonly type: "firecrawl";
+}, {
+    readonly type: "http_auth";
+}, {
+    readonly type: "aws_s3";
+}, {
+    readonly type: "memory_contextwindow";
+}, {
+    readonly type: "memory_mongodb";
+    readonly ssrfValidated: true;
+    readonly tunnelable: true;
+}, {
+    readonly type: "mcp_server";
+}, {
+    readonly type: "voice_agent";
+}, {
+    readonly type: "telegram_bot";
+}, {
+    readonly type: "whatsapp_business";
+}, {
+    readonly type: "discord_bot";
+}, {
+    readonly type: "discord_oauth";
+}, {
+    readonly type: "bluesky_app_password";
+}, {
+    readonly type: "twitter_oauth2";
+}, {
+    readonly type: "mastodon_oauth2";
+}, {
+    readonly type: "linkedin_oauth2";
+}, {
+    readonly type: "threads_oauth2";
+}, {
+    readonly type: "instagram_oauth2";
+}, {
+    readonly type: "facebook_oauth2";
+}, {
+    readonly type: "notion_internal";
+}, {
+    readonly type: "notion_oauth";
+}, {
+    readonly type: "mailchimp_oauth2";
+}, {
+    readonly type: "shopify_oauth2";
+}, {
+    readonly type: "github_app";
+}, {
+    readonly type: "github_pat";
+}];
 /**
  * Plain string array — what the Mongoose `enum` field and the
  * class-validator `@IsIn(...)` decorator both consume. Keep it as a
@@ -51,7 +133,12 @@ export declare const credentialTypeValues: () => string[];
  * Discriminated union of every supported type. Use as the field type
  * on entities + DTOs so a typo at the call site fails at compile
  * time, not at runtime via a Mongoose validation error.
+ *
+ * ⚠️ Y ahora ES una unión. Hasta la 1.69.0 esto valía `string` —la anotación
+ * de `CREDENTIAL_TYPES` ensanchaba los literales— así que la frase de arriba
+ * describía una protección que no existía. Ver el comentario del `satisfies`
+ * al final del registro.
  */
-export type CredentialType = typeof CREDENTIAL_TYPES[number]['type'];
+export type CredentialType = (typeof CREDENTIAL_TYPES)[number]['type'];
 export declare function getCredentialType(type: string): CredentialTypeRegistration | undefined;
 export declare function isCredentialType(type: string): type is CredentialType;

package/dist/credentials.js

@@ -19,6 +19,23 @@ exports.CREDENTIAL_TYPES = [
     { type: 'llm_anthropic' },
     { type: 'llm_openai' },
     { type: 'llm_google' },
+    // La clave de API de Groq (`gsk_…`), que el usuario saca de
+    // https://console.groq.com/keys y pega. Un secreto suyo, sin OAuth de por
+    // medio, igual que los tres de arriba y que `llm_openrouter` de abajo.
+    //
+    // El sufijo es `groq` por la misma regla que explica el bloque de
+    // OpenRouter: de aquí salen `getModelsFor`/`getDefaultModel` quitando el
+    // prefijo `llm_`, así que lo que quede detrás tiene que ser LITERALMENTE el
+    // `LlmProvider`, y ése es `'groq'`.
+    //
+    // 🔥 Llega TARDE, y el agujero que tapa no era teórico: `groq` es un
+    // `LlmProvider` de pleno derecho desde hace tiempo —está en `LLM_PROVIDERS`,
+    // con sus cinco modelos en `LLM_MODELS.groq`— pero no tenía tipo de
+    // credencial. O sea que el proveedor se podía ELEGIR en el selector y no
+    // había dónde guardar su clave: una rama del catálogo inalcanzable, sin un
+    // solo error que lo dijera. El resto de la lista se anota antes de que la
+    // api exista precisamente para no llegar a esto.
+    { type: 'llm_groq' },
     // La clave de API de OpenRouter (`sk-or-v1-…`). Un secreto pegado por el
     // usuario, igual que los tres de arriba: no hay OAuth de por medio.
     //
@@ -31,10 +48,10 @@ exports.CREDENTIAL_TYPES = [
     // el validador del DTO, y un tipo que falte ahí no rompe al compilar — mata
     // el `create` de la credencial en runtime, con el usuario delante.
     //
-    // ⚠️ Y falta un vecino, que no es cosa de este cambio pero conviene que esté
-    // escrito: `groq` es un `LlmProvider` desde hace tiempo y NO tiene
-    // `llm_groq` en esta lista. O sea que hoy se puede elegir Groq como
-    // proveedor y no hay tipo de credencial con el que guardar su clave.
+    // ⚠️ El vecino que faltaba y que este bloque dejó escrito —`groq` sin su
+    // `llm_groq`— ya está arriba. Lo que queda de aquel aviso es la regla que lo
+    // hizo posible, y por eso la cubre ahora un test: cada `LlmProvider` de
+    // `LLM_PROVIDERS` tiene que tener su `llm_*` en esta lista.
     { type: 'llm_openrouter' },
     { type: 'llm_ollama' },
     { type: 'firecrawl' },
@@ -158,6 +175,16 @@ exports.CREDENTIAL_TYPES = [
     // que cambia es de dónde sale la lista de repositorios del formulario: los
     // del usuario, en vez de los que abarca una instalación.
     { type: 'github_pat' },
+    /* ⚠️ `as const satisfies …` y no `: readonly CredentialTypeRegistration[]`.
+       Los dos comprueban lo mismo —que cada entrada tenga la forma del registro—,
+       pero la ANOTACIÓN además ENSANCHA lo que se guarda: con ella cada `type` se
+       recuerda como `string`, y entonces `CredentialType` de más abajo es
+       literalmente `string`. O sea que la promesa de su comentario («un typo al
+       asignar falla al compilar») era falsa desde el primer día: `const t:
+       CredentialType = 'llm_openroutr'` compilaba sin rechistar.
+  
+       `satisfies` comprueba y NO ensancha, así que los literales sobreviven y la
+       unión es de verdad. El control está en `tipos-de-credencial.test.ts`. */
 ];
 /**
  * Plain string array — what the Mongoose `enum` field and the

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>;