@progress/kendo-angular-webmcp 24.0.0-develop.41

package/fesm2022/progress-kendo-angular-webmcp.mjs

@@ -0,0 +1,4873 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2026 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as i0 from '@angular/core';
+import { Input, Host, Optional, Inject, Directive, NgModule } from '@angular/core';
+import { isDocumentAvailable, KENDO_WEBMCP_HOST } from '@progress/kendo-angular-common';
+import { validatePackage } from '@progress/kendo-licensing';
+import { saveAs } from '@progress/kendo-file-saver';
+import { Workbook } from '@progress/kendo-ooxml';
+
+/**
+ * @hidden
+ */
+const packageMetadata = {
+    name: '@progress/kendo-angular-webmcp',
+    productName: 'Kendo UI for Angular',
+    productCode: 'KENDOUIANGULAR',
+    productCodes: ['KENDOUIANGULAR'],
+    publishDate: 1779255940,
+    version: '24.0.0-develop.41',
+    licensingDocsUrl: 'https://www.telerik.com/kendo-angular-ui/my-license/?utm_medium=product&utm_source=kendoangular&utm_campaign=kendo-ui-angular-purchase-license-keys-warning',
+};
+
+/**
+ * Resolves a `boolean | WebMcpConfig` input into a full config with defaults.
+ *
+ * @hidden
+ */
+function resolveConfig(value) {
+    if (value === false) {
+        return null;
+    }
+    if (value === true) {
+        return {};
+    }
+    return value;
+}
+
+/**
+ * @hidden
+ *
+ * Emits dataStateChange so kendoGridBinding re-processes data.
+ */
+function emitDataStateChange(grid) {
+    grid.dataStateChange.emit({
+        skip: grid.skip || 0,
+        take: grid.pageSize,
+        sort: grid.sort,
+        filter: grid.filter,
+        group: grid.group
+    });
+}
+/**
+ * @hidden
+ *
+ * Returns column fields that satisfy a predicate.
+ */
+function getColumnFields(grid, predicate) {
+    const fields = [];
+    const columns = grid.columns?.toArray() || [];
+    for (const col of columns) {
+        if ('field' in col && col.field) {
+            if (!predicate || predicate(col)) {
+                fields.push(col.field);
+            }
+        }
+    }
+    return fields;
+}
+/**
+ * @hidden
+ *
+ * Evaluates a highlight condition against an item value.
+ */
+function matchesHighlight(itemValue, operator, value) {
+    const numItem = Number(itemValue);
+    const numVal = Number(value);
+    const useNum = !isNaN(numItem) && !isNaN(numVal);
+    switch (operator) {
+        case 'eq': return useNum ? numItem === numVal : String(itemValue).toLowerCase() === String(value).toLowerCase();
+        case 'neq': return useNum ? numItem !== numVal : String(itemValue).toLowerCase() !== String(value).toLowerCase();
+        case 'gt': return useNum && numItem > numVal;
+        case 'gte': return useNum && numItem >= numVal;
+        case 'lt': return useNum && numItem < numVal;
+        case 'lte': return useNum && numItem <= numVal;
+        case 'contains': return String(itemValue).toLowerCase().includes(String(value).toLowerCase());
+        case 'startswith': return String(itemValue).toLowerCase().startsWith(String(value).toLowerCase());
+        case 'endswith': return String(itemValue).toLowerCase().endsWith(String(value).toLowerCase());
+        default: return false;
+    }
+}
+/**
+ * @hidden
+ *
+ * Finds a column by field name.
+ */
+function findColumn(grid, field) {
+    return (grid.columns?.toArray() || []).find(c => c.field === field);
+}
+/**
+ * @hidden
+ *
+ * Web MCP tool adapter for the Kendo Angular Grid component.
+ * Supports: sort, filter, group, page, select, export, column operations.
+ */
+class GridToolAdapter {
+    selector = 'kendo-grid';
+    registerTools(grid, config, modelContext, ngZone) {
+        const handles = [];
+        const prefix = config.dataName || 'kendo-grid';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' grid'
+            : 'Kendo UI Grid';
+        const rawOptions = this.buildToolOptions(grid, config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled).map(t => t.name));
+        handles.push(...this.registerSortTools(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerFilterTools(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerGroupTools(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerPageTools(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerSelectionTools(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerExportTools(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerColumnTools(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerSelectAllTool(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerGroupExpandTools(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerDetailTools(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerGetDataTool(grid, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerHighlightTools(grid, modelContext, ngZone, prefix, label, enabled));
+        return handles;
+    }
+    // Tool options builder
+    buildToolOptions(grid, config, label) {
+        const sort = !!grid.sortable;
+        const filter = !!grid.filterable;
+        const group = !!grid.groupable;
+        const page = !!grid.pageable;
+        const select = !!grid.selectable;
+        return [
+            { name: 'sort-column', description: `Sort the ${label} by a specified column field.`, enabled: sort },
+            { name: 'clear-sort', description: `Remove all sorting from the ${label}.`, enabled: sort },
+            { name: 'filter', description: `Apply a filter to a column in the ${label}.`, enabled: filter },
+            { name: 'clear-filters', description: `Remove all filters from the ${label}.`, enabled: filter },
+            { name: 'group', description: `Group the ${label} rows by a column field.`, enabled: group },
+            { name: 'clear-groups', description: `Remove all grouping from the ${label}.`, enabled: group },
+            { name: 'go-to-page', description: `Navigate to a specific page in the ${label}.`, enabled: page },
+            { name: 'set-page-size', description: `Change the number of rows per page in the ${label}.`, enabled: page },
+            { name: 'select-rows', description: `Select rows in the ${label} by their 0-based indices.`, enabled: select },
+            { name: 'clear-selection', description: `Deselect all rows in the ${label}.`, enabled: select },
+            { name: 'select-all', description: `Select all rows in the ${label}.`, enabled: select },
+            { name: 'export-pdf', description: `Export the ${label} to a PDF file.`, enabled: true },
+            { name: 'export-excel', description: `Export the ${label} data to an Excel file.`, enabled: true },
+            { name: 'export-csv', description: `Export the ${label} data to a CSV file.`, enabled: true },
+            { name: 'show-column', description: `Show a hidden column in the ${label}.`, enabled: true },
+            { name: 'hide-column', description: `Hide a visible column in the ${label}.`, enabled: true },
+            { name: 'lock-column', description: `Lock (freeze) a column in the ${label}.`, enabled: true },
+            { name: 'unlock-column', description: `Unlock a frozen column in the ${label}.`, enabled: true },
+            { name: 'reorder-column', description: `Move a column to a new position in the ${label}.`, enabled: !!grid.reorderable },
+            { name: 'resize-column', description: `Resize a column in the ${label} to a specified pixel width.`, enabled: !!grid.resizable },
+            { name: 'group-expand', description: `Expand a specific group in the ${label}.`, enabled: group },
+            { name: 'group-collapse', description: `Collapse a specific group in the ${label}.`, enabled: group },
+            { name: 'group-expand-all', description: `Expand all groups in the ${label}.`, enabled: group },
+            { name: 'group-collapse-all', description: `Collapse all groups in the ${label}.`, enabled: group },
+            { name: 'detail-expand', description: `Expand the detail row at a specific index in the ${label}.`, enabled: true },
+            { name: 'detail-collapse', description: `Collapse the detail row at a specific index in the ${label}.`, enabled: true },
+            { name: 'detail-expand-all', description: `Expand all detail rows in the ${label}.`, enabled: true },
+            { name: 'detail-collapse-all', description: `Collapse all detail rows in the ${label}.`, enabled: true },
+            { name: 'get-data', description: `Read the rows currently visible in the ${label} (after any active filter/sort/page) as JSON.`, enabled: true },
+            { name: 'highlight', description: `Visually highlight rows in the ${label} that match a condition. Uses the grid rowClass callback to apply the k-selected CSS class.`, enabled: true },
+            { name: 'clear-highlight', description: `Remove all row highlights from the ${label}.`, enabled: true }
+        ];
+    }
+    // Sort
+    registerSortTools(grid, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('sort-column')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-sort-column`,
+                description: `Sort the ${label} by a specified column field. Sets a new sort descriptor, replacing any existing sort.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: {
+                            type: 'string',
+                            description: 'The column field name to sort by. Omit to discover available sortable fields.'
+                        },
+                        dir: {
+                            type: 'string',
+                            enum: ['asc', 'desc'],
+                            description: 'Sort direction. Defaults to "asc".'
+                        }
+                    },
+                    required: []
+                },
+                execute: (args) => {
+                    const sortableFields = getColumnFields(grid, col => col.sortable !== false);
+                    const field = args['field'];
+                    const direction = args['dir'];
+                    if (!field) {
+                        return { success: true, message: 'Sortable fields: ' + sortableFields.join(', '), data: { sortableFields, currentSort: grid.sort || [] } };
+                    }
+                    if (!sortableFields.includes(field)) {
+                        return { success: false, message: `Field "${field}" is not sortable. Available: ${sortableFields.join(', ')}` };
+                    }
+                    const dir = direction === 'desc' ? 'desc' : 'asc';
+                    const descriptors = [{ field, dir }];
+                    zone.run(() => {
+                        grid.sort = descriptors;
+                        grid.sortChange.emit(descriptors);
+                        emitDataStateChange(grid);
+                    });
+                    return { success: true, message: `Sorted by "${field}" ${dir}ending.`, data: { sort: descriptors } };
+                }
+            }));
+        }
+        if (enabled.has('clear-sort')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-sort`,
+                description: `Remove all sorting from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        grid.sort = [];
+                        grid.sortChange.emit([]);
+                        emitDataStateChange(grid);
+                    });
+                    return { success: true, message: 'Sort cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Filter
+    registerFilterTools(grid, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('filter')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-filter`,
+                description: `Apply a filter to a column in the ${label}. Supports operators: eq, neq, contains, startswith, endswith, gt, gte, lt, lte, isnull, isnotnull.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: {
+                            type: 'string',
+                            description: 'The column field name to filter. Omit to discover available filterable fields.'
+                        },
+                        operator: {
+                            type: 'string',
+                            enum: ['eq', 'neq', 'contains', 'startswith', 'endswith', 'gt', 'gte', 'lt', 'lte', 'isnull', 'isnotnull'],
+                            description: 'Filter operator. Defaults to "contains". Use "eq", "gt", "lt", etc. for numeric or date columns.'
+                        },
+                        value: {
+                            description: 'The filter value.'
+                        }
+                    },
+                    required: []
+                },
+                execute: (args) => {
+                    const filterableFields = getColumnFields(grid);
+                    const field = args['field'];
+                    const operator = args['operator'] || 'contains';
+                    const value = args['value'];
+                    if (!field) {
+                        return { success: true, message: 'Filterable fields: ' + filterableFields.join(', '), data: { filterableFields, currentFilter: grid.filter } };
+                    }
+                    if (!filterableFields.includes(field)) {
+                        return { success: false, message: `Field "${field}" not found. Available: ${filterableFields.join(', ')}` };
+                    }
+                    const currentFilter = grid.filter || { logic: 'and', filters: [] };
+                    // Remove existing filters on the same field
+                    const otherFilters = currentFilter.filters.filter((f) => !('field' in f && f.field === field));
+                    const newFilter = {
+                        logic: currentFilter.logic || 'and',
+                        filters: [...otherFilters, { field, operator, value }]
+                    };
+                    zone.run(() => {
+                        grid.filter = newFilter;
+                        grid.filterChange.emit(newFilter);
+                        emitDataStateChange(grid);
+                    });
+                    return { success: true, message: `Filtered "${field}" ${operator} "${value}".`, data: { filter: newFilter } };
+                }
+            }));
+        }
+        if (enabled.has('clear-filters')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-filters`,
+                description: `Remove all filters from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const emptyFilter = { logic: 'and', filters: [] };
+                    zone.run(() => {
+                        grid.filter = emptyFilter;
+                        grid.filterChange.emit(emptyFilter);
+                        emitDataStateChange(grid);
+                    });
+                    return { success: true, message: 'All filters cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Group
+    registerGroupTools(grid, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('group')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-group`,
+                description: `Group the ${label} rows by a column field.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: {
+                            type: 'string',
+                            description: 'The column field name to group by. Omit to discover available fields.'
+                        }
+                    },
+                    required: []
+                },
+                execute: (args) => {
+                    const fields = getColumnFields(grid);
+                    const field = args['field'];
+                    if (!field) {
+                        return { success: true, message: 'Groupable fields: ' + fields.join(', '), data: { fields, currentGroup: grid.group || [] } };
+                    }
+                    if (!fields.includes(field)) {
+                        return { success: false, message: `Field "${field}" not found. Available: ${fields.join(', ')}` };
+                    }
+                    const currentGroups = grid.group || [];
+                    if (currentGroups.some((g) => g.field === field)) {
+                        return { success: true, message: `Already grouped by "${field}".`, data: { group: currentGroups } };
+                    }
+                    const newGroups = [...currentGroups, { field }];
+                    zone.run(() => {
+                        grid.group = newGroups;
+                        grid.groupChange.emit(newGroups);
+                        emitDataStateChange(grid);
+                    });
+                    return { success: true, message: `Grouped by "${field}".`, data: { group: newGroups } };
+                }
+            }));
+        }
+        if (enabled.has('clear-groups')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-groups`,
+                description: `Remove all grouping from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        grid.group = [];
+                        grid.groupChange.emit([]);
+                        emitDataStateChange(grid);
+                    });
+                    return { success: true, message: 'Groups cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Page
+    registerPageTools(grid, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('go-to-page')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-go-to-page`,
+                description: `Navigate to a specific page in the ${label}. Pages are 1-based.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        page: {
+                            type: 'number',
+                            description: 'The 1-based page number. Omit to get current page info.'
+                        }
+                    },
+                    required: []
+                },
+                execute: (args) => {
+                    const page = args['page'];
+                    const pageSize = grid.pageSize || 10;
+                    const totalItems = Array.isArray(grid.data) ? grid.data.length : (grid.data?.total || 0);
+                    const totalPages = Math.ceil(totalItems / pageSize) || 1;
+                    const currentPage = Math.floor((grid.skip || 0) / pageSize) + 1;
+                    if (!page) {
+                        return { success: true, message: `Page ${currentPage} of ${totalPages}.`, data: { currentPage, totalPages, pageSize, totalItems } };
+                    }
+                    if (page < 1 || page > totalPages) {
+                        return { success: false, message: `Page ${page} out of range (1–${totalPages}).` };
+                    }
+                    const newSkip = (page - 1) * pageSize;
+                    zone.run(() => {
+                        grid.skip = newSkip;
+                        grid.pageChange.emit({ skip: newSkip, take: pageSize });
+                        emitDataStateChange(grid);
+                    });
+                    return { success: true, message: `Navigated to page ${page}.`, data: { page, skip: newSkip, pageSize } };
+                }
+            }));
+        }
+        if (enabled.has('set-page-size')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-page-size`,
+                description: `Change the number of rows per page in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        pageSize: {
+                            type: 'number',
+                            description: 'Number of rows per page.'
+                        }
+                    },
+                    required: ['pageSize']
+                },
+                execute: (args) => {
+                    const newPageSize = args['pageSize'];
+                    if (!newPageSize || newPageSize < 1) {
+                        return { success: false, message: 'pageSize must be a positive number.' };
+                    }
+                    zone.run(() => {
+                        grid.pageSize = newPageSize;
+                        grid.skip = 0;
+                        grid.pageChange.emit({ skip: 0, take: newPageSize });
+                        emitDataStateChange(grid);
+                    });
+                    return { success: true, message: `Page size set to ${newPageSize}.`, data: { pageSize: newPageSize } };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Selection
+    registerSelectionTools(grid, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('select-rows')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select-rows`,
+                description: `Select rows in the ${label} by their data item indices (0-based).`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        indices: {
+                            type: 'array',
+                            items: { type: 'number' },
+                            description: 'Array of 0-based row indices to select.'
+                        }
+                    },
+                    required: ['indices']
+                },
+                execute: (args) => {
+                    const indices = args['indices'];
+                    const data = Array.isArray(grid.data) ? grid.data : (grid.data?.data ?? []);
+                    zone.run(() => {
+                        grid.selectionChange.emit({
+                            selectedRows: indices.map(i => ({ dataItem: data[i] ?? null, index: i })),
+                            deselectedRows: [],
+                            ctrlKey: false,
+                            shiftKey: false
+                        });
+                    });
+                    return { success: true, message: `Selected ${indices.length} row(s).` };
+                }
+            }));
+        }
+        if (enabled.has('clear-selection')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-selection`,
+                description: `Deselect all rows in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const data = Array.isArray(grid.data) ? grid.data : (grid.data?.data ?? []);
+                    zone.run(() => {
+                        grid.selectionChange.emit({
+                            selectedRows: [],
+                            deselectedRows: data.map((item, i) => ({ dataItem: item, index: i })),
+                            ctrlKey: false,
+                            shiftKey: false
+                        });
+                    });
+                    return { success: true, message: 'Selection cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Export
+    registerExportTools(grid, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('export-pdf')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-export-pdf`,
+                description: `Export the ${label} to a PDF file.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    if (typeof grid.saveAsPDF !== 'function') {
+                        return { success: false, message: 'PDF export is not configured. Add <kendo-grid-pdf> to the grid.' };
+                    }
+                    zone.run(() => grid.saveAsPDF());
+                    return { success: true, message: 'PDF export started.' };
+                }
+            }));
+        }
+        if (enabled.has('export-excel')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-export-excel`,
+                description: `Export the ${label} data to an Excel file.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    if (typeof grid.saveAsExcel !== 'function') {
+                        return { success: false, message: 'Excel export is not configured. Add <kendo-grid-excel> to the grid.' };
+                    }
+                    zone.run(() => grid.saveAsExcel());
+                    return { success: true, message: 'Excel export started.' };
+                }
+            }));
+        }
+        if (enabled.has('export-csv')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-export-csv`,
+                description: `Export the ${label} data to a CSV file.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    if (typeof grid.saveAsCSV !== 'function') {
+                        return { success: false, message: 'CSV export is not available.' };
+                    }
+                    zone.run(() => grid.saveAsCSV());
+                    return { success: true, message: 'CSV export started.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Column Operations
+    registerColumnTools(grid, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('show-column')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-show-column`,
+                description: `Show a hidden column in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'The field name of the column to show. Omit to list hidden columns.' }
+                    },
+                    required: []
+                },
+                execute: (args) => {
+                    const field = args['field'];
+                    const allFields = getColumnFields(grid);
+                    const hiddenFields = allFields.filter(f => findColumn(grid, f)?.hidden);
+                    if (!field) {
+                        return { success: true, message: 'Hidden columns: ' + (hiddenFields.length ? hiddenFields.join(', ') : 'none'), data: { hiddenFields } };
+                    }
+                    const col = findColumn(grid, field);
+                    if (!col) {
+                        return { success: false, message: `Column "${field}" not found. Available: ${allFields.join(', ')}` };
+                    }
+                    if (!col.hidden) {
+                        return { success: true, message: `Column "${field}" is already visible.` };
+                    }
+                    zone.run(() => {
+                        col.hidden = false;
+                        grid.columnInfoService?.changeVisibility([{ column: col, hidden: false }]);
+                    });
+                    return { success: true, message: `Column "${field}" is now visible.` };
+                }
+            }));
+        }
+        if (enabled.has('hide-column')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-hide-column`,
+                description: `Hide a visible column in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'The field name of the column to hide. Omit to list visible columns.' }
+                    },
+                    required: []
+                },
+                execute: (args) => {
+                    const field = args['field'];
+                    const allFields = getColumnFields(grid);
+                    const visibleFields = allFields.filter(f => !findColumn(grid, f)?.hidden);
+                    if (!field) {
+                        return { success: true, message: 'Visible columns: ' + visibleFields.join(', '), data: { visibleFields } };
+                    }
+                    const col = findColumn(grid, field);
+                    if (!col) {
+                        return { success: false, message: `Column "${field}" not found. Available: ${allFields.join(', ')}` };
+                    }
+                    if (col.hidden) {
+                        return { success: true, message: `Column "${field}" is already hidden.` };
+                    }
+                    zone.run(() => {
+                        col.hidden = true;
+                        grid.columnInfoService?.changeVisibility([{ column: col, hidden: true }]);
+                    });
+                    return { success: true, message: `Column "${field}" is now hidden.` };
+                }
+            }));
+        }
+        if (enabled.has('lock-column')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-lock-column`,
+                description: `Lock (freeze) a column in the ${label} so it stays visible during horizontal scrolling.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'The field name of the column to lock.' }
+                    },
+                    required: ['field']
+                },
+                execute: (args) => {
+                    const field = args['field'];
+                    const col = findColumn(grid, field);
+                    if (!col) {
+                        return { success: false, message: `Column "${field}" not found.` };
+                    }
+                    if (col.locked) {
+                        return { success: true, message: `Column "${field}" is already locked.` };
+                    }
+                    zone.run(() => {
+                        col.locked = true;
+                        grid.columnInfoService?.changeLocked([{ column: col, locked: true }]);
+                    });
+                    return { success: true, message: `Column "${field}" locked.` };
+                }
+            }));
+        }
+        if (enabled.has('unlock-column')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-unlock-column`,
+                description: `Unlock a frozen column in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'The field name of the column to unlock.' }
+                    },
+                    required: ['field']
+                },
+                execute: (args) => {
+                    const field = args['field'];
+                    const col = findColumn(grid, field);
+                    if (!col) {
+                        return { success: false, message: `Column "${field}" not found.` };
+                    }
+                    if (!col.locked) {
+                        return { success: true, message: `Column "${field}" is already unlocked.` };
+                    }
+                    zone.run(() => {
+                        col.locked = false;
+                        grid.columnInfoService?.changeLocked([{ column: col, locked: false }]);
+                    });
+                    return { success: true, message: `Column "${field}" unlocked.` };
+                }
+            }));
+        }
+        if (enabled.has('reorder-column')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-reorder-column`,
+                description: `Move a column to a new position in the ${label}. Positions are 0-based.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'The field name of the column to move.' },
+                        position: { type: 'number', description: 'The new 0-based position index.' }
+                    },
+                    required: ['field', 'position']
+                },
+                execute: (args) => {
+                    const field = args['field'];
+                    const position = args['position'];
+                    const col = findColumn(grid, field);
+                    const allCols = grid.columns?.toArray() || [];
+                    if (!col) {
+                        return { success: false, message: `Column "${field}" not found.` };
+                    }
+                    if (position < 0 || position >= allCols.length) {
+                        return { success: false, message: `Position ${position} out of range (0–${allCols.length - 1}).` };
+                    }
+                    const sorted = [...allCols].sort((a, b) => (a.orderIndex ?? 0) - (b.orderIndex ?? 0));
+                    const currentVisualPos = sorted.indexOf(col);
+                    if (currentVisualPos === position) {
+                        return { success: true, message: `Column "${field}" is already at position ${position}.` };
+                    }
+                    zone.run(() => {
+                        // before:true = "insert before target" (used when moving left)
+                        // before:false = "insert after target" (used when moving right)
+                        grid.reorderColumn(col, position, { before: position < currentVisualPos });
+                    });
+                    return { success: true, message: `Column "${field}" moved to position ${position}.` };
+                }
+            }));
+        }
+        if (enabled.has('resize-column')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-resize-column`,
+                description: `Resize a column in the ${label} to a specified width in pixels.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'The field name of the column to resize.' },
+                        width: { type: 'number', description: 'The new width in pixels.' }
+                    },
+                    required: ['field', 'width']
+                },
+                execute: (args) => {
+                    const field = args['field'];
+                    const width = args['width'];
+                    const col = findColumn(grid, field);
+                    if (!col) {
+                        return { success: false, message: `Column "${field}" not found.` };
+                    }
+                    if (col.resizable === false) {
+                        return { success: false, message: `Column "${field}" is not resizable.` };
+                    }
+                    if (width < 1) {
+                        return { success: false, message: 'Width must be a positive number.' };
+                    }
+                    const oldWidth = col.width;
+                    zone.run(() => {
+                        col.width = width;
+                        grid.columnResize.emit([{ column: col, newWidth: width, oldWidth }]);
+                    });
+                    return { success: true, message: `Column "${field}" resized to ${width}px.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Select All
+    registerSelectAllTool(grid, mc, zone, prefix, label, enabled) {
+        if (!enabled.has('select-all')) {
+            return [];
+        }
+        return [mc.registerTool({
+                name: `${prefix}-select-all`,
+                description: `Select all rows in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const data = Array.isArray(grid.data) ? grid.data : (grid.data?.data ?? []);
+                    const indices = data.map((_, i) => i);
+                    zone.run(() => {
+                        grid.selectionChange.emit({
+                            selectedRows: indices.map((i) => ({ dataItem: data[i], index: i })),
+                            deselectedRows: [],
+                            ctrlKey: false,
+                            shiftKey: false
+                        });
+                    });
+                    return { success: true, message: `Selected all ${indices.length} row(s).` };
+                }
+            })];
+    }
+    // Group Expand/Collapse
+    registerGroupExpandTools(grid, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('group-expand')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-group-expand`,
+                description: `Expand a specific group in the ${label} by group index.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        index: { type: 'string', description: 'The group index path (e.g. "0" or "0_1" for nested groups).' }
+                    },
+                    required: ['index']
+                },
+                execute: (args) => {
+                    const index = args['index'];
+                    zone.run(() => {
+                        grid.expandGroup(index);
+                        grid.groupExpand.emit({ group: { index } });
+                    });
+                    return { success: true, message: `Group "${index}" expanded.` };
+                }
+            }));
+        }
+        if (enabled.has('group-collapse')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-group-collapse`,
+                description: `Collapse a specific group in the ${label} by group index.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        index: { type: 'string', description: 'The group index path (e.g. "0" or "0_1" for nested groups).' }
+                    },
+                    required: ['index']
+                },
+                execute: (args) => {
+                    const index = args['index'];
+                    zone.run(() => {
+                        grid.collapseGroup(index);
+                        grid.groupCollapse.emit({ group: { index } });
+                    });
+                    return { success: true, message: `Group "${index}" collapsed.` };
+                }
+            }));
+        }
+        if (enabled.has('group-expand-all')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-group-expand-all`,
+                description: `Expand all groups in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        grid.resetGroupsState();
+                    });
+                    return { success: true, message: 'All groups expanded.' };
+                }
+            }));
+        }
+        if (enabled.has('group-collapse-all')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-group-collapse-all`,
+                description: `Collapse all groups in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const currentGroups = grid.group || [];
+                    if (currentGroups.length === 0) {
+                        return { success: true, message: 'No groups are configured.' };
+                    }
+                    // grid.data is GroupResult[] when grouping is active — each top-level item is a group
+                    const topLevelGroups = Array.isArray(grid.data) ? grid.data : (grid.data?.data ?? []);
+                    zone.run(() => {
+                        for (let i = 0; i < topLevelGroups.length; i++) {
+                            grid.collapseGroup(String(i));
+                        }
+                    });
+                    return { success: true, message: 'All groups collapsed.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Detail Expand/Collapse
+    registerDetailTools(grid, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('detail-expand')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-detail-expand`,
+                description: `Expand the detail row at a specific index in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        index: { type: 'number', description: '0-based row index to expand.' }
+                    },
+                    required: ['index']
+                },
+                execute: (args) => {
+                    const index = args['index'];
+                    zone.run(() => {
+                        grid.expandRow(index);
+                        grid.detailExpand.emit({ index });
+                    });
+                    return { success: true, message: `Detail row ${index} expanded.` };
+                }
+            }));
+        }
+        if (enabled.has('detail-collapse')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-detail-collapse`,
+                description: `Collapse the detail row at a specific index in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        index: { type: 'number', description: '0-based row index to collapse.' }
+                    },
+                    required: ['index']
+                },
+                execute: (args) => {
+                    const index = args['index'];
+                    zone.run(() => {
+                        grid.collapseRow(index);
+                        grid.detailCollapse.emit({ index });
+                    });
+                    return { success: true, message: `Detail row ${index} collapsed.` };
+                }
+            }));
+        }
+        if (enabled.has('detail-expand-all')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-detail-expand-all`,
+                description: `Expand all detail rows in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const data = Array.isArray(grid.data) ? grid.data : (grid.data?.data ?? []);
+                    zone.run(() => {
+                        for (let i = 0; i < data.length; i++) {
+                            grid.expandRow(i);
+                        }
+                    });
+                    return { success: true, message: `Expanded all ${data.length} detail row(s).` };
+                }
+            }));
+        }
+        if (enabled.has('detail-collapse-all')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-detail-collapse-all`,
+                description: `Collapse all detail rows in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const data = Array.isArray(grid.data) ? grid.data : (grid.data?.data ?? []);
+                    zone.run(() => {
+                        for (let i = 0; i < data.length; i++) {
+                            grid.collapseRow(i);
+                        }
+                    });
+                    return { success: true, message: `Collapsed all ${data.length} detail row(s).` };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Get Data
+    registerGetDataTool(grid, mc, zone, prefix, label, enabled) {
+        if (!enabled.has('get-data')) {
+            return [];
+        }
+        return [mc.registerTool({
+                name: `${prefix}-get-data`,
+                description: `Read the rows currently visible in the ${label} (after any active filter/sort/page) as JSON. Returns an array of objects with one entry per visible row. Each object contains the column fields and their values.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const data = Array.isArray(grid.data) ? grid.data : (grid.data?.data ?? []);
+                    const fields = getColumnFields(grid);
+                    const rows = [];
+                    const extractRows = (items) => {
+                        for (const item of items) {
+                            // Grouped data wraps items in { field, value, items } objects
+                            if (item.items) {
+                                extractRows(item.items);
+                            }
+                            else {
+                                const row = {};
+                                for (const f of fields) {
+                                    row[f] = item[f];
+                                }
+                                rows.push(row);
+                            }
+                        }
+                    };
+                    extractRows(data);
+                    return { success: true, message: `${rows.length} row(s) returned.`, data: rows };
+                }
+            })];
+    }
+    // Highlight
+    registerHighlightTools(grid, mc, zone, prefix, label, enabled) {
+        const highlightDirective = grid.ctx?.highlightDirective;
+        // Highlight tools require the kendoGridHighlight directive to be applied
+        if (!highlightDirective) {
+            return [];
+        }
+        const handles = [];
+        if (enabled.has('highlight')) {
+            const fields = getColumnFields(grid);
+            handles.push(mc.registerTool({
+                name: `${prefix}-highlight`,
+                description: `Visually highlight rows in the ${label} that match a condition using the built-in highlight mechanism.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: {
+                            type: 'string',
+                            enum: fields.length ? fields : undefined,
+                            description: 'The column field to evaluate.'
+                        },
+                        operator: {
+                            type: 'string',
+                            enum: ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'contains', 'startswith', 'endswith'],
+                            description: 'Comparison operator.'
+                        },
+                        value: {
+                            description: 'The value to compare against. Use a number for numeric fields.'
+                        }
+                    },
+                    required: ['field', 'operator', 'value']
+                },
+                execute: (args) => {
+                    const field = args['field'];
+                    const op = args['operator'];
+                    const value = args['value'];
+                    const data = Array.isArray(grid.data) ? grid.data : (grid.data?.data ?? []);
+                    const highlightItems = [];
+                    for (let i = 0; i < data.length; i++) {
+                        const item = data[i];
+                        if (matchesHighlight(item[field], op, value)) {
+                            const key = highlightDirective.highlightItemKey
+                                ? highlightDirective['getItemKey']({ data: item, index: i })
+                                : i;
+                            highlightItems.push({ itemKey: key });
+                        }
+                    }
+                    zone.run(() => {
+                        highlightDirective['setState'](highlightItems);
+                    });
+                    return { success: true, message: `${highlightItems.length} row(s) highlighted.` };
+                }
+            }));
+        }
+        if (enabled.has('clear-highlight')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-highlight`,
+                description: `Remove all row highlights from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        highlightDirective['setState']([]);
+                    });
+                    return { success: true, message: 'Highlights cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+}
+
+function getTreeListData(treeList) {
+    if (Array.isArray(treeList.data) && treeList.data.length) {
+        return treeList.data;
+    }
+    const result = treeList.data?.data;
+    if (Array.isArray(result) && result.length) {
+        return result;
+    }
+    // When kendoTreeListFlatBinding is used, data lives in the binding directive
+    const bindingData = treeList.localEditService?.bindingDirective?.originalData;
+    if (Array.isArray(bindingData) && bindingData.length) {
+        return bindingData;
+    }
+    // Fallback to rendered view items
+    try {
+        return (treeList.view?.data || []).map((item) => item.data);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * @hidden
+ *
+ * Web MCP tool adapter for the Kendo Angular TreeList component.
+ * Supports: sort, filter, select, expand/collapse, export.
+ */
+class TreeListToolAdapter {
+    selector = 'kendo-treelist';
+    registerTools(treeList, config, modelContext, ngZone) {
+        const handles = [];
+        const prefix = config.dataName || 'kendo-treelist';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' tree list'
+            : 'Kendo UI TreeList';
+        const rawOptions = this.buildToolOptions(treeList, config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        handles.push(...this.registerSortTools(treeList, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerFilterTools(treeList, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerSelectionTools(treeList, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerExportTools(treeList, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerExpandTools(treeList, modelContext, ngZone, prefix, label, enabled));
+        return handles;
+    }
+    buildToolOptions(treeList, config, label) {
+        return [
+            { name: 'sort-column', description: `Sort the ${label} by a column field and direction.`, enabled: !!treeList.sortable },
+            { name: 'clear-sort', description: `Remove all sorting from the ${label}.`, enabled: !!treeList.sortable },
+            { name: 'filter', description: `Apply a filter to a column in the ${label}.`, enabled: !!treeList.filterable },
+            { name: 'clear-filters', description: `Remove all filters from the ${label}.`, enabled: !!treeList.filterable },
+            { name: 'select-rows', description: `Select one or more rows in the ${label} by index.`, enabled: !!treeList.selectable },
+            { name: 'clear-selection', description: `Clear all row selections in the ${label}.`, enabled: !!treeList.selectable },
+            { name: 'export-pdf', description: `Export the ${label} to PDF.`, enabled: true },
+            { name: 'export-excel', description: `Export the ${label} to Excel.`, enabled: true },
+            { name: 'expand', description: `Expand a row in the ${label}.`, enabled: true },
+            { name: 'collapse', description: `Collapse a row in the ${label}.`, enabled: true },
+            { name: 'expand-all', description: `Expand all rows in the ${label}.`, enabled: true },
+            { name: 'collapse-all', description: `Collapse all rows in the ${label}.`, enabled: true }
+        ];
+    }
+    // Sort
+    registerSortTools(treeList, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('sort-column')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-sort-column`,
+                description: `Sort the ${label} by a column field and direction.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'Column field name to sort by.' },
+                        dir: { type: 'string', enum: ['asc', 'desc'], description: 'Sort direction.' }
+                    },
+                    required: ['field', 'dir']
+                },
+                execute: (args) => {
+                    const field = args['field'];
+                    const dir = args['dir'];
+                    const descriptor = [{ field, dir }];
+                    zone.run(() => {
+                        treeList.sort = descriptor;
+                        treeList.sortChange.emit(descriptor);
+                    });
+                    return { success: true, message: `Sorted by "${field}" ${dir}.` };
+                }
+            }));
+        }
+        if (enabled.has('clear-sort')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-sort`,
+                description: `Remove all sorting from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        treeList.sort = [];
+                        treeList.sortChange.emit([]);
+                    });
+                    return { success: true, message: 'Sort cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Filter
+    registerFilterTools(treeList, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('filter')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-filter`,
+                description: `Apply a filter to a column in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'Column field name to filter.' },
+                        operator: { type: 'string', description: 'Filter operator (eq, contains, startswith, etc.).' },
+                        value: { type: 'string', description: 'Filter value.' }
+                    },
+                    required: ['field', 'operator', 'value']
+                },
+                execute: (args) => {
+                    const { field, operator, value } = args;
+                    const descriptor = { logic: 'and', filters: [{ field, operator, value }] };
+                    zone.run(() => {
+                        treeList.filter = descriptor;
+                        treeList.filterChange.emit(descriptor);
+                    });
+                    return { success: true, message: `Filtered "${field}" ${operator} "${value}".` };
+                }
+            }));
+        }
+        if (enabled.has('clear-filters')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-filters`,
+                description: `Remove all filters from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const descriptor = { logic: 'and', filters: [] };
+                    zone.run(() => {
+                        treeList.filter = descriptor;
+                        treeList.filterChange.emit(descriptor);
+                    });
+                    return { success: true, message: 'Filters cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Selection
+    registerSelectionTools(treeList, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('select-rows')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select-rows`,
+                description: `Select one or more rows in the ${label} by index.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        indices: { type: 'array', items: { type: 'number' }, description: '0-based row indices to select.' }
+                    },
+                    required: ['indices']
+                },
+                execute: (args) => {
+                    const indices = args['indices'];
+                    zone.run(() => {
+                        treeList.selectionChange.emit({
+                            selectedRows: indices.map(i => ({ dataItem: null, index: i })),
+                            deselectedRows: [],
+                            ctrlKey: false,
+                            shiftKey: false
+                        });
+                    });
+                    return { success: true, message: `Selected ${indices.length} row(s).` };
+                }
+            }));
+        }
+        if (enabled.has('clear-selection')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-selection`,
+                description: `Clear all row selections in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const data = getTreeListData(treeList);
+                    zone.run(() => {
+                        treeList.selectionChange.emit({
+                            selectedRows: [],
+                            deselectedRows: data.map((item, i) => ({ dataItem: item, index: i })),
+                            ctrlKey: false,
+                            shiftKey: false
+                        });
+                    });
+                    return { success: true, message: 'Selection cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Export
+    registerExportTools(treeList, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('export-pdf') && typeof treeList.saveAsPDF === 'function') {
+            handles.push(mc.registerTool({
+                name: `${prefix}-export-pdf`,
+                description: `Export the ${label} to PDF.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => treeList.saveAsPDF());
+                    return { success: true, message: 'PDF export started.' };
+                }
+            }));
+        }
+        if (enabled.has('export-excel') && typeof treeList.saveAsExcel === 'function') {
+            handles.push(mc.registerTool({
+                name: `${prefix}-export-excel`,
+                description: `Export the ${label} to Excel.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => treeList.saveAsExcel());
+                    return { success: true, message: 'Excel export started.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Expand / Collapse
+    registerExpandTools(treeList, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('expand')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-expand`,
+                description: `Expand a row in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'number', description: 'Row id to expand.' }
+                    },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    const data = getTreeListData(treeList);
+                    const item = data.find((d) => d.id === args['id']);
+                    if (!item) {
+                        return { success: false, message: `Row with id ${args['id']} not found.` };
+                    }
+                    zone.run(() => {
+                        treeList.expand(item);
+                    });
+                    return { success: true, message: `Row ${args['id']} expanded.` };
+                }
+            }));
+        }
+        if (enabled.has('collapse')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-collapse`,
+                description: `Collapse a row in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'number', description: 'Row id to collapse.' }
+                    },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    const data = getTreeListData(treeList);
+                    const item = data.find((d) => d.id === args['id']);
+                    if (!item) {
+                        return { success: false, message: `Row with id ${args['id']} not found.` };
+                    }
+                    zone.run(() => {
+                        treeList.collapse(item);
+                    });
+                    return { success: true, message: `Row ${args['id']} collapsed.` };
+                }
+            }));
+        }
+        if (enabled.has('expand-all')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-expand-all`,
+                description: `Expand all rows in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const data = getTreeListData(treeList);
+                    zone.run(() => {
+                        for (const item of data) {
+                            treeList.expand(item);
+                        }
+                    });
+                    return { success: true, message: `Expanded all ${data.length} row(s).` };
+                }
+            }));
+        }
+        if (enabled.has('collapse-all')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-collapse-all`,
+                description: `Collapse all rows in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const data = getTreeListData(treeList);
+                    zone.run(() => {
+                        for (const item of data) {
+                            treeList.collapse(item);
+                        }
+                    });
+                    return { success: true, message: `Collapsed all ${data.length} row(s).` };
+                }
+            }));
+        }
+        return handles;
+    }
+}
+
+/**
+ * @hidden
+ *
+ * Web MCP tool adapter for the Kendo Angular Scheduler component.
+ * Supports: create, update, delete events, set view, navigate.
+ */
+class SchedulerToolAdapter {
+    selector = 'kendo-scheduler';
+    registerTools(scheduler, config, modelContext, ngZone) {
+        const handles = [];
+        const prefix = config.dataName || 'kendo-scheduler';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' scheduler'
+            : 'Kendo UI Scheduler';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        handles.push(...this.registerEventTools(scheduler, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerNavigationTools(scheduler, modelContext, ngZone, prefix, label, enabled));
+        handles.push(...this.registerExportTools(scheduler, modelContext, ngZone, prefix, label, enabled));
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'create-event', description: `Create a new event in the ${label}.`, enabled: true },
+            { name: 'update-event', description: `Update an existing event in the ${label}.`, enabled: true },
+            { name: 'delete-event', description: `Delete an event from the ${label}.`, enabled: true },
+            { name: 'set-view', description: `Change the view of the ${label}.`, enabled: true },
+            { name: 'navigate', description: `Navigate to a specific date in the ${label}.`, enabled: true },
+            { name: 'export-pdf', description: `Export the ${label} to PDF.`, enabled: true }
+        ];
+    }
+    // Event CRUD
+    registerEventTools(scheduler, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('create-event')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-create-event`,
+                description: `Create a new event in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string', description: 'Event title.' },
+                        start: { type: 'string', description: 'Start date/time (ISO 8601).' },
+                        end: { type: 'string', description: 'End date/time (ISO 8601).' },
+                        description: { type: 'string', description: 'Event description (optional).' }
+                    },
+                    required: ['title', 'start', 'end']
+                },
+                execute: (args) => {
+                    const event = {
+                        title: args['title'],
+                        start: new Date(args['start']),
+                        end: new Date(args['end']),
+                        description: args['description'] || ''
+                    };
+                    zone.run(() => {
+                        scheduler.save?.emit({ dataItem: event, isNew: true });
+                    });
+                    const descPart = event.description ? ', Description: "' + event.description + '"' : '';
+                    return { success: true, message: 'Event created. Title: "' + event.title + '", Start: ' + args['start'] + ', End: ' + args['end'] + descPart + '.' };
+                }
+            }));
+        }
+        if (enabled.has('update-event')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-update-event`,
+                description: `Update an existing event in the ${label} by title.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string', description: 'Title of the event to update.' },
+                        start: { type: 'string', description: 'New start date/time (ISO 8601).' },
+                        end: { type: 'string', description: 'New end date/time (ISO 8601).' },
+                        newTitle: { type: 'string', description: 'New title for the event.' }
+                    },
+                    required: ['title']
+                },
+                execute: (args) => {
+                    const updates = { _originalTitle: args['title'] };
+                    if (args['start'])
+                        updates['start'] = new Date(args['start']);
+                    if (args['end'])
+                        updates['end'] = new Date(args['end']);
+                    if (args['newTitle'])
+                        updates['title'] = args['newTitle'];
+                    zone.run(() => {
+                        scheduler.save?.emit({
+                            dataItem: { title: args['title'], ...updates },
+                            isNew: false
+                        });
+                    });
+                    return { success: true, message: `Event "${args['title']}" updated.` };
+                }
+            }));
+        }
+        if (enabled.has('delete-event')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-delete-event`,
+                description: `Delete an event from the ${label} by title.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string', description: 'Title of the event to delete.' }
+                    },
+                    required: ['title']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        scheduler.remove?.emit({
+                            dataItem: { title: args['title'] }
+                        });
+                    });
+                    return { success: true, message: `Event "${args['title']}" deleted.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Navigation
+    registerNavigationTools(scheduler, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('set-view')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-view`,
+                description: `Change the view of the ${label} (e.g. day, week, month).`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        view: { type: 'string', description: 'View name: day, week, month, timeline, agenda.' }
+                    },
+                    required: ['view']
+                },
+                execute: (args) => {
+                    const view = (args['view'] || '').toLowerCase();
+                    const viewToIndex = { day: 0, week: 1, month: 2, timeline: 3, agenda: 4 };
+                    const index = viewToIndex[view] ?? 1;
+                    zone.run(() => {
+                        scheduler.selectedViewIndex = index;
+                        scheduler.navigate?.emit({ index, view: args['view'] });
+                    });
+                    return { success: true, message: `View set to "${args['view']}".` };
+                }
+            }));
+        }
+        if (enabled.has('navigate')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-navigate`,
+                description: `Navigate to a specific date in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        date: { type: 'string', description: 'Target date (ISO 8601).' }
+                    },
+                    required: ['date']
+                },
+                execute: (args) => {
+                    const date = new Date(args['date']);
+                    zone.run(() => {
+                        scheduler.selectedDate = date;
+                        scheduler.dateChange?.emit({
+                            selectedDate: date,
+                            dateRange: { start: date, end: date }
+                        });
+                    });
+                    return { success: true, message: `Navigated to ${date.toISOString().split('T')[0]}.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    // Export
+    registerExportTools(scheduler, mc, zone, prefix, label, enabled) {
+        const handles = [];
+        if (enabled.has('export-pdf') && typeof scheduler.saveAsPDF === 'function') {
+            handles.push(mc.registerTool({
+                name: `${prefix}-export-pdf`,
+                description: `Export the ${label} to PDF.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => scheduler.saveAsPDF());
+                    return { success: true, message: 'PDF export started.' };
+                }
+            }));
+        }
+        return handles;
+    }
+}
+
+/**
+ * @hidden
+ *
+ * Web MCP tool adapter for the Kendo Angular Chart component.
+ * Supports: drilldown, export.
+ */
+class ChartToolAdapter {
+    selector = 'kendo-chart';
+    registerTools(chart, config, modelContext, ngZone) {
+        const handles = [];
+        const prefix = config.dataName || 'kendo-chart';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' chart'
+            : 'Kendo UI Chart';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        if (enabled.has('drilldown')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-drilldown`,
+                description: `Drill down into a specific category/series in the ${label}. Triggers the full chart drilldown pipeline.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string', description: 'The drilldown field value (category) to drill into.' },
+                        series: { type: 'string', description: 'Series name to drill into. If omitted, uses the first drilldown-enabled series.' }
+                    },
+                    required: ['value']
+                },
+                execute: (args) => {
+                    let seriesName = args['series'];
+                    if (!seriesName) {
+                        const drilldownSeries = chart.seriesComponents?.find((sc) => sc.drilldownTemplate);
+                        seriesName = drilldownSeries?.name;
+                    }
+                    if (!seriesName) {
+                        return { success: false, message: 'No drilldown-enabled series found.' };
+                    }
+                    ngZone.run(() => {
+                        chart.trigger?.('drilldown', {
+                            value: args['value'],
+                            series: { name: seriesName },
+                            point: {}
+                        });
+                    });
+                    return { success: true, message: `Drilled down into "${args['value']}".` };
+                }
+            }));
+        }
+        if (enabled.has('export')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-export`,
+                description: `Export the ${label} to an image format.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        format: { type: 'string', enum: ['png', 'svg'], description: 'Export format.' }
+                    },
+                    required: ['format']
+                },
+                execute: (args) => {
+                    const format = args['format'];
+                    const fileName = `${prefix}.${format === 'svg' ? 'svg' : 'png'}`;
+                    ngZone.run(() => {
+                        const exportPromise = format === 'svg'
+                            ? chart.exportSVG()
+                            : chart.exportImage();
+                        exportPromise.then((dataURI) => {
+                            saveAs(dataURI, fileName);
+                        });
+                    });
+                    return { success: true, message: `${format.toUpperCase()} export started.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            {
+                name: 'drilldown',
+                description: `Drill down into a specific category/series in the ${label}. Triggers the full chart drilldown pipeline.`,
+                enabled: true
+            },
+            { name: 'export', description: `Export the ${label} to an image format.`, enabled: true }
+        ];
+    }
+}
+
+/**
+ * @hidden
+ *
+ * Web MCP tool adapter for the Kendo Angular Editor component.
+ * Supports: get content, set content, export PDF.
+ */
+class EditorToolAdapter {
+    selector = 'kendo-editor';
+    registerTools(editor, config, modelContext, ngZone) {
+        const handles = [];
+        const prefix = config.dataName || 'kendo-editor';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' editor'
+            : 'Kendo UI Editor';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        if (enabled.has('get-content')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-get-content`,
+                description: `Get the current HTML content of the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const value = editor.value;
+                    return { success: true, message: 'Content retrieved.', data: value };
+                }
+            }));
+        }
+        if (enabled.has('set-content')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-set-content`,
+                description: `Set the HTML content of the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        html: { type: 'string', description: 'HTML content to set.' }
+                    },
+                    required: ['html']
+                },
+                execute: (args) => {
+                    const html = args['html'];
+                    ngZone.run(() => {
+                        editor.value = html;
+                        editor.valueChange.emit(html);
+                    });
+                    return { success: true, message: 'Content updated.' };
+                }
+            }));
+        }
+        if (enabled.has('insert-html')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-insert-html`,
+                description: `Insert HTML at the end of the ${label} content.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        html: { type: 'string', description: 'HTML markup to insert.' }
+                    },
+                    required: ['html']
+                },
+                execute: (args) => {
+                    const html = args['html'];
+                    ngZone.run(() => {
+                        const current = editor.value || '';
+                        const updated = current + html;
+                        editor.value = updated;
+                        editor.valueChange.emit(updated);
+                    });
+                    const preview = html.length > 100 ? html.substring(0, 100) + '...' : html;
+                    return { success: true, message: `HTML inserted (${html.length} chars). Content: "${preview}".` };
+                }
+            }));
+        }
+        if (enabled.has('clear-content')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-clear-content`,
+                description: `Clear all content from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    ngZone.run(() => {
+                        editor.value = '';
+                        editor.valueChange.emit('');
+                    });
+                    return { success: true, message: 'Content cleared.' };
+                }
+            }));
+        }
+        if (enabled.has('export-pdf') && typeof editor.saveAsPDF === 'function') {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-export-pdf`,
+                description: `Export the ${label} content to PDF.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    ngZone.run(() => editor.saveAsPDF());
+                    return { success: true, message: 'PDF export started.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'get-content', description: `Get the current HTML content of the ${label}.`, enabled: true },
+            { name: 'set-content', description: `Set the HTML content of the ${label}.`, enabled: true },
+            { name: 'insert-html', description: `Insert HTML at the end of the ${label} content.`, enabled: true },
+            { name: 'clear-content', description: `Clear all content from the ${label}.`, enabled: true },
+            { name: 'export-pdf', description: `Export the ${label} content to PDF.`, enabled: true }
+        ];
+    }
+}
+
+/**
+ * @hidden
+ *
+ * Web MCP tool adapter for the Kendo Angular Spreadsheet component.
+ * Supports: set cell, navigate sheet, add sheet, rename sheet, export.
+ */
+class SpreadsheetToolAdapter {
+    selector = 'kendo-spreadsheet';
+    registerTools(spreadsheet, config, modelContext, ngZone) {
+        const handles = [];
+        const prefix = config.dataName || 'kendo-spreadsheet';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' spreadsheet'
+            : 'Kendo UI Spreadsheet';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        if (enabled.has('set-cell')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-set-cell`,
+                description: `Set a cell value in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        cell: { type: 'string', description: 'Cell reference (e.g. "A1", "B3").' },
+                        value: { type: 'string', description: 'Value to set in the cell.' }
+                    },
+                    required: ['cell', 'value']
+                },
+                execute: (args) => {
+                    const cell = args['cell'];
+                    const value = args['value'];
+                    ngZone.run(() => {
+                        const instance = spreadsheet.spreadsheetWidget;
+                        if (instance) {
+                            const sheet = instance.activeSheet();
+                            sheet.range(cell).value(value);
+                        }
+                    });
+                    return { success: true, message: `Cell ${cell} set to "${value}".` };
+                }
+            }));
+        }
+        if (enabled.has('navigate-sheet')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-navigate-sheet`,
+                description: `Switch to a specific sheet in the ${label} by name or index.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        sheet: { type: 'string', description: 'Sheet name or 0-based index.' }
+                    },
+                    required: ['sheet']
+                },
+                execute: (args) => {
+                    const sheet = args['sheet'];
+                    let navigated = false;
+                    ngZone.run(() => {
+                        const instance = spreadsheet.spreadsheetWidget;
+                        if (instance) {
+                            const idx = Number.parseInt(sheet, 10);
+                            let targetName;
+                            if (Number.isNaN(idx)) {
+                                targetName = sheet;
+                            }
+                            else {
+                                const sheets = instance.sheets();
+                                if (sheets[idx]) {
+                                    targetName = sheets[idx].name();
+                                }
+                            }
+                            if (targetName) {
+                                const targetSheet = instance.sheets().find((s) => s.name() === targetName);
+                                if (targetSheet) {
+                                    instance.activeSheet(targetSheet);
+                                    instance.view?.sheetsbar?.onSheetSelect(targetName);
+                                    navigated = true;
+                                }
+                            }
+                        }
+                    });
+                    return navigated
+                        ? { success: true, message: `Navigated to sheet "${sheet}".` }
+                        : { success: false, message: `Sheet "${sheet}" not found.` };
+                }
+            }));
+        }
+        if (enabled.has('add-sheet')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-add-sheet`,
+                description: `Add a new sheet to the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string', description: 'Optional name for the new sheet.' }
+                    },
+                    required: []
+                },
+                execute: (args) => {
+                    let sheetName = '';
+                    let sheetIndex = -1;
+                    ngZone.run(() => {
+                        const instance = spreadsheet.spreadsheetWidget;
+                        if (instance) {
+                            const sheetsbar = instance.view?.sheetsbar;
+                            if (args['name']) {
+                                instance.insertSheet({ data: { name: args['name'] } });
+                            }
+                            else if (sheetsbar) {
+                                sheetsbar.onAddSelect();
+                            }
+                            else {
+                                instance.insertSheet();
+                            }
+                            const sheets = instance.sheets();
+                            sheetIndex = sheets.length - 1;
+                            sheetName = sheets[sheetIndex]?.name() || 'Sheet' + (sheetIndex + 1);
+                        }
+                    });
+                    return { success: true, message: `Sheet added. Name: "${sheetName}", Index: ${sheetIndex}.` };
+                }
+            }));
+        }
+        if (enabled.has('rename-sheet')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-rename-sheet`,
+                description: `Rename the active sheet in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string', description: 'New name for the active sheet.' }
+                    },
+                    required: ['name']
+                },
+                execute: (args) => {
+                    const name = args['name'];
+                    let oldName = '';
+                    ngZone.run(() => {
+                        const instance = spreadsheet.spreadsheetWidget;
+                        if (instance) {
+                            const activeSheet = instance.activeSheet();
+                            oldName = activeSheet.name();
+                            const allSheets = instance.sheets();
+                            const sheetIndex = allSheets.findIndex((s) => s.name() === oldName);
+                            const sheetsbar = instance.view?.sheetsbar;
+                            if (sheetsbar && sheetIndex >= 0) {
+                                sheetsbar.onSheetRename(name, sheetIndex);
+                            }
+                            else {
+                                activeSheet.name(name);
+                            }
+                        }
+                    });
+                    return { success: true, message: `Sheet renamed from "${oldName}" to "${name}".` };
+                }
+            }));
+        }
+        if (enabled.has('export')) {
+            handles.push(modelContext.registerTool({
+                name: `${prefix}-export`,
+                description: `Export the ${label} to a file.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    ngZone.run(() => {
+                        const instance = spreadsheet.spreadsheetWidget;
+                        if (instance) {
+                            instance.saveAsExcel({
+                                ...instance.options.excel,
+                                saveAs,
+                                Workbook
+                            });
+                        }
+                    });
+                    return { success: true, message: 'Export started.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'set-cell', description: `Set a cell value in the ${label}.`, enabled: true },
+            { name: 'navigate-sheet', description: `Switch to a specific sheet in the ${label} by name or index.`, enabled: true },
+            { name: 'add-sheet', description: `Add a new sheet to the ${label}.`, enabled: true },
+            { name: 'rename-sheet', description: `Rename the active sheet in the ${label}.`, enabled: true },
+            { name: 'export', description: `Export the ${label} to a file.`, enabled: true }
+        ];
+    }
+}
+
+function getGanttData(gantt) {
+    if (Array.isArray(gantt.data) && gantt.data.length) {
+        return gantt.data;
+    }
+    // When kendoGanttFlatBinding is used, data lives in the binding directive's originalData
+    const treeList = gantt.treeList;
+    const bindingData = treeList?.localEditService?.bindingDirective?.originalData;
+    if (Array.isArray(bindingData) && bindingData.length) {
+        return bindingData;
+    }
+    // Fallback to rendered items (visible rows only)
+    return gantt.renderedTreeListItems || [];
+}
+/**
+ * @hidden
+ *
+ * Web MCP tool adapter for the Kendo Angular Gantt component.
+ * Supports: task CRUD, sort, filter, expand/collapse, export, view.
+ */
+class GanttToolAdapter {
+    selector = 'kendo-gantt';
+    registerTools(gantt, config, modelContext, ngZone) {
+        const handles = [];
+        const prefix = config.dataName || 'kendo-gantt';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' gantt'
+            : 'Kendo UI Gantt';
+        const mc = modelContext;
+        const zone = ngZone;
+        const rawOptions = this.buildToolOptions(gantt, config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        // Task CRUD
+        if (enabled.has('add-task')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-add-task`,
+                description: `Add a new task to the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string', description: 'Task title.' },
+                        start: { type: 'string', description: 'Start date (ISO 8601).' },
+                        end: { type: 'string', description: 'End date (ISO 8601).' }
+                    },
+                    required: ['title', 'start', 'end']
+                },
+                execute: (args) => {
+                    const data = gantt.data;
+                    if (!Array.isArray(data)) {
+                        return { success: false, message: 'Cannot add task: data is not an array.' };
+                    }
+                    const maxId = data.reduce((m, t) => Math.max(m, t.id || 0), 0);
+                    const newTask = {
+                        id: maxId + 1,
+                        parentId: null,
+                        title: args['title'],
+                        start: new Date(args['start']),
+                        end: new Date(args['end']),
+                        percentComplete: 0
+                    };
+                    zone.run(() => {
+                        gantt.data = [...data, newTask];
+                    });
+                    return { success: true, message: `Task added. ID: ${newTask.id}, Title: "${newTask.title}", Start: ${args['start']}, End: ${args['end']}, Complete: ${newTask.percentComplete}%.` };
+                }
+            }));
+        }
+        if (enabled.has('update-task')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-update-task`,
+                description: `Update an existing task in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string', description: 'Title of the task to update.' },
+                        start: { type: 'string', description: 'New start date.' },
+                        end: { type: 'string', description: 'New end date.' },
+                        percentComplete: { type: 'number', description: 'Completion percentage (0-1).' }
+                    },
+                    required: ['title']
+                },
+                execute: (args) => {
+                    const data = gantt.data;
+                    if (!Array.isArray(data)) {
+                        return { success: false, message: 'Cannot update task: data is not an array.' };
+                    }
+                    const task = data.find((t) => t.title === args['title']);
+                    if (!task) {
+                        return { success: false, message: `Task "${args['title']}" not found.` };
+                    }
+                    zone.run(() => {
+                        if (args['start'])
+                            task.start = new Date(args['start']);
+                        if (args['end'])
+                            task.end = new Date(args['end']);
+                        if (args['percentComplete'] !== undefined)
+                            task.percentComplete = args['percentComplete'];
+                        gantt.data = [...data];
+                    });
+                    return { success: true, message: `Task "${args['title']}" updated.` };
+                }
+            }));
+        }
+        if (enabled.has('delete-task')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-delete-task`,
+                description: `Delete a task from the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string', description: 'Title of the task to delete.' }
+                    },
+                    required: ['title']
+                },
+                execute: (args) => {
+                    const data = gantt.data;
+                    if (!Array.isArray(data)) {
+                        return { success: false, message: 'Cannot delete task: data is not an array.' };
+                    }
+                    const idx = data.findIndex((t) => t.title === args['title']);
+                    if (idx < 0) {
+                        return { success: false, message: `Task "${args['title']}" not found.` };
+                    }
+                    zone.run(() => {
+                        data.splice(idx, 1);
+                        gantt.data = [...data];
+                    });
+                    return { success: true, message: `Task "${args['title']}" deleted.` };
+                }
+            }));
+        }
+        // View
+        if (enabled.has('set-view')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-view`,
+                description: `Change the timeline view of the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        view: { type: 'string', description: 'View name: day, week, month, year.' }
+                    },
+                    required: ['view']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        gantt.activeView = args['view'];
+                        gantt.activeViewChange.emit(args['view']);
+                    });
+                    return { success: true, message: `View set to "${args['view']}".` };
+                }
+            }));
+        }
+        // Sort
+        if (enabled.has('sort')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-sort`,
+                description: `Sort the ${label} by a field.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'Field to sort by.' },
+                        dir: { type: 'string', enum: ['asc', 'desc'], description: 'Sort direction.' }
+                    },
+                    required: ['field', 'dir']
+                },
+                execute: (args) => {
+                    const sortDesc = [{ field: args['field'], dir: args['dir'] }];
+                    zone.run(() => {
+                        gantt.sort = sortDesc;
+                        gantt.sortChange.emit(sortDesc);
+                    });
+                    return { success: true, message: `Sorted by "${args['field']}" ${args['dir']}.` };
+                }
+            }));
+        }
+        if (enabled.has('clear-sort')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-sort`,
+                description: `Clear sorting from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        gantt.sort = [];
+                        gantt.sortChange.emit([]);
+                    });
+                    return { success: true, message: 'Sort cleared.' };
+                }
+            }));
+        }
+        // Filter
+        if (enabled.has('filter')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-filter`,
+                description: `Apply a filter to the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'Field to filter.' },
+                        operator: { type: 'string', description: 'Filter operator.' },
+                        value: { type: 'string', description: 'Filter value.' }
+                    },
+                    required: ['field', 'operator', 'value']
+                },
+                execute: (args) => {
+                    const filterDesc = {
+                        logic: 'and',
+                        filters: [{ field: args['field'], operator: args['operator'], value: args['value'] }]
+                    };
+                    zone.run(() => {
+                        gantt.filter = filterDesc;
+                        gantt.filterChange.emit(filterDesc);
+                    });
+                    return { success: true, message: `Filtered "${args['field']}" ${args['operator']} "${args['value']}".` };
+                }
+            }));
+        }
+        if (enabled.has('clear-filters')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-filters`,
+                description: `Clear all filters from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    const emptyFilter = { logic: 'and', filters: [] };
+                    zone.run(() => {
+                        gantt.filter = emptyFilter;
+                        gantt.filterChange.emit(emptyFilter);
+                    });
+                    return { success: true, message: 'Filters cleared.' };
+                }
+            }));
+        }
+        // Expand / Collapse
+        if (enabled.has('expand')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-expand`,
+                description: `Expand a task row in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { id: { type: 'number', description: 'Task id to expand.' } },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    const task = getGanttData(gantt).find((t) => t.id === args['id']);
+                    if (!task) {
+                        return { success: false, message: `Task with id ${args['id']} not found.` };
+                    }
+                    zone.run(() => {
+                        gantt.rowExpand.emit({ dataItem: task });
+                        gantt.expandStateChange?.emit({ dataItem: task, expand: true });
+                        gantt.updateView();
+                    });
+                    return { success: true, message: `Task ${args['id']} expanded.` };
+                }
+            }));
+        }
+        if (enabled.has('collapse')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-collapse`,
+                description: `Collapse a task row in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { id: { type: 'number', description: 'Task id to collapse.' } },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    const task = getGanttData(gantt).find((t) => t.id === args['id']);
+                    if (!task) {
+                        return { success: false, message: `Task with id ${args['id']} not found.` };
+                    }
+                    zone.run(() => {
+                        gantt.rowCollapse.emit({ dataItem: task });
+                        gantt.expandStateChange?.emit({ dataItem: task, expand: false });
+                        gantt.updateView();
+                    });
+                    return { success: true, message: `Task ${args['id']} collapsed.` };
+                }
+            }));
+        }
+        // Select
+        if (enabled.has('select')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select`,
+                description: `Select a task in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { id: { type: 'number', description: 'Task id to select.' } },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    const task = getGanttData(gantt).find((t) => t.id === args['id']);
+                    if (!task) {
+                        return { success: false, message: `Task with id ${args['id']} not found.` };
+                    }
+                    zone.run(() => {
+                        gantt.notifySelectionChange?.(task, 'select');
+                    });
+                    return { success: true, message: `Task ${args['id']} selected.` };
+                }
+            }));
+        }
+        // Export
+        if (enabled.has('export-pdf') && typeof gantt.saveAsPDF === 'function') {
+            handles.push(mc.registerTool({
+                name: `${prefix}-export-pdf`,
+                description: `Export the ${label} to PDF.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => gantt.saveAsPDF());
+                    return { success: true, message: 'PDF export started.' };
+                }
+            }));
+        }
+        if (enabled.has('export-excel') && typeof gantt.saveAsExcel === 'function') {
+            handles.push(mc.registerTool({
+                name: `${prefix}-export-excel`,
+                description: `Export the ${label} to Excel.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => gantt.saveAsExcel());
+                    return { success: true, message: 'Excel export started.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(gantt, config, label) {
+        return [
+            { name: 'add-task', description: `Add a new task to the ${label}.`, enabled: true },
+            { name: 'update-task', description: `Update an existing task in the ${label}.`, enabled: true },
+            { name: 'delete-task', description: `Delete a task from the ${label}.`, enabled: true },
+            { name: 'set-view', description: `Change the timeline view of the ${label}.`, enabled: true },
+            { name: 'sort', description: `Sort the ${label} by a field.`, enabled: !!gantt.sortable },
+            { name: 'clear-sort', description: `Clear sorting from the ${label}.`, enabled: !!gantt.sortable },
+            { name: 'filter', description: `Apply a filter to the ${label}.`, enabled: !!gantt.filterable },
+            { name: 'clear-filters', description: `Clear all filters from the ${label}.`, enabled: !!gantt.filterable },
+            { name: 'expand', description: `Expand a task row in the ${label}.`, enabled: true },
+            { name: 'collapse', description: `Collapse a task row in the ${label}.`, enabled: true },
+            { name: 'select', description: `Select a task in the ${label}.`, enabled: true },
+            { name: 'export-pdf', description: `Export the ${label} to PDF.`, enabled: true },
+            { name: 'export-excel', description: `Export the ${label} to Excel.`, enabled: true }
+        ];
+    }
+}
+
+/**
+ * @hidden
+ *
+ * Web MCP tool adapter for the Kendo Angular PivotGrid component.
+ * Supports: set rows, set columns, set measures, expand, collapse, export.
+ */
+class PivotGridToolAdapter {
+    selector = 'kendo-pivotgrid';
+    registerTools(pivot, config, modelContext, ngZone) {
+        const handles = [];
+        const prefix = config.dataName || 'kendo-pivotgrid';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' pivot grid'
+            : 'Kendo UI PivotGrid';
+        const mc = modelContext;
+        const zone = ngZone;
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        if (enabled.has('set-rows')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-rows`,
+                description: `Set the row fields of the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        fields: { type: 'array', items: { type: 'string' }, description: 'Row field names.' }
+                    },
+                    required: ['fields']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        const ds = pivot.dataService;
+                        const newAxes = args['fields'].map(f => ({ name: [f], expand: false }));
+                        const newState = { ...ds.state, rowAxes: newAxes };
+                        ds.configuratorFieldChange.emit(newState);
+                    });
+                    return { success: true, message: `Rows set to: ${args['fields'].join(', ')}.` };
+                }
+            }));
+        }
+        if (enabled.has('set-columns')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-columns`,
+                description: `Set the column fields of the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        fields: { type: 'array', items: { type: 'string' }, description: 'Column field names.' }
+                    },
+                    required: ['fields']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        const ds = pivot.dataService;
+                        const newAxes = args['fields'].map(f => ({ name: [f], expand: false }));
+                        const newState = { ...ds.state, columnAxes: newAxes };
+                        ds.configuratorFieldChange.emit(newState);
+                    });
+                    return { success: true, message: `Columns set to: ${args['fields'].join(', ')}.` };
+                }
+            }));
+        }
+        if (enabled.has('set-measures')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-measures`,
+                description: `Set the measure fields of the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        fields: { type: 'array', items: { type: 'string' }, description: 'Measure field names.' }
+                    },
+                    required: ['fields']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        const ds = pivot.dataService;
+                        const newAxes = args['fields'].map(f => ({ name: [f] }));
+                        const newState = { ...ds.state, measureAxes: newAxes };
+                        ds.configuratorFieldChange.emit(newState);
+                    });
+                    return { success: true, message: `Measures set to: ${args['fields'].join(', ')}.` };
+                }
+            }));
+        }
+        if (enabled.has('expand')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-expand`,
+                description: `Expand a row or column header in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        axis: { type: 'string', enum: ['rows', 'columns'], description: 'Axis to expand on.' },
+                        path: { type: 'array', items: { type: 'string' }, description: 'Header path to expand.' }
+                    },
+                    required: ['axis', 'path']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        const ds = pivot.dataService;
+                        const tableType = args['axis'] === 'columns' ? 'columnHeader' : 'rowHeader';
+                        ds.expandedStateChange.emit({ tableType, cell: { path: args['path'] } });
+                    });
+                    return { success: true, message: `Expanded ${args['axis']} at path [${args['path'].join(', ')}].` };
+                }
+            }));
+        }
+        if (enabled.has('collapse')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-collapse`,
+                description: `Collapse a row or column header in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        axis: { type: 'string', enum: ['rows', 'columns'], description: 'Axis to collapse on.' },
+                        path: { type: 'array', items: { type: 'string' }, description: 'Header path to collapse.' }
+                    },
+                    required: ['axis', 'path']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        const ds = pivot.dataService;
+                        const tableType = args['axis'] === 'columns' ? 'columnHeader' : 'rowHeader';
+                        ds.expandedStateChange.emit({ tableType, cell: { path: args['path'] } });
+                    });
+                    return { success: true, message: `Collapsed ${args['axis']} at path [${args['path'].join(', ')}].` };
+                }
+            }));
+        }
+        if (enabled.has('export-pdf')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-export-pdf`,
+                description: `Export the ${label} to PDF.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => pivot.saveAsPDF?.());
+                    return { success: true, message: 'PDF export started.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'set-rows', description: `Set the row fields of the ${label}.`, enabled: true },
+            { name: 'set-columns', description: `Set the column fields of the ${label}.`, enabled: true },
+            { name: 'set-measures', description: `Set the measure fields of the ${label}.`, enabled: true },
+            { name: 'expand', description: `Expand a row or column header in the ${label}.`, enabled: true },
+            { name: 'collapse', description: `Collapse a row or column header in the ${label}.`, enabled: true },
+            { name: 'export-pdf', description: `Export the ${label} to PDF.`, enabled: true }
+        ];
+    }
+}
+
+// DropDownList
+/**
+ * @hidden
+ */
+class DropDownListToolAdapter {
+    selector = 'kendo-dropdownlist';
+    registerTools(ddl, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-dropdownlist';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' dropdown'
+            : 'Kendo UI DropDownList';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('select')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select`,
+                description: `Select an item in the ${label} by value or text.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string', description: 'Value or text of the item to select.' }
+                    },
+                    required: ['value']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        ddl.value = args['value'];
+                        ddl.valueChange.emit(args['value']);
+                        ddl.selectionChange.emit(args['value']);
+                    });
+                    return { success: true, message: `Selected "${args['value']}".` };
+                }
+            }));
+        }
+        if (enabled.has('open')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-open`,
+                description: `Open the ${label} popup.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => ddl.toggle(true));
+                    return { success: true, message: 'Dropdown opened.' };
+                }
+            }));
+        }
+        if (enabled.has('close')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-close`,
+                description: `Close the ${label} popup.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => ddl.toggle(false));
+                    return { success: true, message: 'Dropdown closed.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'select', description: `Select an item in the ${label} by value or text.`, enabled: true },
+            { name: 'open', description: `Open the ${label} popup.`, enabled: true },
+            { name: 'close', description: `Close the ${label} popup.`, enabled: true }
+        ];
+    }
+}
+// ComboBox
+/**
+ * @hidden
+ */
+class ComboBoxToolAdapter {
+    selector = 'kendo-combobox';
+    registerTools(combo, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-combobox';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' combobox'
+            : 'Kendo UI ComboBox';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('select')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select`,
+                description: `Select an item in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string', description: 'Value or text of the item to select.' }
+                    },
+                    required: ['value']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        combo.value = args['value'];
+                        combo.valueChange.emit(args['value']);
+                        combo.selectionChange.emit(args['value']);
+                    });
+                    return { success: true, message: `Selected "${args['value']}".` };
+                }
+            }));
+        }
+        if (enabled.has('search')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-search`,
+                description: `Search/filter items in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        text: { type: 'string', description: 'Search text.' }
+                    },
+                    required: ['text']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        combo.toggle(true);
+                        combo.filterChange.emit(args['text']);
+                    });
+                    return { success: true, message: `Searched for "${args['text']}".` };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear the ${label} value.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        combo.value = null;
+                        combo.valueChange.emit(null);
+                    });
+                    return { success: true, message: 'Value cleared.' };
+                }
+            }));
+        }
+        if (enabled.has('open')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-open`,
+                description: `Open the ${label} popup.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => combo.toggle(true));
+                    return { success: true, message: 'Popup opened.' };
+                }
+            }));
+        }
+        if (enabled.has('close')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-close`,
+                description: `Close the ${label} popup.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => combo.toggle(false));
+                    return { success: true, message: 'Popup closed.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'select', description: `Select an item in the ${label}.`, enabled: true },
+            { name: 'search', description: `Search/filter items in the ${label}.`, enabled: true },
+            { name: 'clear', description: `Clear the ${label} value.`, enabled: true },
+            { name: 'open', description: `Open the ${label} popup.`, enabled: true },
+            { name: 'close', description: `Close the ${label} popup.`, enabled: true }
+        ];
+    }
+}
+/**
+ * @hidden
+ */
+class AutoCompleteToolAdapter {
+    selector = 'kendo-autocomplete';
+    registerTools(ac, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-autocomplete';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' autocomplete'
+            : 'Kendo UI AutoComplete';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('search')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-search`,
+                description: `Search for items in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        text: { type: 'string', description: 'Search text.' }
+                    },
+                    required: ['text']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        ac.value = args['text'];
+                        ac.toggle(true);
+                        ac.filterChange.emit(args['text']);
+                    });
+                    return { success: true, message: `Searched for "${args['text']}".` };
+                }
+            }));
+        }
+        if (enabled.has('select')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select`,
+                description: `Select a value in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string', description: 'Value to select.' }
+                    },
+                    required: ['value']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        ac.value = args['value'];
+                        ac.valueChange.emit(args['value']);
+                    });
+                    return { success: true, message: `Selected "${args['value']}".` };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear the ${label} value.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        ac.value = '';
+                        ac.valueChange.emit('');
+                    });
+                    return { success: true, message: 'Value cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'search', description: `Search for items in the ${label}.`, enabled: true },
+            { name: 'select', description: `Select a value in the ${label}.`, enabled: true },
+            { name: 'clear', description: `Clear the ${label} value.`, enabled: true }
+        ];
+    }
+}
+// MultiSelect
+/**
+ * @hidden
+ */
+class MultiSelectToolAdapter {
+    selector = 'kendo-multiselect';
+    registerTools(ms, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-multiselect';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' multiselect'
+            : 'Kendo UI MultiSelect';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('select')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select`,
+                description: `Add items to the ${label} selection.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        values: { type: 'array', items: { type: 'string' }, description: 'Values to add to selection.' }
+                    },
+                    required: ['values']
+                },
+                execute: (args) => {
+                    const toAdd = args['values'];
+                    const current = ms.value || [];
+                    const merged = [...current, ...toAdd.filter((v) => !current.includes(v))];
+                    zone.run(() => {
+                        ms.value = merged;
+                        ms.valueChange.emit(merged);
+                    });
+                    return { success: true, message: `Selected ${toAdd.length} item(s). Added: [${toAdd.join(', ')}]. Total selected: ${merged.length}.` };
+                }
+            }));
+        }
+        if (enabled.has('remove')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-remove`,
+                description: `Remove an item from the ${label} selection.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string', description: 'Value to remove from selection.' }
+                    },
+                    required: ['value']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        ms.removeTag.emit(args['value']);
+                    });
+                    return { success: true, message: `Removed "${args['value']}".` };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear all selections in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        ms.value = [];
+                        ms.valueChange.emit([]);
+                    });
+                    return { success: true, message: 'Selection cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'select', description: `Add items to the ${label} selection.`, enabled: true },
+            { name: 'remove', description: `Remove an item from the ${label} selection.`, enabled: true },
+            { name: 'clear', description: `Clear all selections in the ${label}.`, enabled: true }
+        ];
+    }
+}
+// DropDownTree
+/**
+ * @hidden
+ */
+class DropDownTreeToolAdapter {
+    selector = 'kendo-dropdowntree';
+    registerTools(ddt, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-dropdowntree';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' dropdown tree'
+            : 'Kendo UI DropDownTree';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('select')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select`,
+                description: `Select a node in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string', description: 'Node value to select.' }
+                    },
+                    required: ['value']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        ddt.value = args['value'];
+                        ddt.valueChange.emit(args['value']);
+                    });
+                    return { success: true, message: `Selected "${args['value']}".` };
+                }
+            }));
+        }
+        if (enabled.has('open')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-open`,
+                description: `Open the ${label} popup.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => ddt.toggle(true));
+                    return { success: true, message: 'Popup opened.' };
+                }
+            }));
+        }
+        if (enabled.has('close')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-close`,
+                description: `Close the ${label} popup.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => ddt.toggle(false));
+                    return { success: true, message: 'Popup closed.' };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear the ${label} value.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        ddt.value = null;
+                        ddt.valueChange.emit(null);
+                    });
+                    return { success: true, message: 'Value cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'select', description: `Select a node in the ${label}.`, enabled: true },
+            { name: 'open', description: `Open the ${label} popup.`, enabled: true },
+            { name: 'close', description: `Close the ${label} popup.`, enabled: true },
+            { name: 'clear', description: `Clear the ${label} value.`, enabled: true }
+        ];
+    }
+}
+// MultiColumnComboBox
+/**
+ * @hidden
+ */
+class MultiColumnComboBoxToolAdapter {
+    selector = 'kendo-multicolumncombobox';
+    registerTools(mccb, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-multicolumncombobox';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' multi-column combobox'
+            : 'Kendo UI MultiColumnComboBox';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('select')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select`,
+                description: `Select an item in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string', description: 'Value to select.' }
+                    },
+                    required: ['value']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        mccb.value = args['value'];
+                        mccb.valueChange.emit(args['value']);
+                        mccb.selectionChange.emit(args['value']);
+                    });
+                    return { success: true, message: `Selected "${args['value']}".` };
+                }
+            }));
+        }
+        if (enabled.has('search')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-search`,
+                description: `Search/filter items in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        text: { type: 'string', description: 'Search text.' }
+                    },
+                    required: ['text']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        mccb.filterChange.emit(args['text']);
+                    });
+                    return { success: true, message: `Searched for "${args['text']}".` };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear the ${label} value.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        mccb.value = null;
+                        mccb.valueChange.emit(null);
+                    });
+                    return { success: true, message: 'Value cleared.' };
+                }
+            }));
+        }
+        if (enabled.has('open')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-open`,
+                description: `Open the ${label} popup.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => mccb.toggle(true));
+                    return { success: true, message: 'Popup opened.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'select', description: `Select an item in the ${label}.`, enabled: true },
+            { name: 'search', description: `Search/filter items in the ${label}.`, enabled: true },
+            { name: 'clear', description: `Clear the ${label} value.`, enabled: true },
+            { name: 'open', description: `Open the ${label} popup.`, enabled: true }
+        ];
+    }
+}
+
+// DatePicker ────────────────────────────────────────────────────────
+/**
+ * @hidden
+ */
+class DatePickerToolAdapter {
+    selector = 'kendo-datepicker';
+    registerTools(dp, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-datepicker';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' date picker'
+            : 'Kendo UI DatePicker';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('set-value')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-value`,
+                description: `Set the date value of the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { date: { type: 'string', description: 'Date value (ISO 8601).' } },
+                    required: ['date']
+                },
+                execute: (args) => {
+                    const date = new Date(args['date']);
+                    zone.run(() => {
+                        dp.value = date;
+                        dp.valueChange.emit(date);
+                        dp.cdr.markForCheck();
+                    });
+                    return { success: true, message: `Date set to ${date.toISOString().split('T')[0]}.` };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear the ${label} value.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        dp.value = null;
+                        dp.valueChange.emit(null);
+                        dp.cdr.markForCheck();
+                    });
+                    return { success: true, message: 'Date cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'set-value', description: `Set the date value of the ${label}.`, enabled: true },
+            { name: 'clear', description: `Clear the ${label} value.`, enabled: true }
+        ];
+    }
+}
+// DateRangePicker
+/**
+ * @hidden
+ */
+class DateRangeToolAdapter {
+    selector = 'kendo-daterange';
+    registerTools(drp, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-daterangepicker';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' date range picker'
+            : 'Kendo UI DateRangePicker';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('set-range')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-range`,
+                description: `Set the date range in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        start: { type: 'string', description: 'Start date (ISO 8601).' },
+                        end: { type: 'string', description: 'End date (ISO 8601).' }
+                    },
+                    required: ['start', 'end']
+                },
+                execute: (args) => {
+                    const start = new Date(args['start']);
+                    const end = new Date(args['end']);
+                    zone.run(() => {
+                        drp.dateRangeService.range$.next({ start, end });
+                    });
+                    return { success: true, message: `Range set: ${start.toISOString().split('T')[0]} to ${end.toISOString().split('T')[0]}.` };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear the ${label} value.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => drp.dateRangeService.range$.next({ start: null, end: null }));
+                    return { success: true, message: 'Date range cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'set-range', description: `Set the date range in the ${label}.`, enabled: true },
+            { name: 'clear', description: `Clear the ${label} value.`, enabled: true }
+        ];
+    }
+}
+// TimePicker
+/**
+ * @hidden
+ */
+class TimePickerToolAdapter {
+    selector = 'kendo-timepicker';
+    registerTools(tp, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-timepicker';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' time picker'
+            : 'Kendo UI TimePicker';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('set-value')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-value`,
+                description: `Set the time value of the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { time: { type: 'string', description: 'Time value (ISO 8601 or HH:mm format).' } },
+                    required: ['time']
+                },
+                execute: (args) => {
+                    const time = new Date(args['time']);
+                    zone.run(() => {
+                        tp.value = time;
+                        tp.valueChange.emit(time);
+                        tp.cdr.markForCheck();
+                    });
+                    return { success: true, message: `Time set.` };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear the ${label} value.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        tp.value = null;
+                        tp.valueChange.emit(null);
+                        tp.cdr.markForCheck();
+                    });
+                    return { success: true, message: 'Time cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'set-value', description: `Set the time value of the ${label}.`, enabled: true },
+            { name: 'clear', description: `Clear the ${label} value.`, enabled: true }
+        ];
+    }
+}
+// DateTimePicker
+/**
+ * @hidden
+ */
+class DateTimePickerToolAdapter {
+    selector = 'kendo-datetimepicker';
+    registerTools(dtp, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-datetimepicker';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' date time picker'
+            : 'Kendo UI DateTimePicker';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('set-value')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-value`,
+                description: `Set the date and time value of the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { datetime: { type: 'string', description: 'Date/time value (ISO 8601).' } },
+                    required: ['datetime']
+                },
+                execute: (args) => {
+                    const dt = new Date(args['datetime']);
+                    zone.run(() => {
+                        dtp.value = dt;
+                        dtp.valueChange.emit(dt);
+                        dtp.cdr.markForCheck();
+                    });
+                    return { success: true, message: `Date/time set.` };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear the ${label} value.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        dtp.value = null;
+                        dtp.valueChange.emit(null);
+                        dtp.cdr.markForCheck();
+                    });
+                    return { success: true, message: 'Value cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'set-value', description: `Set the date and time value of the ${label}.`, enabled: true },
+            { name: 'clear', description: `Clear the ${label} value.`, enabled: true }
+        ];
+    }
+}
+// Calendar
+/**
+ * @hidden
+ */
+class CalendarToolAdapter {
+    selector = 'kendo-calendar';
+    registerTools(cal, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-calendar';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' calendar'
+            : 'Kendo UI Calendar';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('select-date')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select-date`,
+                description: `Select a date in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { date: { type: 'string', description: 'Date to select (ISO 8601).' } },
+                    required: ['date']
+                },
+                execute: (args) => {
+                    const date = new Date(args['date']);
+                    zone.run(() => {
+                        cal.value = date;
+                        cal.valueChange.emit(date);
+                        cal.cdr.markForCheck();
+                    });
+                    return { success: true, message: `Selected ${date.toISOString().split('T')[0]}.` };
+                }
+            }));
+        }
+        if (enabled.has('navigate')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-navigate`,
+                description: `Navigate the ${label} to a specific date.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { date: { type: 'string', description: 'Date to navigate to (ISO 8601).' } },
+                    required: ['date']
+                },
+                execute: (args) => {
+                    const date = new Date(args['date']);
+                    zone.run(() => {
+                        cal.focusedDate = date;
+                        cal.cdr.markForCheck();
+                    });
+                    return { success: true, message: `Navigated to ${date.toISOString().split('T')[0]}.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'select-date', description: `Select a date in the ${label}.`, enabled: true },
+            { name: 'navigate', description: `Navigate the ${label} to a specific date.`, enabled: true }
+        ];
+    }
+}
+
+/**
+ * @hidden
+ *
+ * Helper to build a simple set-value + clear adapter for input components.
+ */
+function buildSimpleAdapter(selector, defaultPrefix, componentLabel, toolSuffixes, tools) {
+    class Adapter {
+        selector = selector;
+        registerTools(component, config, mc, zone) {
+            const prefix = config.dataName || defaultPrefix;
+            const label = config.dataName
+                ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' ' + componentLabel
+                : 'Kendo UI ' + componentLabel;
+            const rawOptions = toolSuffixes.map(name => ({ name, description: name, enabled: true }));
+            const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+            const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+            return tools(component, prefix, label, mc, zone, enabled);
+        }
+    }
+    return Adapter;
+}
+// Slider
+/** @hidden */
+const SliderToolAdapter = buildSimpleAdapter('kendo-slider', 'kendo-slider', 'Slider', ['set-value'], (slider, prefix, label, mc, zone, enabled) => {
+    const handles = [];
+    if (enabled.has('set-value')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-set-value`,
+            description: `Set the value of the ${label}.`,
+            inputSchema: {
+                type: 'object',
+                properties: { value: { type: 'number', description: 'Slider value.' } },
+                required: ['value']
+            },
+            execute: (args) => {
+                zone.run(() => {
+                    slider.changeValue(args['value']);
+                });
+                return { success: true, message: `Value set to ${args['value']}.` };
+            }
+        }));
+    }
+    return handles;
+});
+// RangeSlider
+/** @hidden */
+const RangeSliderToolAdapter = buildSimpleAdapter('kendo-rangeslider', 'kendo-rangeslider', 'RangeSlider', ['set-value'], (rs, prefix, label, mc, zone, enabled) => {
+    const handles = [];
+    if (enabled.has('set-value')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-set-value`,
+            description: `Set the range value of the ${label}.`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    start: { type: 'number', description: 'Start value.' },
+                    end: { type: 'number', description: 'End value.' }
+                },
+                required: ['start', 'end']
+            },
+            execute: (args) => {
+                zone.run(() => {
+                    rs.value = { start: args['start'], end: args['end'] };
+                    rs.valueChange.emit({ start: args['start'], end: args['end'] });
+                });
+                return { success: true, message: `Range set to ${args['start']}-${args['end']}.` };
+            }
+        }));
+    }
+    return handles;
+});
+// Switch
+/** @hidden */
+const SwitchToolAdapter = buildSimpleAdapter('kendo-switch', 'kendo-switch', 'Switch', ['toggle'], (sw, prefix, label, mc, zone, enabled) => {
+    const handles = [];
+    if (enabled.has('toggle')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-toggle`,
+            description: `Toggle the ${label} on/off.`,
+            inputSchema: { type: 'object', properties: {}, required: [] },
+            execute: () => {
+                const newValue = !sw.checked;
+                zone.run(() => {
+                    sw.checked = newValue;
+                    sw.changeDetector.markForCheck();
+                    sw.valueChange.emit(newValue);
+                });
+                return { success: true, message: `Switched ${newValue ? 'on' : 'off'}.` };
+            }
+        }));
+    }
+    return handles;
+});
+// NumericTextBox
+/** @hidden */
+const NumericTextBoxToolAdapter = buildSimpleAdapter('kendo-numerictextbox', 'kendo-numerictextbox', 'NumericTextBox', ['set-value', 'increment', 'decrement', 'clear'], (ntb, prefix, label, mc, zone, enabled) => {
+    const handles = [];
+    if (enabled.has('set-value')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-set-value`,
+            description: `Set the numeric value of the ${label}.`,
+            inputSchema: {
+                type: 'object',
+                properties: { value: { type: 'number', description: 'Numeric value.' } },
+                required: ['value']
+            },
+            execute: (args) => {
+                zone.run(() => {
+                    ntb.value = args['value'];
+                    ntb.setInputValue();
+                    ntb.valueChange.emit(args['value']);
+                });
+                return { success: true, message: `Value set to ${args['value']}.` };
+            }
+        }));
+    }
+    if (enabled.has('increment')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-increment`,
+            description: `Increment the value of the ${label} by one step.`,
+            inputSchema: { type: 'object', properties: {}, required: [] },
+            execute: () => {
+                const current = ntb.value || 0;
+                const step = ntb.step || 1;
+                const newValue = current + step;
+                zone.run(() => {
+                    ntb.value = newValue;
+                    ntb.setInputValue();
+                    ntb.valueChange.emit(newValue);
+                });
+                return { success: true, message: `Incremented to ${newValue}.` };
+            }
+        }));
+    }
+    if (enabled.has('decrement')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-decrement`,
+            description: `Decrement the value of the ${label} by one step.`,
+            inputSchema: { type: 'object', properties: {}, required: [] },
+            execute: () => {
+                const current = ntb.value || 0;
+                const step = ntb.step || 1;
+                const newValue = current - step;
+                zone.run(() => {
+                    ntb.value = newValue;
+                    ntb.setInputValue();
+                    ntb.valueChange.emit(newValue);
+                });
+                return { success: true, message: `Decremented to ${newValue}.` };
+            }
+        }));
+    }
+    if (enabled.has('clear')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-clear`,
+            description: `Clear the ${label} value.`,
+            inputSchema: { type: 'object', properties: {}, required: [] },
+            execute: () => {
+                zone.run(() => {
+                    ntb.value = null;
+                    ntb.setInputValue();
+                    ntb.valueChange.emit(null);
+                });
+                return { success: true, message: 'Value cleared.' };
+            }
+        }));
+    }
+    return handles;
+});
+// ColorPicker
+/** @hidden */
+const ColorPickerToolAdapter = buildSimpleAdapter('kendo-colorpicker', 'kendo-colorpicker', 'ColorPicker', ['set-value', 'clear'], (cp, prefix, label, mc, zone, enabled) => {
+    const handles = [];
+    if (enabled.has('set-value')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-set-value`,
+            description: `Set the color value of the ${label}.`,
+            inputSchema: {
+                type: 'object',
+                properties: { color: { type: 'string', description: 'Color value (hex, rgb, or named color).' } },
+                required: ['color']
+            },
+            execute: (args) => {
+                zone.run(() => {
+                    cp.value = args['color'];
+                    cp.valueChange.emit(args['color']);
+                });
+                return { success: true, message: `Color set to "${args['color']}".` };
+            }
+        }));
+    }
+    if (enabled.has('clear')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-clear`,
+            description: `Clear the ${label} value.`,
+            inputSchema: { type: 'object', properties: {}, required: [] },
+            execute: () => {
+                zone.run(() => {
+                    cp.value = '';
+                    cp.valueChange.emit('');
+                });
+                return { success: true, message: 'Color cleared.' };
+            }
+        }));
+    }
+    return handles;
+});
+// TextBox
+/** @hidden */
+const TextBoxToolAdapter = buildSimpleAdapter('kendo-textbox', 'kendo-textbox', 'TextBox', ['set-value', 'clear'], (tb, prefix, label, mc, zone, enabled) => {
+    const handles = [];
+    if (enabled.has('set-value')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-set-value`,
+            description: `Set the text value of the ${label}.`,
+            inputSchema: {
+                type: 'object',
+                properties: { text: { type: 'string', description: 'Text to set.' } },
+                required: ['text']
+            },
+            execute: (args) => {
+                zone.run(() => {
+                    tb.value = args['text'];
+                    tb.valueChange.emit(args['text']);
+                });
+                return { success: true, message: `Value set.` };
+            }
+        }));
+    }
+    if (enabled.has('clear')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-clear`,
+            description: `Clear the ${label} value.`,
+            inputSchema: { type: 'object', properties: {}, required: [] },
+            execute: () => {
+                zone.run(() => {
+                    tb.value = '';
+                    tb.valueChange.emit('');
+                });
+                return { success: true, message: 'Value cleared.' };
+            }
+        }));
+    }
+    return handles;
+});
+// TextArea
+/** @hidden */
+const TextAreaToolAdapter = buildSimpleAdapter('kendo-textarea', 'kendo-textarea', 'TextArea', ['set-value', 'clear'], (ta, prefix, label, mc, zone, enabled) => {
+    const handles = [];
+    if (enabled.has('set-value')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-set-value`,
+            description: `Set the text value of the ${label}.`,
+            inputSchema: {
+                type: 'object',
+                properties: { text: { type: 'string', description: 'Text to set.' } },
+                required: ['text']
+            },
+            execute: (args) => {
+                zone.run(() => {
+                    ta.value = args['text'];
+                    ta.valueChange.emit(args['text']);
+                });
+                return { success: true, message: `Value set.` };
+            }
+        }));
+    }
+    if (enabled.has('clear')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-clear`,
+            description: `Clear the ${label} value.`,
+            inputSchema: { type: 'object', properties: {}, required: [] },
+            execute: () => {
+                zone.run(() => {
+                    ta.value = '';
+                    ta.valueChange.emit('');
+                });
+                return { success: true, message: 'Value cleared.' };
+            }
+        }));
+    }
+    return handles;
+});
+// MaskedTextBox
+/** @hidden */
+const MaskedTextBoxToolAdapter = buildSimpleAdapter('kendo-maskedtextbox', 'kendo-maskedtextbox', 'MaskedTextBox', ['set-value', 'clear'], (mtb, prefix, label, mc, zone, enabled) => {
+    const handles = [];
+    if (enabled.has('set-value')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-set-value`,
+            description: `Set the value of the ${label}.`,
+            inputSchema: {
+                type: 'object',
+                properties: { value: { type: 'string', description: 'Masked value.' } },
+                required: ['value']
+            },
+            execute: (args) => {
+                zone.run(() => {
+                    mtb.value = args['value'];
+                    mtb.valueChange.emit(args['value']);
+                });
+                return { success: true, message: `Value set.` };
+            }
+        }));
+    }
+    if (enabled.has('clear')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-clear`,
+            description: `Clear the ${label} value.`,
+            inputSchema: { type: 'object', properties: {}, required: [] },
+            execute: () => {
+                zone.run(() => {
+                    mtb.value = '';
+                    mtb.valueChange.emit('');
+                });
+                return { success: true, message: 'Value cleared.' };
+            }
+        }));
+    }
+    return handles;
+});
+// Signature
+/** @hidden */
+const SignatureToolAdapter = buildSimpleAdapter('kendo-signature', 'kendo-signature', 'Signature', ['clear'], (sig, prefix, label, mc, zone, enabled) => {
+    const handles = [];
+    if (enabled.has('clear')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-clear`,
+            description: `Clear the ${label}.`,
+            inputSchema: { type: 'object', properties: {}, required: [] },
+            execute: () => {
+                zone.run(() => {
+                    sig.value = '';
+                    sig.valueChange.emit('');
+                });
+                return { success: true, message: 'Signature cleared.' };
+            }
+        }));
+    }
+    return handles;
+});
+// Rating
+/** @hidden */
+const RatingToolAdapter = buildSimpleAdapter('kendo-rating', 'kendo-rating', 'Rating', ['set-value', 'clear'], (rating, prefix, label, mc, zone, enabled) => {
+    const handles = [];
+    if (enabled.has('set-value')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-set-value`,
+            description: `Set the rating value of the ${label}.`,
+            inputSchema: {
+                type: 'object',
+                properties: { value: { type: 'number', description: 'Rating value (e.g. 1-5).' } },
+                required: ['value']
+            },
+            execute: (args) => {
+                zone.run(() => {
+                    rating.value = args['value'];
+                    rating.valueChange.emit(args['value']);
+                });
+                return { success: true, message: `Rating set to ${args['value']}.` };
+            }
+        }));
+    }
+    if (enabled.has('clear')) {
+        handles.push(mc.registerTool({
+            name: `${prefix}-clear`,
+            description: `Clear the ${label} value.`,
+            inputSchema: { type: 'object', properties: {}, required: [] },
+            execute: () => {
+                zone.run(() => {
+                    rating.value = null;
+                    rating.valueChange.emit(null);
+                });
+                return { success: true, message: 'Rating cleared.' };
+            }
+        }));
+    }
+    return handles;
+});
+
+// TabStrip
+/**
+ * @hidden
+ */
+class TabStripToolAdapter {
+    selector = 'kendo-tabstrip';
+    registerTools(tabs, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-tabstrip';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' tab strip'
+            : 'Kendo UI TabStrip';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('select-tab')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select-tab`,
+                description: `Select a tab in the ${label} by title or index.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        tab: { type: 'string', description: 'Tab title or 0-based index.' }
+                    },
+                    required: ['tab']
+                },
+                execute: (args) => {
+                    const tab = args['tab'];
+                    const idx = parseInt(tab, 10);
+                    zone.run(() => {
+                        if (!isNaN(idx)) {
+                            tabs.selectTab(idx);
+                        }
+                        else {
+                            const items = tabs.tabs?.toArray() || [];
+                            const found = items.findIndex((t) => t.title === tab);
+                            if (found >= 0) {
+                                tabs.selectTab(found);
+                            }
+                        }
+                    });
+                    return { success: true, message: `Selected tab "${tab}".` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [{ name: 'select-tab', description: `Select a tab in the ${label} by title or index.`, enabled: true }];
+    }
+}
+// PanelBar
+/**
+ * @hidden
+ */
+class PanelBarToolAdapter {
+    selector = 'kendo-panelbar';
+    registerTools(pb, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-panelbar';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' panel bar'
+            : 'Kendo UI PanelBar';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('expand')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-expand`,
+                description: `Expand a panel in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { id: { type: 'string', description: 'Panel identifier or title.' } },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    const id = args['id'];
+                    zone.run(() => {
+                        const items = pb.allItems || [];
+                        const item = items.find((i) => i.id === id || i.title === id);
+                        if (item && !item.expanded) {
+                            pb.onItemAction(item);
+                        }
+                    });
+                    return { success: true, message: `Panel "${id}" expanded.` };
+                }
+            }));
+        }
+        if (enabled.has('collapse')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-collapse`,
+                description: `Collapse a panel in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { id: { type: 'string', description: 'Panel identifier or title.' } },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    const id = args['id'];
+                    zone.run(() => {
+                        const items = pb.allItems || [];
+                        const item = items.find((i) => i.id === id || i.title === id);
+                        if (item?.expanded) {
+                            pb.onItemAction(item);
+                        }
+                    });
+                    return { success: true, message: `Panel "${id}" collapsed.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'expand', description: `Expand a panel in the ${label}.`, enabled: true },
+            { name: 'collapse', description: `Collapse a panel in the ${label}.`, enabled: true }
+        ];
+    }
+}
+// Drawer
+/**
+ * @hidden
+ */
+class DrawerToolAdapter {
+    selector = 'kendo-drawer';
+    registerTools(drawer, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-drawer';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' drawer'
+            : 'Kendo UI Drawer';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('open')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-open`,
+                description: `Open the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        drawer.expanded = true;
+                        drawer.expandedChange?.emit(true);
+                    });
+                    return { success: true, message: 'Drawer opened.' };
+                }
+            }));
+        }
+        if (enabled.has('close')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-close`,
+                description: `Close the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        drawer.expanded = false;
+                        drawer.expandedChange?.emit(false);
+                    });
+                    return { success: true, message: 'Drawer closed.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'open', description: `Open the ${label}.`, enabled: true },
+            { name: 'close', description: `Close the ${label}.`, enabled: true }
+        ];
+    }
+}
+// Stepper
+/**
+ * @hidden
+ */
+class StepperToolAdapter {
+    selector = 'kendo-stepper';
+    registerTools(stepper, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-stepper';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' stepper'
+            : 'Kendo UI Stepper';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('step')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-step`,
+                description: `Navigate to a step in the ${label} by 0-based index.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        step: { type: 'number', description: '0-based step index to navigate to.' }
+                    },
+                    required: ['step']
+                },
+                execute: (args) => {
+                    const step = args['step'];
+                    zone.run(() => {
+                        stepper.currentStep = step;
+                        stepper.activate.emit({ index: step });
+                    });
+                    return { success: true, message: `Navigated to step ${step}.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [{ name: 'step', description: `Navigate to a step in the ${label} by 0-based index.`, enabled: true }];
+    }
+}
+
+// Dialog
+/**
+ * @hidden
+ */
+class DialogToolAdapter {
+    selector = 'kendo-dialog';
+    registerTools(dialog, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-dialog';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' dialog'
+            : 'Kendo UI Dialog';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('confirm')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-confirm`,
+                description: `Confirm/accept the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => dialog.action.emit({ text: 'confirm' }));
+                    return { success: true, message: 'Dialog confirmed.' };
+                }
+            }));
+        }
+        if (enabled.has('cancel')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-cancel`,
+                description: `Cancel/close the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => dialog.close.emit());
+                    return { success: true, message: 'Dialog cancelled.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'confirm', description: `Confirm/accept the ${label}.`, enabled: true },
+            { name: 'cancel', description: `Cancel/close the ${label}.`, enabled: true }
+        ];
+    }
+}
+// Window
+/**
+ * @hidden
+ */
+class WindowToolAdapter {
+    selector = 'kendo-window';
+    registerTools(win, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-window';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' window'
+            : 'Kendo UI Window';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('open')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-open`,
+                description: `Open/restore the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        win.state = 'default';
+                        win.stateChange?.emit('default');
+                    });
+                    return { success: true, message: 'Window opened.' };
+                }
+            }));
+        }
+        if (enabled.has('close')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-close`,
+                description: `Close the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => win.close.emit());
+                    return { success: true, message: 'Window closed.' };
+                }
+            }));
+        }
+        if (enabled.has('minimize')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-minimize`,
+                description: `Minimize the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        win.state = 'minimized';
+                        win.stateChange?.emit('minimized');
+                    });
+                    return { success: true, message: 'Window minimized.' };
+                }
+            }));
+        }
+        if (enabled.has('maximize')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-maximize`,
+                description: `Maximize the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        win.state = 'maximized';
+                        win.stateChange?.emit('maximized');
+                    });
+                    return { success: true, message: 'Window maximized.' };
+                }
+            }));
+        }
+        if (enabled.has('restore')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-restore`,
+                description: `Restore the ${label} to its default size after being minimized or maximized.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        win.state = 'default';
+                        win.stateChange?.emit('default');
+                    });
+                    return { success: true, message: 'Window restored.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'open', description: `Open/restore the ${label}.`, enabled: true },
+            { name: 'close', description: `Close the ${label}.`, enabled: true },
+            { name: 'minimize', description: `Minimize the ${label}.`, enabled: true },
+            { name: 'maximize', description: `Maximize the ${label}.`, enabled: true },
+            { name: 'restore', description: `Restore the ${label} to its default size after being minimized or maximized.`, enabled: true }
+        ];
+    }
+}
+
+// Chat
+/**
+ * @hidden
+ */
+class ChatToolAdapter {
+    selector = 'kendo-chat';
+    registerTools(chat, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-chat';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' chat'
+            : 'Kendo UI Chat';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('send-message')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-send-message`,
+                description: `Send a message in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { text: { type: 'string', description: 'Message text.' } },
+                    required: ['text']
+                },
+                execute: (args) => {
+                    const timestamp = new Date();
+                    zone.run(() => {
+                        const msg = {
+                            author: { id: chat.authorId, name: 'User' },
+                            text: args['text'],
+                            timestamp
+                        };
+                        const updated = [...(chat.messages || []), msg];
+                        chat.messages = updated;
+                        if (chat.chatService) {
+                            chat.chatService.messages = chat.processedMessages;
+                        }
+                        chat.sendMessage.emit({ message: msg });
+                    });
+                    return { success: true, message: `Message sent. Author: "User" (id: ${chat.authorId}), Text: "${args['text']}", Timestamp: ${timestamp.toISOString()}.` };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear the ${label} messages.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        chat.messages = [];
+                        if (chat.chatService) {
+                            chat.chatService.messages = [];
+                        }
+                    });
+                    return { success: true, message: 'Chat cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'send-message', description: `Send a message in the ${label}.`, enabled: true },
+            { name: 'clear', description: `Clear the ${label} messages.`, enabled: true }
+        ];
+    }
+}
+// AIPrompt
+/**
+ * @hidden
+ */
+class AIPromptToolAdapter {
+    selector = 'kendo-aiprompt';
+    registerTools(prompt, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-aiprompt';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' AI prompt'
+            : 'Kendo UI AIPrompt';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('submit')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-submit`,
+                description: `Submit a prompt to the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { text: { type: 'string', description: 'Prompt text.' } },
+                    required: ['text']
+                },
+                execute: (args) => {
+                    zone.run(() => prompt.promptRequest?.emit(args['text']));
+                    return { success: true, message: `Prompt submitted: "${args['text']}".` };
+                }
+            }));
+        }
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    return { success: true, message: 'AI Prompt cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'submit', description: `Submit a prompt to the ${label}.`, enabled: true },
+            { name: 'clear', description: `Clear the ${label}.`, enabled: true }
+        ];
+    }
+}
+
+// TreeView
+/**
+ * @hidden
+ */
+class TreeViewToolAdapter {
+    selector = 'kendo-treeview';
+    registerTools(tv, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-treeview';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' tree view'
+            : 'Kendo UI TreeView';
+        const rawOptions = this.buildToolOptions(tv, config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('expand')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-expand`,
+                description: `Expand a node in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { id: { type: 'string', description: 'Node identifier to expand.' } },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    zone.run(() => tv.expand.emit({ dataItem: { id: args['id'] }, index: args['id'] }));
+                    return { success: true, message: `Node "${args['id']}" expanded.` };
+                }
+            }));
+        }
+        if (enabled.has('collapse')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-collapse`,
+                description: `Collapse a node in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { id: { type: 'string', description: 'Node identifier to collapse.' } },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    zone.run(() => tv.collapse.emit({ dataItem: { id: args['id'] }, index: args['id'] }));
+                    return { success: true, message: `Node "${args['id']}" collapsed.` };
+                }
+            }));
+        }
+        if (enabled.has('select')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select`,
+                description: `Select a node in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { id: { type: 'string', description: 'Node identifier to select.' } },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    zone.run(() => tv.selectionChange.emit({ dataItem: { text: args['id'] }, index: args['id'] }));
+                    return { success: true, message: `Node "${args['id']}" selected.` };
+                }
+            }));
+        }
+        if (enabled.has('check') && tv.checkboxes) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-check`,
+                description: `Toggle the checkbox of a node in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { id: { type: 'string', description: 'Node identifier to check/uncheck.' } },
+                    required: ['id']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        const lookup = tv.itemLookup(args['id']);
+                        if (lookup) {
+                            tv.checkedChange.emit(lookup);
+                            tv.changeDetectorRef.markForCheck();
+                        }
+                    });
+                    return { success: true, message: `Node "${args['id']}" toggled.` };
+                }
+            }));
+        }
+        if (enabled.has('filter') && tv.filterable) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-filter`,
+                description: `Filter nodes in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { text: { type: 'string', description: 'Filter text.' } },
+                    required: ['text']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        tv.filter = args['text'];
+                        tv.filterChange.emit(args['text']);
+                        tv.changeDetectorRef.markForCheck();
+                    });
+                    return { success: true, message: `Filtered by "${args['text']}".` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(tv, config, label) {
+        return [
+            { name: 'expand', description: `Expand a node in the ${label}.`, enabled: true },
+            { name: 'collapse', description: `Collapse a node in the ${label}.`, enabled: true },
+            { name: 'select', description: `Select a node in the ${label}.`, enabled: true },
+            { name: 'check', description: `Toggle the checkbox of a node in the ${label}.`, enabled: !!tv.checkboxes },
+            { name: 'filter', description: `Filter nodes in the ${label}.`, enabled: !!tv.filterable }
+        ];
+    }
+}
+// ListBox
+/**
+ * @hidden
+ */
+class ListBoxToolAdapter {
+    selector = 'kendo-listbox';
+    registerTools(lb, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-listbox';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' list box'
+            : 'Kendo UI ListBox';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('transfer')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-transfer`,
+                description: `Transfer items from the ${label} to the connected list box. Selects items by index first, then transfers.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        indices: { type: 'array', items: { type: 'number' }, description: 'Zero-based indices of items to transfer.' },
+                        direction: { type: 'string', enum: ['to', 'from'], description: 'Transfer direction: "to" or "from".' }
+                    },
+                    required: ['indices']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        const indices = args['indices'] || [0];
+                        lb.select(indices);
+                        const action = args['direction'] === 'from' ? 'transferFrom' : 'transferTo';
+                        lb.performAction(action);
+                    });
+                    return { success: true, message: `Transferred item(s) at indices ${args['indices']}.` };
+                }
+            }));
+        }
+        if (enabled.has('reorder')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-reorder`,
+                description: `Reorder an item in the ${label}. Selects the item by index first, then moves it.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        index: { type: 'number', description: 'Zero-based index of item to move.' },
+                        direction: { type: 'string', enum: ['up', 'down'], description: 'Direction to move.' }
+                    },
+                    required: ['index', 'direction']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        lb.select([args['index']]);
+                        lb.performAction((args['direction'] === 'up' ? 'moveUp' : 'moveDown'));
+                    });
+                    return { success: true, message: `Item at index ${args['index']} moved ${args['direction']}.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'transfer', description: `Transfer items in the ${label}.`, enabled: true },
+            { name: 'reorder', description: `Reorder an item in the ${label}.`, enabled: true }
+        ];
+    }
+}
+// ListView
+/**
+ * @hidden
+ */
+class ListViewToolAdapter {
+    selector = 'kendo-listview';
+    registerTools(lv, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-listview';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' list view'
+            : 'Kendo UI ListView';
+        const rawOptions = this.buildToolOptions(lv, config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('page') && lv.pageable) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-page`,
+                description: `Navigate to a page in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { page: { type: 'number', description: '1-based page number.' } },
+                    required: ['page']
+                },
+                execute: (args) => {
+                    zone.run(() => lv.pageChange.emit({ skip: (args['page'] - 1) * (lv.pageSize || 10), take: lv.pageSize || 10 }));
+                    return { success: true, message: `Navigated to page ${args['page']}.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(lv, config, label) {
+        return [{ name: 'page', description: `Navigate to a page in the ${label}.`, enabled: !!lv.pageable }];
+    }
+}
+// Menu
+/**
+ * @hidden
+ */
+class MenuToolAdapter {
+    selector = 'kendo-menu';
+    registerTools(menu, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-menu';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' menu'
+            : 'Kendo UI Menu';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('select-item')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-select-item`,
+                description: `Select a menu item in the ${label} by path.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { path: { type: 'string', description: "Menu item path (e.g. 'File > Export > PDF')." } },
+                    required: ['path']
+                },
+                execute: (args) => {
+                    zone.run(() => menu.select.emit({ item: { text: args['path'] } }));
+                    return { success: true, message: `Selected "${args['path']}".` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [{ name: 'select-item', description: `Select a menu item in the ${label} by path.`, enabled: true }];
+    }
+}
+// ScrollView
+/**
+ * @hidden
+ */
+class ScrollViewToolAdapter {
+    selector = 'kendo-scrollview';
+    registerTools(sv, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-scrollview';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' scroll view'
+            : 'Kendo UI ScrollView';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('next')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-next`,
+                description: `Navigate to the next slide in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => sv.next());
+                    return { success: true, message: 'Moved to next slide.' };
+                }
+            }));
+        }
+        if (enabled.has('previous')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-previous`,
+                description: `Navigate to the previous slide in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => sv.prev());
+                    return { success: true, message: 'Moved to previous slide.' };
+                }
+            }));
+        }
+        if (enabled.has('navigate')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-navigate`,
+                description: `Navigate to a specific slide in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { index: { type: 'number', description: '0-based slide index.' } },
+                    required: ['index']
+                },
+                execute: (args) => {
+                    zone.run(() => sv.activeIndex = args['index']);
+                    return { success: true, message: `Navigated to slide ${args['index']}.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'next', description: `Navigate to the next slide in the ${label}.`, enabled: true },
+            { name: 'previous', description: `Navigate to the previous slide in the ${label}.`, enabled: true },
+            { name: 'navigate', description: `Navigate to a specific slide in the ${label}.`, enabled: true }
+        ];
+    }
+}
+// Sortable
+/**
+ * @hidden
+ */
+class SortableToolAdapter {
+    selector = 'kendo-sortable';
+    registerTools(sortable, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-sortable';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' sortable'
+            : 'Kendo UI Sortable';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('reorder')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-reorder`,
+                description: `Reorder items in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        fromIndex: { type: 'number', description: 'Source index.' },
+                        toIndex: { type: 'number', description: 'Destination index.' }
+                    },
+                    required: ['fromIndex', 'toIndex']
+                },
+                execute: (args) => {
+                    zone.run(() => sortable.moveItem(args['fromIndex'], args['toIndex']));
+                    return { success: true, message: `Moved item from ${args['fromIndex']} to ${args['toIndex']}.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [{ name: 'reorder', description: `Reorder items in the ${label}.`, enabled: true }];
+    }
+}
+// Map
+/**
+ * @hidden
+ */
+class MapToolAdapter {
+    selector = 'kendo-map';
+    registerTools(map, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-map';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' map'
+            : 'Kendo UI Map';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('set-center')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-center`,
+                description: `Set the center of the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        lat: { type: 'number', description: 'Latitude.' },
+                        lng: { type: 'number', description: 'Longitude.' }
+                    },
+                    required: ['lat', 'lng']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        map.center = [args['lat'], args['lng']];
+                        if (map.instance) {
+                            map.instance.center([args['lat'], args['lng']]);
+                        }
+                    });
+                    return { success: true, message: `Center set to [${args['lat']}, ${args['lng']}].` };
+                }
+            }));
+        }
+        if (enabled.has('set-zoom')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-set-zoom`,
+                description: `Set the zoom level of the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: { zoom: { type: 'number', description: 'Zoom level (1-20).' } },
+                    required: ['zoom']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        map.zoom = args['zoom'];
+                        if (map.instance) {
+                            map.instance.zoom(args['zoom']);
+                        }
+                    });
+                    return { success: true, message: `Zoom set to ${args['zoom']}.` };
+                }
+            }));
+        }
+        if (enabled.has('add-marker')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-add-marker`,
+                description: `Add a marker to the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        lat: { type: 'number', description: 'Latitude.' },
+                        lng: { type: 'number', description: 'Longitude.' },
+                        title: { type: 'string', description: 'Marker tooltip (optional).' }
+                    },
+                    required: ['lat', 'lng']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        map.instance?.markers?.add({ location: [args['lat'], args['lng']], tooltip: { content: args['title'] || '' } });
+                    });
+                    return { success: true, message: `Marker added at [${args['lat']}, ${args['lng']}].` };
+                }
+            }));
+        }
+        if (enabled.has('clear-markers')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear-markers`,
+                description: `Clear all markers from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => {
+                        map.instance?.markers?.clear();
+                    });
+                    return { success: true, message: 'Markers cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'set-center', description: `Set the center of the ${label}.`, enabled: true },
+            { name: 'set-zoom', description: `Set the zoom level of the ${label}.`, enabled: true },
+            { name: 'add-marker', description: `Add a marker to the ${label}.`, enabled: true },
+            { name: 'clear-markers', description: `Clear all markers from the ${label}.`, enabled: true }
+        ];
+    }
+}
+// Notification
+/**
+ * @hidden
+ */
+class NotificationToolAdapter {
+    selector = 'kendo-notification';
+    registerTools(notif, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-notification';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' notification'
+            : 'Kendo UI Notification';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('show')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-show`,
+                description: `Show a notification in the ${label}.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        text: { type: 'string', description: 'Notification text.' },
+                        type: { type: 'string', description: 'Notification type (success, info, warning, error).' }
+                    },
+                    required: ['text']
+                },
+                execute: (args) => {
+                    zone.run(() => {
+                        notif.templateString = args['text'];
+                        notif.type = { style: args['type'] || 'info', icon: true };
+                        notif.cdr.markForCheck();
+                    });
+                    return { success: true, message: `Notification shown: "${args['text']}".` };
+                }
+            }));
+        }
+        if (enabled.has('dismiss')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-dismiss`,
+                description: `Dismiss all notifications in the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => notif.hide());
+                    return { success: true, message: 'Notifications dismissed.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [
+            { name: 'show', description: `Show a notification in the ${label}.`, enabled: true },
+            { name: 'dismiss', description: `Dismiss all notifications in the ${label}.`, enabled: true }
+        ];
+    }
+}
+// Upload
+/**
+ * @hidden
+ */
+class UploadToolAdapter {
+    selector = 'kendo-upload';
+    registerTools(upload, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-upload';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' upload'
+            : 'Kendo UI Upload';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('clear')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-clear`,
+                description: `Clear all files from the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    zone.run(() => upload.clearFiles());
+                    return { success: true, message: 'Files cleared.' };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [{ name: 'clear', description: `Clear all files from the ${label}.`, enabled: true }];
+    }
+}
+// Button
+/**
+ * @hidden
+ */
+class ButtonToolAdapter {
+    selector = '[kendoButton]';
+    registerTools(btn, config, mc, zone) {
+        const prefix = config.dataName || 'kendo-button';
+        const label = config.dataName
+            ? config.dataName.charAt(0).toUpperCase() + config.dataName.slice(1) + ' button'
+            : 'Kendo UI Button';
+        const rawOptions = this.buildToolOptions(config, label);
+        const finalOptions = config.tools ? config.tools(rawOptions) : rawOptions;
+        const enabled = new Set(finalOptions.filter(t => t.enabled !== false).map(t => t.name));
+        const handles = [];
+        if (enabled.has('click')) {
+            handles.push(mc.registerTool({
+                name: `${prefix}-click`,
+                description: `Click the ${label}.`,
+                inputSchema: { type: 'object', properties: {}, required: [] },
+                execute: () => {
+                    if (btn.disabled) {
+                        return { success: false, message: 'Button is disabled.' };
+                    }
+                    zone.run(() => btn.element.click());
+                    return { success: true, message: `Clicked the ${label}.` };
+                }
+            }));
+        }
+        return handles;
+    }
+    buildToolOptions(config, label) {
+        return [{ name: 'click', description: `Click the ${label}.`, enabled: true }];
+    }
+}
+
+const ADAPTERS = [
+    new GridToolAdapter(),
+    new TreeListToolAdapter(),
+    new SchedulerToolAdapter(),
+    new ChartToolAdapter(),
+    new EditorToolAdapter(),
+    new SpreadsheetToolAdapter(),
+    new GanttToolAdapter(),
+    new PivotGridToolAdapter(),
+    new DropDownListToolAdapter(),
+    new ComboBoxToolAdapter(),
+    new AutoCompleteToolAdapter(),
+    new MultiSelectToolAdapter(),
+    new DropDownTreeToolAdapter(),
+    new MultiColumnComboBoxToolAdapter(),
+    new DatePickerToolAdapter(),
+    new DateRangeToolAdapter(),
+    new TimePickerToolAdapter(),
+    new DateTimePickerToolAdapter(),
+    new CalendarToolAdapter(),
+    new SliderToolAdapter(),
+    new RangeSliderToolAdapter(),
+    new SwitchToolAdapter(),
+    new NumericTextBoxToolAdapter(),
+    new ColorPickerToolAdapter(),
+    new TextBoxToolAdapter(),
+    new TextAreaToolAdapter(),
+    new MaskedTextBoxToolAdapter(),
+    new SignatureToolAdapter(),
+    new RatingToolAdapter(),
+    new TabStripToolAdapter(),
+    new PanelBarToolAdapter(),
+    new DrawerToolAdapter(),
+    new StepperToolAdapter(),
+    new DialogToolAdapter(),
+    new WindowToolAdapter(),
+    new ChatToolAdapter(),
+    new AIPromptToolAdapter(),
+    new TreeViewToolAdapter(),
+    new ListBoxToolAdapter(),
+    new ListViewToolAdapter(),
+    new MenuToolAdapter(),
+    new ScrollViewToolAdapter(),
+    new SortableToolAdapter(),
+    new MapToolAdapter(),
+    new NotificationToolAdapter(),
+    new UploadToolAdapter(),
+    new ButtonToolAdapter()
+];
+/**
+ * Registers Web MCP tools for the host Kendo Angular component.
+ *
+ * Apply this attribute directive to any supported Kendo component to expose
+ * AI-discoverable tools through the browser's Web MCP protocol (Chrome 146+).
+ *
+ * @example
+ * ```html
+ * <kendo-grid [data]="data" [kendoWebMcp]="true"></kendo-grid>
+ * ```
+ *
+ * @example
+ * ```html
+ * <kendo-grid [data]="data" [kendoWebMcp]="{ dataName: 'orders' }"></kendo-grid>
+ * ```
+ */
+class WebMcpDirective {
+    el;
+    ngZone;
+    hostComponent;
+    /**
+     * Enables or configures the Web MCP tools for the host component.
+     *
+     * - `true` — registers all supported tools with defaults.
+     * - `WebMcpConfig` — fine-grained control over which tool groups are enabled.
+     * - `false` — disables all tools.
+     */
+    config = true;
+    registrations = [];
+    modelContext = null;
+    constructor(el, ngZone, hostComponent) {
+        this.el = el;
+        this.ngZone = ngZone;
+        this.hostComponent = hostComponent;
+        validatePackage(packageMetadata);
+    }
+    ngOnInit() {
+        if (!this.isBrowserWithMcp()) {
+            return;
+        }
+        this.modelContext = navigator.modelContext;
+        this.registerAll();
+    }
+    ngOnChanges(changes) {
+        if (changes['config'] && !changes['config'].firstChange) {
+            this.unregisterAll();
+            this.registerAll();
+        }
+    }
+    ngOnDestroy() {
+        this.unregisterAll();
+    }
+    registerAll() {
+        const resolved = resolveConfig(this.config);
+        if (!resolved || !this.modelContext || !this.hostComponent) {
+            return;
+        }
+        const mc = this.modelContext;
+        const adapter = this.findAdapter();
+        if (!adapter) {
+            return;
+        }
+        this.ngZone.runOutsideAngular(() => {
+            const handles = adapter.registerTools(this.hostComponent, resolved, mc, this.ngZone);
+            this.registrations.push(...handles);
+        });
+    }
+    findAdapter() {
+        const el = this.el.nativeElement;
+        const tag = el.tagName.toLowerCase();
+        for (const adapter of ADAPTERS) {
+            const sel = adapter.selector;
+            if (sel.startsWith('[')) {
+                // Attribute selector — check for the attribute on the host element
+                const attr = sel.slice(1, -1);
+                if (el.hasAttribute(attr) || el.hasAttribute(attr.toLowerCase())) {
+                    return adapter;
+                }
+            }
+            else if (sel === tag) {
+                return adapter;
+            }
+        }
+        return null;
+    }
+    unregisterAll() {
+        for (const reg of this.registrations) {
+            reg.unregister();
+        }
+        this.registrations = [];
+    }
+    isBrowserWithMcp() {
+        return isDocumentAvailable()
+            && typeof navigator !== 'undefined'
+            && !!navigator.modelContext;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: WebMcpDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: KENDO_WEBMCP_HOST, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.20", type: WebMcpDirective, isStandalone: true, selector: "[kendoWebMcp]", inputs: { config: ["kendoWebMcp", "config"] }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: WebMcpDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoWebMcp]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Host
+                }, {
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [KENDO_WEBMCP_HOST]
+                }] }], propDecorators: { config: [{
+                type: Input,
+                args: ['kendoWebMcp']
+            }] } });
+
+/**
+ * Use the `KENDO_WEBMCP` utility array to add Web MCP support to a standalone Angular component.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { KENDO_WEBMCP } from '@progress/kendo-angular-webmcp';
+ * import { KENDO_GRID } from '@progress/kendo-angular-grid';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [KENDO_WEBMCP, KENDO_GRID],
+ *   template: `
+ *      <kendo-grid [data]="data" [kendoWebMcp]="true"></kendo-grid>
+ *   `,
+ * })
+ * export class AppComponent {
+ *   data = [...];
+ * }
+ * ```
+ */
+const KENDO_WEBMCP = [
+    WebMcpDirective
+];
+
+//IMPORTANT: NgModule export kept for backwards compatibility
+/**
+ * Represents the [NgModule](link:site.data.urls.angular['ngmoduleapi'])
+ * definition for the Web MCP directive.
+ *
+ * @example
+ * ```typescript
+ * import { NgModule } from '@angular/core';
+ * import { BrowserModule } from '@angular/platform-browser';
+ * import { WebMcpModule } from '@progress/kendo-angular-webmcp';
+ * import { GridModule } from '@progress/kendo-angular-grid';
+ * import { AppComponent } from './app.component';
+ *
+ * @NgModule({
+ *   declarations: [AppComponent],
+ *   imports: [BrowserModule, GridModule, WebMcpModule],
+ *   bootstrap: [AppComponent]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+class WebMcpModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: WebMcpModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.20", ngImport: i0, type: WebMcpModule, imports: [WebMcpDirective], exports: [WebMcpDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: WebMcpModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: WebMcpModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...KENDO_WEBMCP],
+                    exports: [...KENDO_WEBMCP]
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { KENDO_WEBMCP, WebMcpDirective, WebMcpModule };
+