@kyuda/n8n-nodes-databricks 1.0.2

package/dist/nodes/Databricks/Databricks.node.js

@@ -0,0 +1,1719 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Databricks = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const resources_1 = require("./resources");
+const mime_types_1 = __importDefault(require("mime-types"));
+const endpointCache = new Map();
+const warehouseCache = new Map();
+const catalogCache = new Map();
+const schemaCache = new Map();
+const volumeCache = new Map();
+const tableCache = new Map();
+const functionCache = new Map();
+const CACHE_TTL = 1 * 60 * 1000;
+function getCacheKey(host, type) {
+    return `${host}:${type}`;
+}
+function isCacheValid(entry) {
+    if (!entry)
+        return false;
+    return Date.now() - entry.timestamp < CACHE_TTL;
+}
+function detectInputFormat(openApiSchema) {
+    var _a, _b, _c, _d, _e, _f;
+    const invocationUrl = (_b = (_a = openApiSchema.servers) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url;
+    if (!invocationUrl) {
+        throw new Error('No server URL found in OpenAPI schema');
+    }
+    const pathKeys = Object.keys(openApiSchema.paths);
+    if (!pathKeys.length) {
+        throw new Error('No paths found in OpenAPI schema');
+    }
+    const invocationPath = pathKeys[0];
+    const postOperation = (_c = openApiSchema.paths[invocationPath]) === null || _c === void 0 ? void 0 : _c.post;
+    if (!((_f = (_e = (_d = postOperation === null || postOperation === void 0 ? void 0 : postOperation.requestBody) === null || _d === void 0 ? void 0 : _d.content) === null || _e === void 0 ? void 0 : _e['application/json']) === null || _f === void 0 ? void 0 : _f.schema)) {
+        throw new Error('No request schema found');
+    }
+    const schema = postOperation.requestBody.content['application/json'].schema;
+    if (schema.oneOf && schema.oneOf.length > 0) {
+        for (const option of schema.oneOf) {
+            const properties = option.properties || {};
+            if (properties.messages) {
+                return { format: 'chat', schema: properties.messages, requiredFields: ['messages'], invocationUrl };
+            }
+            if (properties.prompt) {
+                return { format: 'completions', schema: properties.prompt, requiredFields: ['prompt'], invocationUrl };
+            }
+            if (properties.input && !properties.dataframe_records && !properties.dataframe_split) {
+                return { format: 'embeddings', schema: properties.input, requiredFields: ['input'], invocationUrl };
+            }
+            if (properties.dataframe_split) {
+                return {
+                    format: 'dataframe_split',
+                    schema: properties.dataframe_split,
+                    requiredFields: ['dataframe_split'],
+                    invocationUrl,
+                };
+            }
+            if (properties.dataframe_records) {
+                return { format: 'dataframe_records', schema: properties.dataframe_records, requiredFields: ['dataframe_records'], invocationUrl };
+            }
+            if (properties.inputs) {
+                return { format: 'inputs', schema: properties.inputs, requiredFields: ['inputs'], invocationUrl };
+            }
+            if (properties.instances) {
+                return { format: 'instances', schema: properties.instances, requiredFields: ['instances'], invocationUrl };
+            }
+        }
+    }
+    const properties = schema.properties || {};
+    if (properties.messages)
+        return { format: 'chat', schema: properties.messages, requiredFields: ['messages'], invocationUrl };
+    if (properties.prompt)
+        return { format: 'completions', schema: properties.prompt, requiredFields: ['prompt'], invocationUrl };
+    if (properties.input)
+        return { format: 'embeddings', schema: properties.input, requiredFields: ['input'], invocationUrl };
+    if (properties.dataframe_records)
+        return { format: 'dataframe_records', schema: properties.dataframe_records, requiredFields: ['dataframe_records'], invocationUrl };
+    if (properties.dataframe_split)
+        return { format: 'dataframe_split', schema: properties.dataframe_split, requiredFields: ['dataframe_split'], invocationUrl };
+    if (properties.inputs)
+        return { format: 'inputs', schema: properties.inputs, requiredFields: ['inputs'], invocationUrl };
+    if (properties.instances)
+        return { format: 'instances', schema: properties.instances, requiredFields: ['instances'], invocationUrl };
+    return { format: 'generic', schema: schema, requiredFields: [], invocationUrl };
+}
+function generateExampleFromSchema(schema, format) {
+    if (schema && schema.properties) {
+        try {
+            const exampleObj = {};
+            for (const [key, propValue] of Object.entries(schema.properties)) {
+                const prop = propValue;
+                const propType = prop.type;
+                if (key === 'messages' && propType === 'array') {
+                    exampleObj.messages = [
+                        { role: 'user', content: 'Hello! How can you help me today?' }
+                    ];
+                }
+                else if (key === 'prompt' && propType === 'string') {
+                    exampleObj.prompt = 'What is Databricks?';
+                }
+                else if (key === 'input' && propType === 'array') {
+                    exampleObj.input = ['Text to embed'];
+                }
+                else if (key === 'max_tokens' && propType === 'integer') {
+                    exampleObj.max_tokens = 256;
+                }
+                else if (key === 'temperature' && propType === 'number') {
+                    exampleObj.temperature = 0.7;
+                }
+                else if (key === 'top_p' && propType === 'number') {
+                    exampleObj.top_p = 0.9;
+                }
+                else if (key === 'top_k' && propType === 'integer') {
+                    exampleObj.top_k = 40;
+                }
+                else if (key === 'stream' && propType === 'boolean') {
+                    exampleObj.stream = false;
+                }
+                else if (key === 'n' && propType === 'integer') {
+                    exampleObj.n = 1;
+                }
+                else if (key === 'stop' && prop.oneOf) {
+                    exampleObj.stop = ['\\n'];
+                }
+            }
+            if (Object.keys(exampleObj).length > 0) {
+                return JSON.stringify(exampleObj, null, 2);
+            }
+        }
+        catch (e) {
+        }
+    }
+    const examples = {
+        chat: `{
+  "messages": [
+    {
+      "role": "user",
+      "content": "Hello! How are you?"
+    }
+  ],
+  "max_tokens": 256,
+  "temperature": 0.7
+}`,
+        completions: `{
+  "prompt": "What is machine learning?",
+  "max_tokens": 256,
+  "temperature": 0.7,
+  "top_p": 0.9
+}`,
+        embeddings: `{
+  "input": [
+    "Example text to embed"
+  ]
+}`,
+        dataframe_split: `{
+  "dataframe_split": {
+    "columns": ["feature1", "feature2"],
+    "data": [[1.0, 2.0], [3.0, 4.0]]
+  }
+}`,
+        dataframe_records: `{
+  "dataframe_records": [
+    {"feature1": 1.0, "feature2": 2.0}
+  ]
+}`,
+        inputs: `{
+  "inputs": {
+    "tensor1": [1, 2, 3]
+  }
+}`,
+        instances: `{
+  "instances": [
+    {"tensor1": 1}
+  ]
+}`,
+    };
+    return examples[format] || '{}';
+}
+function validateRequestBody(requestBody, detectedFormat) {
+    switch (detectedFormat) {
+        case 'chat':
+            if (!requestBody.messages || !Array.isArray(requestBody.messages)) {
+                throw new Error('Invalid chat format: "messages" array is required');
+            }
+            break;
+        case 'completions':
+            if (!requestBody.prompt) {
+                throw new Error('Invalid completions format: "prompt" is required');
+            }
+            break;
+        case 'embeddings':
+            if (!requestBody.input) {
+                throw new Error('Invalid embeddings format: "input" is required');
+            }
+            break;
+        case 'dataframe_split':
+            if (!requestBody.dataframe_split || !requestBody.dataframe_split.data) {
+                throw new Error('Invalid dataframe_split format: "dataframe_split.data" is required');
+            }
+            break;
+        case 'dataframe_records':
+            if (!requestBody.dataframe_records || !Array.isArray(requestBody.dataframe_records)) {
+                throw new Error('Invalid dataframe_records format: "dataframe_records" array is required');
+            }
+            break;
+        case 'inputs':
+            if (!requestBody.inputs) {
+                throw new Error('Invalid inputs format: "inputs" is required');
+            }
+            break;
+        case 'instances':
+            if (!requestBody.instances || !Array.isArray(requestBody.instances)) {
+                throw new Error('Invalid instances format: "instances" array is required');
+            }
+            break;
+    }
+}
+class Databricks {
+    constructor() {
+        this.description = {
+            displayName: 'Databricks',
+            name: 'databricks',
+            icon: 'file:databricks.svg',
+            group: ['transform'],
+            version: 1,
+            usableAsTool: true,
+            subtitle: '',
+            description: 'Interact with Databricks API',
+            documentationUrl: 'https://docs.databricks.com/aws/en',
+            defaults: {
+                name: 'Databricks',
+            },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: 'databricks',
+                    required: true,
+                },
+            ],
+            requestDefaults: {
+                baseURL: '={{$credentials.host}}',
+                headers: {
+                    Authorization: '=Bearer {{$credentials.token}}',
+                },
+            },
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Genie',
+                            value: 'genie',
+                            description: 'AI-powered data assistant. <a href="https://docs.databricks.com/genie/index.html" target="_blank">Learn more</a>',
+                        },
+                        {
+                            name: 'Databricks SQL',
+                            value: 'databricksSql',
+                            description: 'Execute SQL queries on data warehouses. <a href="https://docs.databricks.com/sql/index.html" target="_blank">Learn more</a>',
+                        },
+                        {
+                            name: 'Unity Catalog',
+                            value: 'unityCatalog',
+                            description: 'Unified governance for data and AI. <a href="https://docs.databricks.com/data-governance/unity-catalog/index.html" target="_blank">Learn more</a>',
+                        },
+                        {
+                            name: 'Model Serving',
+                            value: 'modelServing',
+                            description: 'Deploy and query ML models. <a href="https://docs.databricks.com/machine-learning/model-serving/index.html" target="_blank">Learn more</a>',
+                        },
+                        {
+                            name: 'Files',
+                            value: 'files',
+                            description: 'Manage files in Unity Catalog volumes. <a href="https://docs.databricks.com/api/workspace/files" target="_blank">Learn more</a>',
+                        },
+                        {
+                            name: 'Vector Search',
+                            value: 'vectorSearch',
+                            description: 'Semantic search with vector embeddings. <a href="https://docs.databricks.com/generative-ai/vector-search.html" target="_blank">Learn more</a>',
+                        },
+                    ],
+                    default: 'databricksSql',
+                },
+                resources_1.filesOperations,
+                resources_1.genieOperations,
+                resources_1.unityCatalogOperations,
+                resources_1.databricksSqlOperations,
+                resources_1.modelServingOperations,
+                resources_1.vectorSearchOperations,
+                ...resources_1.filesParameters,
+                ...resources_1.genieParameters,
+                ...resources_1.unityCatalogParameters,
+                ...resources_1.databricksSqlParameters,
+                ...resources_1.modelServingParameters,
+                ...resources_1.vectorSearchParameters,
+            ],
+        };
+        this.methods = {
+            listSearch: {
+                async getWarehouses(filter) {
+                    var _a;
+                    const credentials = await this.getCredentials('databricks');
+                    const host = credentials.host.replace(/\/$/, '');
+                    const cacheKey = getCacheKey(host, 'warehouses');
+                    let warehouses = [];
+                    const cachedEntry = warehouseCache.get(cacheKey);
+                    if (isCacheValid(cachedEntry)) {
+                        warehouses = cachedEntry.data;
+                    }
+                    else {
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.0/sql/warehouses`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Accept': 'application/json',
+                            },
+                            json: true,
+                        });
+                        warehouses = (_a = response.warehouses) !== null && _a !== void 0 ? _a : [];
+                        warehouseCache.set(cacheKey, {
+                            data: warehouses,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    const allResults = warehouses.map((warehouse) => ({
+                        name: warehouse.name,
+                        value: warehouse.id,
+                        url: `${host}/sql/warehouses/${warehouse.id}`,
+                    }));
+                    if (filter) {
+                        const filterLower = filter.toLowerCase();
+                        const filteredResults = allResults.filter((result) => result.name.toLowerCase().includes(filterLower));
+                        return { results: filteredResults };
+                    }
+                    return { results: allResults };
+                },
+                async getEndpoints(filter) {
+                    var _a;
+                    const credentials = await this.getCredentials('databricks');
+                    const host = credentials.host.replace(/\/$/, '');
+                    const cacheKey = getCacheKey(host, 'endpoints');
+                    let endpoints = [];
+                    const cachedEntry = endpointCache.get(cacheKey);
+                    if (isCacheValid(cachedEntry)) {
+                        endpoints = cachedEntry.data;
+                    }
+                    else {
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.0/serving-endpoints`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Accept': 'application/json',
+                            },
+                            json: true,
+                        });
+                        endpoints = (_a = response.endpoints) !== null && _a !== void 0 ? _a : [];
+                        endpointCache.set(cacheKey, {
+                            data: endpoints,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    const allResults = endpoints.map((endpoint) => {
+                        var _a;
+                        const modelNames = (((_a = endpoint.config) === null || _a === void 0 ? void 0 : _a.served_entities) || [])
+                            .map((entity) => { var _a, _b; return ((_a = entity.external_model) === null || _a === void 0 ? void 0 : _a.name) || ((_b = entity.foundation_model) === null || _b === void 0 ? void 0 : _b.name); })
+                            .filter(Boolean)
+                            .join(', ');
+                        return {
+                            name: endpoint.name,
+                            value: endpoint.name,
+                            url: `${host}/ml/endpoints/${endpoint.name}`,
+                            description: modelNames || 'Model serving endpoint',
+                        };
+                    });
+                    if (filter) {
+                        const filterLower = filter.toLowerCase();
+                        const filteredResults = allResults.filter((result) => {
+                            return (result.name.toLowerCase().includes(filterLower) ||
+                                (result.description && result.description.toLowerCase().includes(filterLower)));
+                        });
+                        return { results: filteredResults };
+                    }
+                    return { results: allResults };
+                },
+                async getCatalogs(filter) {
+                    var _a;
+                    const credentials = await this.getCredentials('databricks');
+                    const host = credentials.host.replace(/\/$/, '');
+                    const cacheKey = getCacheKey(host, 'catalogs');
+                    let catalogs = [];
+                    const cachedEntry = catalogCache.get(cacheKey);
+                    if (isCacheValid(cachedEntry)) {
+                        catalogs = cachedEntry.data;
+                    }
+                    else {
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/catalogs`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Accept': 'application/json',
+                            },
+                            json: true,
+                        });
+                        catalogs = (_a = response.catalogs) !== null && _a !== void 0 ? _a : [];
+                        catalogCache.set(cacheKey, {
+                            data: catalogs,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    const allResults = catalogs.map((catalog) => ({
+                        name: catalog.name,
+                        value: catalog.name,
+                        url: `${host}/explore/data/${catalog.name}`,
+                    }));
+                    if (filter) {
+                        const filterLower = filter.toLowerCase();
+                        const filteredResults = allResults.filter((result) => result.name.toLowerCase().includes(filterLower));
+                        return { results: filteredResults };
+                    }
+                    return { results: allResults };
+                },
+                async getSchemas(filter) {
+                    var _a;
+                    const credentials = await this.getCredentials('databricks');
+                    const host = credentials.host.replace(/\/$/, '');
+                    let selectedCatalog;
+                    try {
+                        const catalogParam = this.getCurrentNodeParameter('catalogName');
+                        selectedCatalog = typeof catalogParam === 'object' ? catalogParam.value : catalogParam;
+                        if (selectedCatalog) {
+                            selectedCatalog = selectedCatalog.trim();
+                            if (selectedCatalog === '') {
+                                selectedCatalog = undefined;
+                            }
+                        }
+                    }
+                    catch (e) {
+                        selectedCatalog = undefined;
+                    }
+                    let allSchemas = [];
+                    if (selectedCatalog) {
+                        const cacheKey = `${getCacheKey(host, 'schemas')}:${selectedCatalog}`;
+                        const cachedEntry = schemaCache.get(cacheKey);
+                        if (isCacheValid(cachedEntry)) {
+                            allSchemas = cachedEntry.data;
+                        }
+                        else {
+                            try {
+                                const schemasResponse = await this.helpers.httpRequest({
+                                    method: 'GET',
+                                    url: `${host}/api/2.1/unity-catalog/schemas?catalog_name=${selectedCatalog}`,
+                                    headers: {
+                                        Authorization: `Bearer ${credentials.token}`,
+                                        'Accept': 'application/json',
+                                    },
+                                    json: true,
+                                });
+                                const schemas = (_a = schemasResponse.schemas) !== null && _a !== void 0 ? _a : [];
+                                schemas.forEach((schema) => {
+                                    allSchemas.push({
+                                        name: schema.name,
+                                        value: schema.name,
+                                        url: `${host}/explore/data/${selectedCatalog}/${schema.name}`,
+                                    });
+                                });
+                                schemaCache.set(cacheKey, {
+                                    data: allSchemas,
+                                    timestamp: Date.now(),
+                                });
+                            }
+                            catch (e) {
+                                return {
+                                    results: [{
+                                            name: `Error loading schemas for catalog: ${selectedCatalog}`,
+                                            value: '',
+                                        }]
+                                };
+                            }
+                        }
+                    }
+                    else {
+                        return {
+                            results: [{
+                                    name: 'Please select a catalog first',
+                                    value: '',
+                                }]
+                        };
+                    }
+                    if (filter) {
+                        const filterLower = filter.toLowerCase();
+                        const filteredResults = allSchemas.filter((result) => result.name.toLowerCase().includes(filterLower));
+                        return { results: filteredResults };
+                    }
+                    return { results: allSchemas };
+                },
+                async getVolumes(filter) {
+                    var _a, _b, _c;
+                    const credentials = await this.getCredentials('databricks');
+                    const host = credentials.host.replace(/\/$/, '');
+                    const cacheKey = getCacheKey(host, 'volumes');
+                    let allVolumes = [];
+                    const cachedEntry = volumeCache.get(cacheKey);
+                    if (isCacheValid(cachedEntry)) {
+                        allVolumes = cachedEntry.data;
+                    }
+                    else {
+                        const catalogsResponse = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/catalogs`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Accept': 'application/json',
+                            },
+                            json: true,
+                        });
+                        const catalogs = (_a = catalogsResponse.catalogs) !== null && _a !== void 0 ? _a : [];
+                        for (const catalog of catalogs) {
+                            try {
+                                const schemasResponse = await this.helpers.httpRequest({
+                                    method: 'GET',
+                                    url: `${host}/api/2.1/unity-catalog/schemas?catalog_name=${catalog.name}`,
+                                    headers: {
+                                        Authorization: `Bearer ${credentials.token}`,
+                                        'Accept': 'application/json',
+                                    },
+                                    json: true,
+                                });
+                                const schemas = (_b = schemasResponse.schemas) !== null && _b !== void 0 ? _b : [];
+                                for (const schema of schemas) {
+                                    try {
+                                        const volumesResponse = await this.helpers.httpRequest({
+                                            method: 'GET',
+                                            url: `${host}/api/2.1/unity-catalog/volumes?catalog_name=${catalog.name}&schema_name=${schema.name}`,
+                                            headers: {
+                                                Authorization: `Bearer ${credentials.token}`,
+                                                'Accept': 'application/json',
+                                            },
+                                            json: true,
+                                        });
+                                        const volumes = (_c = volumesResponse.volumes) !== null && _c !== void 0 ? _c : [];
+                                        volumes.forEach((volume) => {
+                                            const fullPath = `${catalog.name}.${schema.name}.${volume.name}`;
+                                            allVolumes.push({
+                                                name: fullPath,
+                                                value: fullPath,
+                                                description: `${catalog.name} / ${schema.name}${volume.volume_type ? ` (${volume.volume_type})` : ''}`,
+                                                url: `${host}/explore/data/${catalog.name}/${schema.name}/${volume.name}`,
+                                            });
+                                        });
+                                    }
+                                    catch (e) {
+                                    }
+                                }
+                            }
+                            catch (e) {
+                            }
+                        }
+                        volumeCache.set(cacheKey, {
+                            data: allVolumes,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    if (filter) {
+                        const filterLower = filter.toLowerCase();
+                        const filteredResults = allVolumes.filter((result) => result.name.toLowerCase().includes(filterLower) ||
+                            result.description.toLowerCase().includes(filterLower));
+                        return { results: filteredResults };
+                    }
+                    return { results: allVolumes };
+                },
+                async getTables(filter) {
+                    var _a, _b, _c;
+                    const credentials = await this.getCredentials('databricks');
+                    const host = credentials.host.replace(/\/$/, '');
+                    const cacheKey = getCacheKey(host, 'tables');
+                    let allTables = [];
+                    const cachedEntry = tableCache.get(cacheKey);
+                    if (isCacheValid(cachedEntry)) {
+                        allTables = cachedEntry.data;
+                    }
+                    else {
+                        const catalogsResponse = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/catalogs`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Accept': 'application/json',
+                            },
+                            json: true,
+                        });
+                        const catalogs = (_a = catalogsResponse.catalogs) !== null && _a !== void 0 ? _a : [];
+                        for (const catalog of catalogs) {
+                            try {
+                                const schemasResponse = await this.helpers.httpRequest({
+                                    method: 'GET',
+                                    url: `${host}/api/2.1/unity-catalog/schemas?catalog_name=${catalog.name}`,
+                                    headers: {
+                                        Authorization: `Bearer ${credentials.token}`,
+                                        'Accept': 'application/json',
+                                    },
+                                    json: true,
+                                });
+                                const schemas = (_b = schemasResponse.schemas) !== null && _b !== void 0 ? _b : [];
+                                for (const schema of schemas) {
+                                    try {
+                                        const tablesResponse = await this.helpers.httpRequest({
+                                            method: 'GET',
+                                            url: `${host}/api/2.1/unity-catalog/tables?catalog_name=${catalog.name}&schema_name=${schema.name}`,
+                                            headers: {
+                                                Authorization: `Bearer ${credentials.token}`,
+                                                'Accept': 'application/json',
+                                            },
+                                            json: true,
+                                        });
+                                        const tables = (_c = tablesResponse.tables) !== null && _c !== void 0 ? _c : [];
+                                        tables.forEach((table) => {
+                                            const fullPath = `${catalog.name}.${schema.name}.${table.name}`;
+                                            allTables.push({
+                                                name: fullPath,
+                                                value: fullPath,
+                                                description: `${catalog.name} / ${schema.name}${table.table_type ? ` (${table.table_type})` : ''}`,
+                                                url: `${host}/explore/data/${catalog.name}/${schema.name}/${table.name}`,
+                                            });
+                                        });
+                                    }
+                                    catch (e) {
+                                    }
+                                }
+                            }
+                            catch (e) {
+                            }
+                        }
+                        tableCache.set(cacheKey, {
+                            data: allTables,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    if (filter) {
+                        const filterLower = filter.toLowerCase();
+                        const filteredResults = allTables.filter((result) => result.name.toLowerCase().includes(filterLower) ||
+                            result.description.toLowerCase().includes(filterLower));
+                        return { results: filteredResults };
+                    }
+                    return { results: allTables };
+                },
+                async getFunctions(filter) {
+                    var _a, _b, _c;
+                    const credentials = await this.getCredentials('databricks');
+                    const host = credentials.host.replace(/\/$/, '');
+                    const cacheKey = getCacheKey(host, 'functions');
+                    let allFunctions = [];
+                    const cachedEntry = functionCache.get(cacheKey);
+                    if (isCacheValid(cachedEntry)) {
+                        allFunctions = cachedEntry.data;
+                    }
+                    else {
+                        const catalogsResponse = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/catalogs`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Accept': 'application/json',
+                            },
+                            json: true,
+                        });
+                        const catalogs = (_a = catalogsResponse.catalogs) !== null && _a !== void 0 ? _a : [];
+                        for (const catalog of catalogs) {
+                            try {
+                                const schemasResponse = await this.helpers.httpRequest({
+                                    method: 'GET',
+                                    url: `${host}/api/2.1/unity-catalog/schemas?catalog_name=${catalog.name}`,
+                                    headers: {
+                                        Authorization: `Bearer ${credentials.token}`,
+                                        'Accept': 'application/json',
+                                    },
+                                    json: true,
+                                });
+                                const schemas = (_b = schemasResponse.schemas) !== null && _b !== void 0 ? _b : [];
+                                for (const schema of schemas) {
+                                    try {
+                                        const functionsResponse = await this.helpers.httpRequest({
+                                            method: 'GET',
+                                            url: `${host}/api/2.1/unity-catalog/functions?catalog_name=${catalog.name}&schema_name=${schema.name}`,
+                                            headers: {
+                                                Authorization: `Bearer ${credentials.token}`,
+                                                'Accept': 'application/json',
+                                            },
+                                            json: true,
+                                        });
+                                        const functions = (_c = functionsResponse.functions) !== null && _c !== void 0 ? _c : [];
+                                        functions.forEach((func) => {
+                                            const fullPath = `${catalog.name}.${schema.name}.${func.name}`;
+                                            allFunctions.push({
+                                                name: fullPath,
+                                                value: fullPath,
+                                                description: `${catalog.name} / ${schema.name}${func.data_type ? ` → ${func.data_type}` : ''}`,
+                                                url: `${host}/explore/data/${catalog.name}/${schema.name}/${func.name}`,
+                                            });
+                                        });
+                                    }
+                                    catch (e) {
+                                    }
+                                }
+                            }
+                            catch (e) {
+                            }
+                        }
+                        functionCache.set(cacheKey, {
+                            data: allFunctions,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    if (filter) {
+                        const filterLower = filter.toLowerCase();
+                        const filteredResults = allFunctions.filter((result) => result.name.toLowerCase().includes(filterLower) ||
+                            result.description.toLowerCase().includes(filterLower));
+                        return { results: filteredResults };
+                    }
+                    return { results: allFunctions };
+                },
+            },
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const items = this.getInputData();
+        const returnData = [];
+        this.logger.debug(`Starting execution with ${items.length} items`);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                this.logger.debug(`Processing item ${i + 1}/${items.length}`);
+                const resource = this.getNodeParameter('resource', i);
+                const operation = this.getNodeParameter('operation', i);
+                this.logger.debug('Node parameters', {
+                    resource,
+                    operation,
+                    itemIndex: i
+                });
+                if (resource === 'files' && operation === 'uploadFile') {
+                    const dataFieldName = this.getNodeParameter('dataFieldName', i);
+                    const volumePath = this.getNodeParameter('volumePath', i);
+                    const filePath = this.getNodeParameter('filePath', i);
+                    const parts = volumePath.split('.');
+                    if (parts.length !== 3) {
+                        throw new Error('Volume path must be in format: catalog.schema.volume (e.g., main.default.my_volume)');
+                    }
+                    const [catalog, schema, volume] = parts;
+                    this.logger.debug('File upload parameters', {
+                        dataFieldName,
+                        volumePath,
+                        catalog,
+                        schema,
+                        volume,
+                        filePath
+                    });
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host;
+                    const binaryData = await this.helpers.getBinaryDataBuffer(i, dataFieldName);
+                    this.logger.debug('Starting file upload', {
+                        host,
+                        filePath,
+                        dataSize: binaryData.length
+                    });
+                    await this.helpers.httpRequest({
+                        method: 'PUT',
+                        url: `${host}/api/2.0/fs/files/Volumes/${catalog}/${schema}/${volume}/${filePath}`,
+                        body: binaryData,
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                            'Content-Type': ((_b = (_a = items[i].binary) === null || _a === void 0 ? void 0 : _a[dataFieldName]) === null || _b === void 0 ? void 0 : _b.mimeType) || 'application/octet-stream',
+                        },
+                        encoding: 'arraybuffer',
+                    });
+                    this.logger.debug('File upload successful', { filePath });
+                    returnData.push({
+                        json: {
+                            success: true,
+                            message: `File uploaded successfully to ${filePath}`,
+                        },
+                    });
+                }
+                else if (resource === 'files' && operation === 'downloadFile') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const volumePath = this.getNodeParameter('volumePath', i);
+                    const filePath = this.getNodeParameter('filePath', i);
+                    const parts = volumePath.split('.');
+                    if (parts.length !== 3) {
+                        throw new Error('Volume path must be in format: catalog.schema.volume (e.g., main.default.my_volume)');
+                    }
+                    const [catalog, schema, volume] = parts;
+                    this.logger.debug('Downloading file', {
+                        volumePath,
+                        catalog,
+                        schema,
+                        volume,
+                        filePath,
+                    });
+                    const downloadUrl = `${host}/api/2.0/fs/files/Volumes/${catalog}/${schema}/${volume}/${filePath}`;
+                    try {
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: downloadUrl,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            encoding: 'arraybuffer',
+                            returnFullResponse: true,
+                        });
+                        const fileName = filePath.split('/').pop() || 'downloaded-file';
+                        let contentType = response.headers['content-type'];
+                        if (!contentType || contentType === 'application/octet-stream') {
+                            const detectedType = mime_types_1.default.lookup(fileName);
+                            contentType = detectedType || 'application/octet-stream';
+                        }
+                        const buffer = Buffer.from(response.body);
+                        this.logger.debug('File downloaded successfully', {
+                            fileName,
+                            size: buffer.length,
+                            contentType,
+                        });
+                        returnData.push({
+                            json: {
+                                fileName,
+                                size: buffer.length,
+                                contentType,
+                                catalog,
+                                schema,
+                                volume,
+                                filePath,
+                            },
+                            binary: {
+                                data: {
+                                    data: buffer.toString('base64'),
+                                    mimeType: contentType,
+                                    fileName,
+                                },
+                            },
+                            pairedItem: { item: i },
+                        });
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({
+                                json: {
+                                    error: error.message,
+                                    catalog,
+                                    schema,
+                                    volume,
+                                    filePath,
+                                },
+                                pairedItem: { item: i },
+                            });
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                }
+                else if (resource === 'files' && operation === 'deleteFile') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const volumePath = this.getNodeParameter('volumePath', i);
+                    const filePath = this.getNodeParameter('filePath', i);
+                    const parts = volumePath.split('.');
+                    if (parts.length !== 3) {
+                        throw new Error('Volume path must be in format: catalog.schema.volume (e.g., main.default.my_volume)');
+                    }
+                    const [catalog, schema, volume] = parts;
+                    await this.helpers.httpRequest({
+                        method: 'DELETE',
+                        url: `${host}/api/2.0/fs/files/Volumes/${catalog}/${schema}/${volume}/${filePath}`,
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                        },
+                        json: true,
+                    });
+                    returnData.push({
+                        json: {
+                            success: true,
+                            message: `File deleted successfully: ${filePath}`,
+                            volumePath,
+                            filePath,
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (resource === 'files' && operation === 'getFileInfo') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const volumePath = this.getNodeParameter('volumePath', i);
+                    const filePath = this.getNodeParameter('filePath', i);
+                    const parts = volumePath.split('.');
+                    if (parts.length !== 3) {
+                        throw new Error('Volume path must be in format: catalog.schema.volume (e.g., main.default.my_volume)');
+                    }
+                    const [catalog, schema, volume] = parts;
+                    const response = await this.helpers.httpRequest({
+                        method: 'HEAD',
+                        url: `${host}/api/2.0/fs/files/Volumes/${catalog}/${schema}/${volume}/${filePath}`,
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                        },
+                        returnFullResponse: true,
+                    });
+                    returnData.push({
+                        json: {
+                            volumePath,
+                            filePath,
+                            headers: response.headers,
+                            contentLength: response.headers['content-length'],
+                            contentType: response.headers['content-type'],
+                            lastModified: response.headers['last-modified'],
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (resource === 'files' && operation === 'listDirectory') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const volumePath = this.getNodeParameter('volumePath', i);
+                    const directoryPath = this.getNodeParameter('directoryPath', i);
+                    const additionalFields = this.getNodeParameter('additionalFields', i, {});
+                    const parts = volumePath.split('.');
+                    if (parts.length !== 3) {
+                        throw new Error('Volume path must be in format: catalog.schema.volume (e.g., main.default.my_volume)');
+                    }
+                    const [catalog, schema, volume] = parts;
+                    const queryParams = {};
+                    if (additionalFields.pageSize) {
+                        queryParams.page_size = additionalFields.pageSize;
+                    }
+                    if (additionalFields.pageToken) {
+                        queryParams.page_token = additionalFields.pageToken;
+                    }
+                    const response = await this.helpers.httpRequest({
+                        method: 'GET',
+                        url: `${host}/api/2.0/fs/directories/Volumes/${catalog}/${schema}/${volume}/${directoryPath}`,
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                        },
+                        qs: queryParams,
+                        json: true,
+                    });
+                    returnData.push({
+                        json: response,
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (resource === 'files' && operation === 'createDirectory') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const volumePath = this.getNodeParameter('volumePath', i);
+                    const directoryPath = this.getNodeParameter('directoryPath', i);
+                    const parts = volumePath.split('.');
+                    if (parts.length !== 3) {
+                        throw new Error('Volume path must be in format: catalog.schema.volume (e.g., main.default.my_volume)');
+                    }
+                    const [catalog, schema, volume] = parts;
+                    await this.helpers.httpRequest({
+                        method: 'PUT',
+                        url: `${host}/api/2.0/fs/directories/Volumes/${catalog}/${schema}/${volume}/${directoryPath}`,
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                        },
+                        json: true,
+                    });
+                    returnData.push({
+                        json: {
+                            success: true,
+                            message: `Directory created successfully: ${directoryPath}`,
+                            volumePath,
+                            directoryPath,
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (resource === 'files' && operation === 'deleteDirectory') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const volumePath = this.getNodeParameter('volumePath', i);
+                    const directoryPath = this.getNodeParameter('directoryPath', i);
+                    const parts = volumePath.split('.');
+                    if (parts.length !== 3) {
+                        throw new Error('Volume path must be in format: catalog.schema.volume (e.g., main.default.my_volume)');
+                    }
+                    const [catalog, schema, volume] = parts;
+                    await this.helpers.httpRequest({
+                        method: 'DELETE',
+                        url: `${host}/api/2.0/fs/directories/Volumes/${catalog}/${schema}/${volume}/${directoryPath}`,
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                        },
+                        json: true,
+                    });
+                    returnData.push({
+                        json: {
+                            success: true,
+                            message: `Directory deleted successfully: ${directoryPath}`,
+                            volumePath,
+                            directoryPath,
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (resource === 'genie') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host;
+                    let url;
+                    let method;
+                    let body;
+                    switch (operation) {
+                        case 'createMessage':
+                            url = `${host}/api/2.0/genie/spaces/${this.getNodeParameter('spaceId', i)}/conversations/${this.getNodeParameter('conversationId', i)}/messages`;
+                            method = 'POST';
+                            body = {
+                                content: this.getNodeParameter('message', i),
+                            };
+                            break;
+                        case 'getMessage':
+                            url = `${host}/api/2.0/genie/spaces/${this.getNodeParameter('spaceId', i)}/conversations/${this.getNodeParameter('conversationId', i)}/messages/${this.getNodeParameter('messageId', i)}`;
+                            method = 'GET';
+                            break;
+                        case 'getQueryResults':
+                            url = `${host}/api/2.0/genie/spaces/${this.getNodeParameter('spaceId', i)}/conversations/${this.getNodeParameter('conversationId', i)}/messages/${this.getNodeParameter('messageId', i)}/attachments/${this.getNodeParameter('attachmentId', i)}/query-result`;
+                            method = 'GET';
+                            break;
+                        case 'executeMessageQuery':
+                            url = `${host}/api/2.0/genie/spaces/${this.getNodeParameter('spaceId', i)}/conversations/${this.getNodeParameter('conversationId', i)}/messages/${this.getNodeParameter('messageId', i)}/attachments/${this.getNodeParameter('attachmentId', i)}/execute-query`;
+                            method = 'POST';
+                            break;
+                        case 'getSpace':
+                            url = `${host}/api/2.0/genie/spaces/${this.getNodeParameter('spaceId', i)}`;
+                            method = 'GET';
+                            break;
+                        case 'startConversation':
+                            const spaceId = this.getNodeParameter('spaceId', i);
+                            url = `${host}/api/2.0/genie/spaces/${spaceId}/start-conversation`;
+                            method = 'POST';
+                            body = {
+                                content: this.getNodeParameter('initialMessage', i),
+                            };
+                            break;
+                        default:
+                            throw new Error(`Unsupported Genie operation: ${operation}`);
+                    }
+                    this.logger.debug('Making Genie API request', {
+                        url,
+                        method,
+                        body: JSON.stringify(body, null, 2)
+                    });
+                    const response = await this.helpers.httpRequest({
+                        method,
+                        url,
+                        body,
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                    });
+                    this.logger.debug('Genie API response received', {
+                        statusCode: response.statusCode,
+                        response: JSON.stringify(response, null, 2)
+                    });
+                    returnData.push({ json: response });
+                }
+                else if (resource === 'databricksSql' && operation === 'executeQuery') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const warehouseId = this.getNodeParameter('warehouseId', i);
+                    const query = this.getNodeParameter('query', i);
+                    this.logger.debug('Executing SQL query', {
+                        warehouseId: warehouseId.value,
+                        query: query.substring(0, 100),
+                    });
+                    const executeResponse = await this.helpers.httpRequest({
+                        method: 'POST',
+                        url: `${host}/api/2.0/sql/statements`,
+                        body: {
+                            warehouse_id: warehouseId.value,
+                            statement: query,
+                        },
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                    });
+                    const statementId = executeResponse.statement_id;
+                    this.logger.debug('Query submitted', { statementId });
+                    let status = executeResponse.status.state;
+                    let queryResult = executeResponse;
+                    const maxRetries = 60;
+                    let retries = 0;
+                    while (status !== 'SUCCEEDED' && status !== 'FAILED' && status !== 'CANCELED' && retries < maxRetries) {
+                        await new Promise(resolve => setTimeout(resolve, 5000));
+                        queryResult = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.0/sql/statements/${statementId}`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Accept': 'application/json',
+                            },
+                            json: true,
+                        });
+                        status = queryResult.status.state;
+                        retries++;
+                        this.logger.debug('Polling query status', {
+                            statementId,
+                            status,
+                            attempt: retries,
+                        });
+                    }
+                    if (status === 'FAILED' || status === 'CANCELED') {
+                        throw new Error(`Query ${status.toLowerCase()}: ${JSON.stringify(queryResult.status)}`);
+                    }
+                    if (retries >= maxRetries) {
+                        throw new Error('Query execution timeout - exceeded maximum wait time');
+                    }
+                    const allRows = [];
+                    let chunkIndex = 0;
+                    const totalChunks = ((_c = queryResult.manifest) === null || _c === void 0 ? void 0 : _c.total_chunk_count) || 0;
+                    this.logger.debug('Starting chunk collection', {
+                        statementId,
+                        totalChunks,
+                    });
+                    if ((_d = queryResult.result) === null || _d === void 0 ? void 0 : _d.data_array) {
+                        allRows.push(...queryResult.result.data_array);
+                        chunkIndex = 1;
+                    }
+                    while (chunkIndex < totalChunks) {
+                        const chunkResponse = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.0/sql/statements/${statementId}/result/chunks/${chunkIndex}`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Accept': 'application/json',
+                            },
+                            json: true,
+                        });
+                        if (chunkResponse.data_array) {
+                            allRows.push(...chunkResponse.data_array);
+                        }
+                        chunkIndex++;
+                        this.logger.debug('Fetched chunk', {
+                            statementId,
+                            chunkIndex,
+                            totalChunks,
+                            rowsCollected: allRows.length,
+                        });
+                    }
+                    const columns = ((_f = (_e = queryResult.manifest) === null || _e === void 0 ? void 0 : _e.schema) === null || _f === void 0 ? void 0 : _f.columns) || [];
+                    const formattedResults = allRows.map(row => {
+                        const obj = {};
+                        columns.forEach((col, idx) => {
+                            obj[col.name] = row[idx];
+                        });
+                        return obj;
+                    });
+                    this.logger.debug('Query execution complete', {
+                        statementId,
+                        totalRows: formattedResults.length,
+                        totalChunks,
+                    });
+                    formattedResults.forEach(row => {
+                        returnData.push({
+                            json: row,
+                            pairedItem: { item: i },
+                        });
+                    });
+                }
+                else if (resource === 'modelServing' && operation === 'queryEndpoint') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const endpointName = this.getNodeParameter('endpointName', i, '', { extractValue: true });
+                    const requestBody = this.getNodeParameter('requestBody', i);
+                    this.logger.debug('Fetching endpoint schema for auto-detection', { endpointName });
+                    let detectedFormat = 'generic';
+                    let invocationUrl = `${host}/serving-endpoints/${endpointName}/invocations`;
+                    let exampleRequestBody = '';
+                    try {
+                        const openApiResponse = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.0/serving-endpoints/${endpointName}/openapi`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Accept': 'application/json',
+                            },
+                            json: true,
+                        });
+                        if (openApiResponse && openApiResponse.length > 0) {
+                            const schemaInfo = detectInputFormat(openApiResponse[0]);
+                            detectedFormat = schemaInfo.format;
+                            invocationUrl = schemaInfo.invocationUrl;
+                            exampleRequestBody = generateExampleFromSchema(schemaInfo.schema, detectedFormat);
+                            this.logger.debug('Auto-detected input format and URL', {
+                                endpointName,
+                                format: detectedFormat,
+                                requiredFields: schemaInfo.requiredFields,
+                                invocationUrl,
+                                exampleRequestBody,
+                            });
+                            try {
+                                validateRequestBody(requestBody, detectedFormat);
+                            }
+                            catch (validationError) {
+                                throw new Error(`${validationError.message}\n\n` +
+                                    `Detected format: ${detectedFormat}\n\n` +
+                                    `Example request body:\n${exampleRequestBody}\n\n` +
+                                    `Your request body:\n${JSON.stringify(requestBody, null, 2)}`);
+                            }
+                            this.logger.debug('Request body validated successfully', {
+                                endpointName,
+                                format: detectedFormat,
+                            });
+                        }
+                    }
+                    catch (error) {
+                        if (error.message && error.message.includes('Detected format:')) {
+                            throw error;
+                        }
+                        this.logger.warn('Could not fetch or parse endpoint schema, using default URL', {
+                            endpointName,
+                            error: error.message,
+                            defaultUrl: invocationUrl,
+                        });
+                        if (!exampleRequestBody) {
+                            exampleRequestBody = generateExampleFromSchema(null, detectedFormat);
+                        }
+                    }
+                    this.logger.debug('Querying model serving endpoint', {
+                        endpointName,
+                        detectedFormat,
+                        invocationUrl,
+                        requestBody: JSON.stringify(requestBody, null, 2),
+                    });
+                    try {
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: invocationUrl,
+                            body: requestBody,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                        });
+                        this.logger.debug('Model serving response received', {
+                            endpointName,
+                            detectedFormat,
+                            invocationUrl,
+                        });
+                        returnData.push({
+                            json: {
+                                ...response,
+                                _metadata: {
+                                    endpoint: endpointName,
+                                    detectedFormat,
+                                    invocationUrl,
+                                }
+                            },
+                            pairedItem: { item: i }
+                        });
+                    }
+                    catch (apiError) {
+                        if (apiError.statusCode === 400) {
+                            if (!exampleRequestBody) {
+                                exampleRequestBody = generateExampleFromSchema(null, detectedFormat);
+                            }
+                            const errorDetails = ((_g = apiError.response) === null || _g === void 0 ? void 0 : _g.body) || apiError.message || 'Bad Request';
+                            throw new Error(`API Error: 400 Bad Request\n\n` +
+                                `The endpoint rejected your request. This usually means the request body format is incorrect.\n\n` +
+                                `Error details: ${JSON.stringify(errorDetails, null, 2)}\n\n` +
+                                `Detected format: ${detectedFormat}\n\n` +
+                                `Expected request body format:\n${exampleRequestBody}\n\n` +
+                                `Your request body:\n${JSON.stringify(requestBody, null, 2)}`);
+                        }
+                        throw apiError;
+                    }
+                }
+                else if (resource === 'unityCatalog') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const extractValue = (param) => {
+                        if (typeof param === 'object' && param !== null) {
+                            return param.value || '';
+                        }
+                        return param || '';
+                    };
+                    let response;
+                    if (operation === 'createVolume') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i));
+                        const schemaName = extractValue(this.getNodeParameter('schemaName', i));
+                        const volumeName = this.getNodeParameter('volumeName', i);
+                        const volumeType = this.getNodeParameter('volumeType', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i, {});
+                        const body = {
+                            catalog_name: catalogName,
+                            schema_name: schemaName,
+                            name: volumeName,
+                            volume_type: volumeType,
+                        };
+                        if (additionalFields.comment) {
+                            body.comment = additionalFields.comment;
+                        }
+                        if (additionalFields.storage_location) {
+                            body.storage_location = additionalFields.storage_location;
+                        }
+                        response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${host}/api/2.1/unity-catalog/volumes`,
+                            body,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'deleteVolume') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i));
+                        const schemaName = extractValue(this.getNodeParameter('schemaName', i));
+                        const volumeName = this.getNodeParameter('volumeName', i);
+                        const fullName = `${catalogName}.${schemaName}.${volumeName}`;
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${host}/api/2.1/unity-catalog/volumes/${fullName}`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                        response = {
+                            success: true,
+                            message: 'Volume deleted successfully',
+                            volumeName: fullName,
+                        };
+                    }
+                    else if (operation === 'getVolume') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i));
+                        const schemaName = extractValue(this.getNodeParameter('schemaName', i));
+                        const volumeName = this.getNodeParameter('volumeName', i);
+                        const fullName = `${catalogName}.${schemaName}.${volumeName}`;
+                        response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/volumes/${fullName}`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'listVolumes') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i, ''));
+                        const schemaName = extractValue(this.getNodeParameter('schemaName', i, ''));
+                        const qs = {};
+                        if (catalogName)
+                            qs.catalog_name = catalogName;
+                        if (schemaName)
+                            qs.schema_name = schemaName;
+                        response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/volumes`,
+                            qs,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'getTable') {
+                        const fullName = extractValue(this.getNodeParameter('fullName', i));
+                        response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/tables/${fullName}`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'listTables') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i, ''));
+                        const schemaName = extractValue(this.getNodeParameter('schemaName', i, ''));
+                        const qs = {};
+                        if (catalogName)
+                            qs.catalog_name = catalogName;
+                        if (schemaName)
+                            qs.schema_name = schemaName;
+                        response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/tables`,
+                            qs,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'createFunction') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i));
+                        const schemaName = extractValue(this.getNodeParameter('schemaName', i));
+                        const functionName = this.getNodeParameter('functionName', i);
+                        const inputParams = this.getNodeParameter('inputParams', i);
+                        const returnType = this.getNodeParameter('returnType', i);
+                        const routineBody = this.getNodeParameter('routineBody', i);
+                        response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${host}/api/2.1/unity-catalog/functions`,
+                            body: {
+                                name: functionName,
+                                catalog_name: catalogName,
+                                schema_name: schemaName,
+                                input_params: inputParams,
+                                data_type: returnType,
+                                routine_body: routineBody,
+                            },
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'deleteFunction') {
+                        const fullName = extractValue(this.getNodeParameter('fullName', i));
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${host}/api/2.1/unity-catalog/functions/${fullName}`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                        response = {
+                            success: true,
+                            message: 'Function deleted successfully',
+                            functionName: fullName,
+                        };
+                    }
+                    else if (operation === 'getFunction') {
+                        const fullName = extractValue(this.getNodeParameter('fullName', i));
+                        response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/functions/${fullName}`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'listFunctions') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i, ''));
+                        const schemaName = extractValue(this.getNodeParameter('schemaName', i, ''));
+                        const qs = {};
+                        if (catalogName)
+                            qs.catalog_name = catalogName;
+                        if (schemaName)
+                            qs.schema_name = schemaName;
+                        response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/functions`,
+                            qs,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'createCatalog') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i));
+                        const comment = this.getNodeParameter('comment', i, '');
+                        const body = {
+                            name: catalogName,
+                        };
+                        if (comment) {
+                            body.comment = comment;
+                        }
+                        response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${host}/api/2.1/unity-catalog/catalogs`,
+                            body,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'getCatalog') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i));
+                        response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/catalogs/${catalogName}`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'updateCatalog') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i));
+                        const comment = this.getNodeParameter('comment', i, '');
+                        response = await this.helpers.httpRequest({
+                            method: 'PATCH',
+                            url: `${host}/api/2.1/unity-catalog/catalogs/${catalogName}`,
+                            body: {
+                                comment,
+                            },
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'deleteCatalog') {
+                        const catalogName = extractValue(this.getNodeParameter('catalogName', i));
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${host}/api/2.1/unity-catalog/catalogs/${catalogName}`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                        response = {
+                            success: true,
+                            message: 'Catalog deleted successfully',
+                            catalogName: catalogName,
+                        };
+                    }
+                    else if (operation === 'listCatalogs') {
+                        response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${host}/api/2.1/unity-catalog/catalogs`,
+                            headers: {
+                                Authorization: `Bearer ${credentials.token}`,
+                            },
+                            json: true,
+                        });
+                    }
+                    returnData.push({
+                        json: response || {},
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (resource === 'vectorSearch' && operation === 'queryIndex') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const indexName = this.getNodeParameter('indexName', i);
+                    const queryType = this.getNodeParameter('queryType', i);
+                    const searchMode = this.getNodeParameter('searchMode', i, 'HYBRID');
+                    const numResults = this.getNodeParameter('numResults', i, 10);
+                    const columnsStr = this.getNodeParameter('columns', i, '');
+                    const options = this.getNodeParameter('options', i, {});
+                    const enableReranking = this.getNodeParameter('enableReranking', i, false);
+                    const rerankerModel = enableReranking ? this.getNodeParameter('rerankerModel', i) : undefined;
+                    const columnsToRerank = enableReranking ? this.getNodeParameter('columnsToRerank', i) : undefined;
+                    const body = {
+                        num_results: numResults,
+                        query_type: searchMode,
+                    };
+                    if (queryType === 'text') {
+                        body.query_text = this.getNodeParameter('queryText', i);
+                    }
+                    else {
+                        body.query_vector = this.getNodeParameter('queryVector', i);
+                    }
+                    body.columns = columnsStr.split(',').map(col => col.trim()).filter(Boolean);
+                    if (options.filterExpression) {
+                        body.filters_json = options.filterExpression;
+                    }
+                    if (options.scoreThreshold) {
+                        body.score_threshold = options.scoreThreshold;
+                    }
+                    if (enableReranking) {
+                        body.reranker = {
+                            model: rerankerModel || 'databricks_reranker',
+                            parameters: {
+                                columns_to_rerank: columnsToRerank.split(',').map((col) => col.trim()).filter(Boolean),
+                            },
+                        };
+                    }
+                    this.logger.debug('Querying vector search index', {
+                        indexName,
+                        queryType,
+                        searchMode,
+                        body: JSON.stringify(body, null, 2),
+                    });
+                    const response = await this.helpers.httpRequest({
+                        method: 'POST',
+                        url: `${host}/api/2.0/vector-search/indexes/${indexName}/query`,
+                        body,
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                    });
+                    returnData.push({
+                        json: response,
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (resource === 'vectorSearch' && operation === 'getIndex') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const indexName = this.getNodeParameter('indexName', i);
+                    const response = await this.helpers.httpRequest({
+                        method: 'GET',
+                        url: `${host}/api/2.0/vector-search/indexes/${indexName}`,
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                        },
+                        json: true,
+                    });
+                    returnData.push({
+                        json: response,
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (resource === 'vectorSearch' && operation === 'listIndexes') {
+                    const credentials = (await this.getCredentials('databricks'));
+                    const host = credentials.host.replace(/\/$/, '');
+                    const endpointName = this.getNodeParameter('endpointName', i);
+                    const response = await this.helpers.httpRequest({
+                        method: 'GET',
+                        url: `${host}/api/2.0/vector-search/indexes`,
+                        qs: {
+                            endpoint_name: endpointName,
+                        },
+                        headers: {
+                            Authorization: `Bearer ${credentials.token}`,
+                        },
+                        json: true,
+                    });
+                    returnData.push({
+                        json: response,
+                        pairedItem: { item: i },
+                    });
+                }
+            }
+            catch (error) {
+                const currentResource = this.getNodeParameter('resource', i);
+                const currentOperation = this.getNodeParameter('operation', i);
+                this.logger.error(`Error processing item ${i + 1}`, {
+                    error: error.message,
+                    stack: error.stack,
+                    itemIndex: i,
+                    resource: currentResource,
+                    operation: currentOperation
+                });
+                if (error.response) {
+                    this.logger.error('API Error', {
+                        status: error.response.status,
+                        statusText: error.response.statusText,
+                        data: error.response.data
+                    });
+                    if (this.continueOnFail()) {
+                        returnData.push({
+                            json: {
+                                error: `API Error: ${error.response.status} ${error.response.statusText}`,
+                                details: error.response.data
+                            }
+                        });
+                    }
+                    else {
+                        throw new Error(`API Error: ${error.response.status} ${error.response.statusText}`);
+                    }
+                }
+                else if (error.request) {
+                    this.logger.error('Network Error', {
+                        request: error.request
+                    });
+                    if (this.continueOnFail()) {
+                        returnData.push({
+                            json: {
+                                error: 'Network Error: No response received from server',
+                                details: error.message
+                            }
+                        });
+                    }
+                    else {
+                        throw new Error('Network Error: No response received from server');
+                    }
+                }
+                else {
+                    if (this.continueOnFail()) {
+                        returnData.push({
+                            json: {
+                                error: error.message,
+                                details: error.stack
+                            }
+                        });
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+        }
+        this.logger.debug('Execution completed successfully');
+        return [returnData];
+    }
+}
+exports.Databricks = Databricks;
+//# sourceMappingURL=Databricks.node.js.map