runline 0.1.0

package/dist/plugins/customerIo/src/index.js

@@ -0,0 +1,184 @@
+async function apiRequest(siteId, apiKey, method, url, body) {
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${btoa(`${siteId}:${apiKey}`)}`,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url, opts);
+    if (!res.ok)
+        throw new Error(`Customer.io API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204 || res.headers.get("content-length") === "0")
+        return { success: true };
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json"))
+        return res.json();
+    return { success: true };
+}
+function getConn(ctx) {
+    const cfg = ctx.connection.config;
+    const region = cfg.region ?? "track.customer.io";
+    const isEu = region.includes("-eu");
+    return {
+        siteId: cfg.siteId,
+        trackingApiKey: cfg.trackingApiKey,
+        appApiKey: cfg.appApiKey,
+        trackingBase: `https://${region}/api/v1`,
+        appBase: isEu ? "https://api-eu.customer.io/v1" : "https://api.customer.io/v1",
+    };
+}
+function tracking(ctx, method, endpoint, body) {
+    const { siteId, trackingApiKey, trackingBase } = getConn(ctx);
+    return apiRequest(siteId, trackingApiKey, method, `${trackingBase}${endpoint}`, body);
+}
+function app(ctx, method, endpoint, body) {
+    const { siteId, appApiKey, appBase } = getConn(ctx);
+    return apiRequest(siteId, appApiKey, method, `${appBase}${endpoint}`, body);
+}
+export default function customerIo(rl) {
+    rl.setName("customerIo");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        siteId: { type: "string", required: true, description: "Customer.io Site ID", env: "CUSTOMERIO_SITE_ID" },
+        trackingApiKey: { type: "string", required: true, description: "Tracking API key", env: "CUSTOMERIO_TRACKING_API_KEY" },
+        appApiKey: { type: "string", required: true, description: "App API key (for campaigns)", env: "CUSTOMERIO_APP_API_KEY" },
+        region: { type: "string", required: false, description: "Region: track.customer.io (US, default) or track-eu.customer.io (EU)", default: "track.customer.io" },
+    });
+    // ── Campaign ────────────────────────────────────────
+    rl.registerAction("campaign.get", {
+        description: "Get a campaign by ID",
+        inputSchema: { campaignId: { type: "number", required: true, description: "Campaign ID" } },
+        async execute(input, ctx) {
+            const { campaignId } = input;
+            const data = (await app(ctx, "GET", `/campaigns/${campaignId}`));
+            return data.campaign;
+        },
+    });
+    rl.registerAction("campaign.list", {
+        description: "List all campaigns",
+        async execute(_input, ctx) {
+            const data = (await app(ctx, "GET", "/campaigns"));
+            return data.campaigns;
+        },
+    });
+    rl.registerAction("campaign.getMetrics", {
+        description: "Get campaign metrics",
+        inputSchema: {
+            campaignId: { type: "number", required: true, description: "Campaign ID" },
+            period: { type: "string", required: false, description: "Period: days (default), weeks, months" },
+            steps: { type: "number", required: false, description: "Number of steps/periods" },
+            type: { type: "string", required: false, description: "Metric type: email, webhook, push, slack, urbanAirship" },
+        },
+        async execute(input, ctx) {
+            const { campaignId, period, steps, type } = (input ?? {});
+            let endpoint = `/campaigns/${campaignId}/metrics`;
+            if (period && period !== "days")
+                endpoint += `?period=${period}`;
+            const body = {};
+            if (steps)
+                body.steps = steps;
+            if (type)
+                body.type = type === "urbanAirship" ? "urban_airship" : type;
+            const data = (await app(ctx, "GET", endpoint, body));
+            return data.metric;
+        },
+    });
+    // ── Customer ────────────────────────────────────────
+    rl.registerAction("customer.upsert", {
+        description: "Create or update a customer",
+        inputSchema: {
+            id: { type: "string", required: true, description: "Customer ID (your internal ID)" },
+            email: { type: "string", required: false, description: "Email address" },
+            createdAt: { type: "string", required: false, description: "Created at (ISO 8601)" },
+            attributes: { type: "object", required: false, description: "Custom attributes as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { id, email, createdAt, attributes } = input;
+            const body = {};
+            if (email)
+                body.email = email;
+            if (createdAt)
+                body.created_at = Math.floor(new Date(createdAt).getTime() / 1000);
+            if (attributes)
+                body.data = attributes;
+            await tracking(ctx, "PUT", `/customers/${id}`, body);
+            return { id, ...body };
+        },
+    });
+    rl.registerAction("customer.delete", {
+        description: "Delete a customer",
+        inputSchema: { id: { type: "string", required: true, description: "Customer ID" } },
+        async execute(input, ctx) {
+            const { id } = input;
+            await tracking(ctx, "DELETE", `/customers/${id}`);
+            return { success: true };
+        },
+    });
+    // ── Event ───────────────────────────────────────────
+    rl.registerAction("event.track", {
+        description: "Track an event for a customer",
+        inputSchema: {
+            customerId: { type: "string", required: true, description: "Customer ID" },
+            eventName: { type: "string", required: true, description: "Event name" },
+            type: { type: "string", required: false, description: "Event type (e.g. page)" },
+            data: { type: "object", required: false, description: "Custom event attributes" },
+        },
+        async execute(input, ctx) {
+            const { customerId, eventName, type, data } = input;
+            const body = { name: eventName };
+            const eventData = {};
+            if (type)
+                eventData.type = type;
+            if (data)
+                Object.assign(eventData, data);
+            if (Object.keys(eventData).length > 0)
+                body.data = eventData;
+            await tracking(ctx, "POST", `/customers/${customerId}/events`, body);
+            return { success: true };
+        },
+    });
+    rl.registerAction("event.trackAnonymous", {
+        description: "Track an anonymous event (not tied to a customer)",
+        inputSchema: {
+            eventName: { type: "string", required: true, description: "Event name" },
+            data: { type: "object", required: false, description: "Custom event attributes" },
+        },
+        async execute(input, ctx) {
+            const { eventName, data } = input;
+            const body = { name: eventName };
+            if (data)
+                body.data = data;
+            await tracking(ctx, "POST", "/events", body);
+            return { success: true };
+        },
+    });
+    // ── Segment ─────────────────────────────────────────
+    rl.registerAction("segment.addCustomers", {
+        description: "Add customers to a manual segment",
+        inputSchema: {
+            segmentId: { type: "number", required: true, description: "Segment ID" },
+            customerIds: { type: "array", required: true, description: "Array of customer IDs" },
+        },
+        async execute(input, ctx) {
+            const { segmentId, customerIds } = input;
+            await tracking(ctx, "POST", `/segments/${segmentId}/add_customers`, { ids: customerIds });
+            return { success: true };
+        },
+    });
+    rl.registerAction("segment.removeCustomers", {
+        description: "Remove customers from a manual segment",
+        inputSchema: {
+            segmentId: { type: "number", required: true, description: "Segment ID" },
+            customerIds: { type: "array", required: true, description: "Array of customer IDs" },
+        },
+        async execute(input, ctx) {
+            const { segmentId, customerIds } = input;
+            await tracking(ctx, "POST", `/segments/${segmentId}/remove_customers`, { ids: customerIds });
+            return { success: true };
+        },
+    });
+}

package/dist/plugins/databricks/src/index.js

@@ -0,0 +1,342 @@
+function getConn(ctx) {
+    const host = ctx.connection.config.host.replace(/\/$/, "");
+    const token = ctx.connection.config.accessToken;
+    return { host, token };
+}
+async function api(host, token, method, path, body, qs) {
+    const url = new URL(`${host}${path}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v)
+                url.searchParams.set(k, v);
+        }
+    }
+    const init = { method, headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (res.status === 204 || res.headers.get("content-length") === "0")
+        return { success: true };
+    if (!res.ok)
+        throw new Error(`Databricks error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : { success: true };
+}
+function volumeParts(volumePath) {
+    const parts = volumePath.split(".");
+    if (parts.length !== 3)
+        throw new Error("Volume path must be catalog.schema.volume");
+    return parts;
+}
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+export default function databricks(rl) {
+    rl.setName("databricks");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        host: { type: "string", required: true, description: "Databricks workspace URL, e.g. https://adb-12345.azuredatabricks.net", env: "DATABRICKS_HOST" },
+        accessToken: { type: "string", required: true, description: "Personal access token or OAuth2 token", env: "DATABRICKS_TOKEN" },
+    });
+    // ── Databricks SQL ──────────────────────────────────
+    rl.registerAction("sql.executeQuery", { description: "Execute a SQL query on a warehouse and return results",
+        inputSchema: {
+            warehouseId: { type: "string", required: true, description: "SQL warehouse ID" },
+            query: { type: "string", required: true, description: "SQL statement" },
+            parameters: { type: "object", required: false, description: "Array of {name, value, type?} query parameters" },
+        },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const params = (p.parameters ?? []);
+            const body = { warehouse_id: p.warehouseId, statement: p.query, wait_timeout: "50s", on_wait_timeout: "CONTINUE" };
+            if (params.length > 0)
+                body.parameters = params.map(({ name, value, type }) => type ? { name, value, type } : { name, value });
+            let result = await api(host, token, "POST", "/api/2.0/sql/statements", body);
+            const statementId = result.statement_id;
+            let status = result.status.state;
+            let retries = 0;
+            while (status !== "SUCCEEDED" && status !== "FAILED" && status !== "CANCELED" && retries < 60) {
+                await sleep(5000);
+                result = await api(host, token, "GET", `/api/2.0/sql/statements/${statementId}`);
+                status = result.status.state;
+                retries++;
+            }
+            if (status === "FAILED" || status === "CANCELED")
+                throw new Error(`Query ${status}: ${JSON.stringify(result.status)}`);
+            if (retries >= 60)
+                throw new Error("Query execution timeout");
+            // Collect all chunks
+            const allRows = [];
+            const manifest = result.manifest;
+            const totalChunks = (manifest?.total_chunk_count ?? 0);
+            const resultData = result.result;
+            if (resultData?.data_array) {
+                allRows.push(...resultData.data_array);
+            }
+            let chunkIdx = allRows.length > 0 ? 1 : 0;
+            while (chunkIdx < totalChunks) {
+                const chunk = await api(host, token, "GET", `/api/2.0/sql/statements/${statementId}/result/chunks/${chunkIdx}`);
+                if (chunk.data_array)
+                    allRows.push(...chunk.data_array);
+                chunkIdx++;
+            }
+            // Transform to objects
+            const columns = (manifest?.schema?.columns ?? []);
+            return allRows.map((row) => {
+                const obj = {};
+                columns.forEach((col, idx) => { obj[col.name] = row[idx]; });
+                return obj;
+            });
+        } });
+    // ── Files ───────────────────────────────────────────
+    rl.registerAction("files.createDirectory", { description: "Create a directory in a Unity Catalog volume",
+        inputSchema: { volumePath: { type: "string", required: true, description: "catalog.schema.volume" }, directoryPath: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const [cat, sch, vol] = volumeParts(p.volumePath);
+            await api(host, token, "PUT", `/api/2.0/fs/directories/Volumes/${cat}/${sch}/${vol}/${p.directoryPath}`);
+            return { success: true, directoryPath: p.directoryPath };
+        } });
+    rl.registerAction("files.deleteDirectory", { description: "Delete a directory in a volume",
+        inputSchema: { volumePath: { type: "string", required: true, description: "catalog.schema.volume" }, directoryPath: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const [cat, sch, vol] = volumeParts(p.volumePath);
+            await api(host, token, "DELETE", `/api/2.0/fs/directories/Volumes/${cat}/${sch}/${vol}/${p.directoryPath}`);
+            return { success: true };
+        } });
+    rl.registerAction("files.deleteFile", { description: "Delete a file in a volume",
+        inputSchema: { volumePath: { type: "string", required: true, description: "catalog.schema.volume" }, filePath: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const [cat, sch, vol] = volumeParts(p.volumePath);
+            await api(host, token, "DELETE", `/api/2.0/fs/files/Volumes/${cat}/${sch}/${vol}/${p.filePath}`);
+            return { success: true };
+        } });
+    rl.registerAction("files.getFileInfo", { description: "Get file metadata (content-length, type, last-modified)",
+        inputSchema: { volumePath: { type: "string", required: true, description: "catalog.schema.volume" }, filePath: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const [cat, sch, vol] = volumeParts(p.volumePath);
+            const url = `${host}/api/2.0/fs/files/Volumes/${cat}/${sch}/${vol}/${p.filePath}`;
+            const res = await fetch(url, { method: "HEAD", headers: { Authorization: `Bearer ${token}` } });
+            if (!res.ok)
+                throw new Error(`Databricks error ${res.status}`);
+            return { filePath: p.filePath, contentLength: res.headers.get("content-length"), contentType: res.headers.get("content-type"), lastModified: res.headers.get("last-modified") };
+        } });
+    rl.registerAction("files.listDirectory", { description: "List files in a volume directory",
+        inputSchema: { volumePath: { type: "string", required: true, description: "catalog.schema.volume" }, directoryPath: { type: "string", required: false }, pageSize: { type: "number", required: false }, pageToken: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const [cat, sch, vol] = volumeParts(p.volumePath);
+            const dir = p.directoryPath ? `/${p.directoryPath}` : "";
+            const qs = {};
+            if (p.pageSize)
+                qs.page_size = String(p.pageSize);
+            if (p.pageToken)
+                qs.page_token = p.pageToken;
+            return api(host, token, "GET", `/api/2.0/fs/directories/Volumes/${cat}/${sch}/${vol}${dir}`, undefined, qs);
+        } });
+    // ── Genie ───────────────────────────────────────────
+    rl.registerAction("genie.startConversation", { description: "Start a new Genie conversation",
+        inputSchema: { spaceId: { type: "string", required: true }, initialMessage: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            return api(host, token, "POST", `/api/2.0/genie/spaces/${p.spaceId}/start-conversation`, { content: p.initialMessage });
+        } });
+    rl.registerAction("genie.createMessage", { description: "Send a message in an existing Genie conversation",
+        inputSchema: { spaceId: { type: "string", required: true }, conversationId: { type: "string", required: true }, message: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            return api(host, token, "POST", `/api/2.0/genie/spaces/${p.spaceId}/conversations/${p.conversationId}/messages`, { content: p.message });
+        } });
+    rl.registerAction("genie.getMessage", { description: "Get a specific message from a conversation",
+        inputSchema: { spaceId: { type: "string", required: true }, conversationId: { type: "string", required: true }, messageId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            return api(host, token, "GET", `/api/2.0/genie/spaces/${p.spaceId}/conversations/${p.conversationId}/messages/${p.messageId}`);
+        } });
+    rl.registerAction("genie.getQueryResults", { description: "Get query results from a message attachment",
+        inputSchema: { spaceId: { type: "string", required: true }, conversationId: { type: "string", required: true }, messageId: { type: "string", required: true }, attachmentId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            return api(host, token, "GET", `/api/2.0/genie/spaces/${p.spaceId}/conversations/${p.conversationId}/messages/${p.messageId}/attachments/${p.attachmentId}/query-result`);
+        } });
+    rl.registerAction("genie.executeMessageQuery", { description: "Execute a query from a message attachment",
+        inputSchema: { spaceId: { type: "string", required: true }, conversationId: { type: "string", required: true }, messageId: { type: "string", required: true }, attachmentId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            return api(host, token, "POST", `/api/2.0/genie/spaces/${p.spaceId}/conversations/${p.conversationId}/messages/${p.messageId}/attachments/${p.attachmentId}/execute-query`);
+        } });
+    rl.registerAction("genie.getSpace", { description: "Get a Genie space",
+        inputSchema: { spaceId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            return api(host, token, "GET", `/api/2.0/genie/spaces/${input.spaceId}`);
+        } });
+    // ── Model Serving ───────────────────────────────────
+    rl.registerAction("modelServing.queryEndpoint", { description: "Query a model serving endpoint",
+        inputSchema: { endpointName: { type: "string", required: true }, requestBody: { type: "object", required: true, description: "JSON body matching the endpoint schema (chat, completions, embeddings, dataframe, etc.)" } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const body = p.requestBody;
+            return api(host, token, "POST", `/serving-endpoints/${p.endpointName}/invocations`, body);
+        } });
+    // ── Unity Catalog: Catalogs ─────────────────────────
+    rl.registerAction("catalog.create", { description: "Create a Unity Catalog catalog",
+        inputSchema: { name: { type: "string", required: true }, comment: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const body = { name: p.name };
+            if (p.comment)
+                body.comment = p.comment;
+            return api(host, token, "POST", "/api/2.1/unity-catalog/catalogs", body);
+        } });
+    rl.registerAction("catalog.get", { description: "Get a catalog", inputSchema: { name: { type: "string", required: true } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); return api(host, token, "GET", `/api/2.1/unity-catalog/catalogs/${input.name}`); } });
+    rl.registerAction("catalog.list", { description: "List all catalogs", inputSchema: {},
+        async execute(_input, ctx) { const { host, token } = getConn(ctx); return api(host, token, "GET", "/api/2.1/unity-catalog/catalogs"); } });
+    rl.registerAction("catalog.update", { description: "Update a catalog's comment",
+        inputSchema: { name: { type: "string", required: true }, comment: { type: "string", required: true } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); const p = input; return api(host, token, "PATCH", `/api/2.1/unity-catalog/catalogs/${p.name}`, { comment: p.comment }); } });
+    rl.registerAction("catalog.delete", { description: "Delete a catalog", inputSchema: { name: { type: "string", required: true } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); await api(host, token, "DELETE", `/api/2.1/unity-catalog/catalogs/${input.name}`); return { success: true }; } });
+    // ── Unity Catalog: Tables ───────────────────────────
+    rl.registerAction("table.create", { description: "Create an external Delta table",
+        inputSchema: { catalogName: { type: "string", required: true }, schemaName: { type: "string", required: true }, tableName: { type: "string", required: true }, storageLocation: { type: "string", required: true }, columns: { type: "object", required: false, description: "JSON array of column defs" }, comment: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const body = { catalog_name: p.catalogName, schema_name: p.schemaName, name: p.tableName, table_type: "EXTERNAL", data_source_format: "DELTA", storage_location: p.storageLocation };
+            if (p.columns)
+                body.columns = p.columns;
+            if (p.comment)
+                body.comment = p.comment;
+            return api(host, token, "POST", "/api/2.1/unity-catalog/tables", body);
+        } });
+    rl.registerAction("table.get", { description: "Get table info", inputSchema: { fullName: { type: "string", required: true, description: "catalog.schema.table" } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); return api(host, token, "GET", `/api/2.1/unity-catalog/tables/${input.fullName}`); } });
+    rl.registerAction("table.list", { description: "List tables",
+        inputSchema: { catalogName: { type: "string", required: false }, schemaName: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = (input ?? {});
+            const qs = {};
+            if (p.catalogName)
+                qs.catalog_name = p.catalogName;
+            if (p.schemaName)
+                qs.schema_name = p.schemaName;
+            return api(host, token, "GET", "/api/2.1/unity-catalog/tables", undefined, qs);
+        } });
+    rl.registerAction("table.delete", { description: "Delete a table", inputSchema: { fullName: { type: "string", required: true, description: "catalog.schema.table" } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); await api(host, token, "DELETE", `/api/2.1/unity-catalog/tables/${input.fullName}`); return { success: true }; } });
+    // ── Unity Catalog: Volumes ──────────────────────────
+    rl.registerAction("volume.create", { description: "Create a Unity Catalog volume",
+        inputSchema: { catalogName: { type: "string", required: true }, schemaName: { type: "string", required: true }, volumeName: { type: "string", required: true }, volumeType: { type: "string", required: true, description: "MANAGED or EXTERNAL" }, storageLocation: { type: "string", required: false, description: "Required for EXTERNAL volumes" }, comment: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            if (p.volumeType === "EXTERNAL" && !p.storageLocation)
+                throw new Error("storageLocation required for EXTERNAL volumes");
+            const body = { catalog_name: p.catalogName, schema_name: p.schemaName, name: p.volumeName, volume_type: p.volumeType };
+            if (p.storageLocation)
+                body.storage_location = p.storageLocation;
+            if (p.comment)
+                body.comment = p.comment;
+            return api(host, token, "POST", "/api/2.1/unity-catalog/volumes", body);
+        } });
+    rl.registerAction("volume.get", { description: "Get a volume",
+        inputSchema: { catalogName: { type: "string", required: true }, schemaName: { type: "string", required: true }, volumeName: { type: "string", required: true } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); const p = input; return api(host, token, "GET", `/api/2.1/unity-catalog/volumes/${p.catalogName}.${p.schemaName}.${p.volumeName}`); } });
+    rl.registerAction("volume.list", { description: "List volumes",
+        inputSchema: { catalogName: { type: "string", required: false }, schemaName: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = (input ?? {});
+            const qs = {};
+            if (p.catalogName)
+                qs.catalog_name = p.catalogName;
+            if (p.schemaName)
+                qs.schema_name = p.schemaName;
+            return api(host, token, "GET", "/api/2.1/unity-catalog/volumes", undefined, qs);
+        } });
+    rl.registerAction("volume.delete", { description: "Delete a volume",
+        inputSchema: { catalogName: { type: "string", required: true }, schemaName: { type: "string", required: true }, volumeName: { type: "string", required: true } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); const p = input; await api(host, token, "DELETE", `/api/2.1/unity-catalog/volumes/${p.catalogName}.${p.schemaName}.${p.volumeName}`); return { success: true }; } });
+    // ── Unity Catalog: Functions ────────────────────────
+    rl.registerAction("function.create", { description: "Create a Unity Catalog function",
+        inputSchema: { catalogName: { type: "string", required: true }, schemaName: { type: "string", required: true }, functionName: { type: "string", required: true }, inputParams: { type: "object", required: true, description: "Array of {name, type_name, type_text?} parameter definitions" }, returnType: { type: "string", required: true, description: "e.g. STRING, INT" }, routineBody: { type: "string", required: true, description: "SQL or EXTERNAL" }, routineDefinition: { type: "string", required: true, description: "The function body" } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const params = (Array.isArray(p.inputParams) ? p.inputParams : p.inputParams?.parameters ?? []);
+            const normalizedParams = params.map((param) => ({ ...param, type_text: param.type_text ?? param.type_name, type_json: param.type_json ?? JSON.stringify({ name: param.type_name }) }));
+            return api(host, token, "POST", "/api/2.1/unity-catalog/functions", {
+                function_info: { name: p.functionName, catalog_name: p.catalogName, schema_name: p.schemaName, input_params: { parameters: normalizedParams }, data_type: p.returnType, full_data_type: p.returnType, specific_name: p.functionName, parameter_style: "S", security_type: "DEFINER", sql_data_access: "CONTAINS_SQL", is_deterministic: false, is_null_call: true, routine_body: p.routineBody, routine_definition: p.routineDefinition },
+            });
+        } });
+    rl.registerAction("function.get", { description: "Get a function", inputSchema: { fullName: { type: "string", required: true, description: "catalog.schema.function_name" } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); return api(host, token, "GET", `/api/2.1/unity-catalog/functions/${input.fullName}`); } });
+    rl.registerAction("function.list", { description: "List functions",
+        inputSchema: { catalogName: { type: "string", required: false }, schemaName: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = (input ?? {});
+            const qs = {};
+            if (p.catalogName)
+                qs.catalog_name = p.catalogName;
+            if (p.schemaName)
+                qs.schema_name = p.schemaName;
+            return api(host, token, "GET", "/api/2.1/unity-catalog/functions", undefined, qs);
+        } });
+    rl.registerAction("function.delete", { description: "Delete a function", inputSchema: { fullName: { type: "string", required: true, description: "catalog.schema.function_name" } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); await api(host, token, "DELETE", `/api/2.1/unity-catalog/functions/${input.fullName}`); return { success: true }; } });
+    // ── Vector Search ───────────────────────────────────
+    rl.registerAction("vectorSearch.createIndex", { description: "Create a vector search index",
+        inputSchema: { indexName: { type: "string", required: true }, endpointName: { type: "string", required: true }, primaryKey: { type: "string", required: true }, indexType: { type: "string", required: true, description: "DELTA_SYNC or DIRECT_ACCESS" }, deltaSyncIndexSpec: { type: "object", required: false, description: "Spec for DELTA_SYNC type" }, directAccessIndexSpec: { type: "object", required: false, description: "Spec for DIRECT_ACCESS type" } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const body = { name: p.indexName, endpoint_name: p.endpointName, primary_key: p.primaryKey, index_type: p.indexType };
+            if (p.indexType === "DELTA_SYNC" && p.deltaSyncIndexSpec)
+                body.delta_sync_index_spec = p.deltaSyncIndexSpec;
+            if (p.indexType === "DIRECT_ACCESS" && p.directAccessIndexSpec)
+                body.direct_access_index_spec = p.directAccessIndexSpec;
+            return api(host, token, "POST", "/api/2.0/vector-search/indexes", body);
+        } });
+    rl.registerAction("vectorSearch.getIndex", { description: "Get a vector search index", inputSchema: { indexName: { type: "string", required: true } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); return api(host, token, "GET", `/api/2.0/vector-search/indexes/${input.indexName}`); } });
+    rl.registerAction("vectorSearch.listIndexes", { description: "List vector search indexes for an endpoint", inputSchema: { endpointName: { type: "string", required: true } },
+        async execute(input, ctx) { const { host, token } = getConn(ctx); return api(host, token, "GET", "/api/2.0/vector-search/indexes", undefined, { endpoint_name: input.endpointName }); } });
+    rl.registerAction("vectorSearch.queryIndex", { description: "Query a vector search index",
+        inputSchema: { indexName: { type: "string", required: true }, queryType: { type: "string", required: true, description: "text or vector" }, queryText: { type: "string", required: false, description: "For text queries" }, queryVector: { type: "object", required: false, description: "For vector queries — array of numbers" }, numResults: { type: "number", required: false }, columns: { type: "string", required: true, description: "Comma-separated column names to return" }, searchMode: { type: "string", required: false, description: "HYBRID (default), ANN, or EXACT" }, filterExpression: { type: "string", required: false }, scoreThreshold: { type: "number", required: false }, enableReranking: { type: "boolean", required: false }, rerankerModel: { type: "string", required: false }, columnsToRerank: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { host, token } = getConn(ctx);
+            const p = input;
+            const body = { num_results: p.numResults ?? 10, query_type: p.searchMode ?? "HYBRID" };
+            if (p.queryType === "text")
+                body.query_text = p.queryText;
+            else
+                body.query_vector = p.queryVector;
+            body.columns = p.columns.split(",").map((c) => c.trim()).filter(Boolean);
+            if (p.filterExpression)
+                body.filters_json = p.filterExpression;
+            if (p.scoreThreshold)
+                body.score_threshold = p.scoreThreshold;
+            if (p.enableReranking) {
+                body.reranker = { model: p.rerankerModel ?? "databricks_reranker", parameters: { columns_to_rerank: (p.columnsToRerank || "").split(",").map((c) => c.trim()).filter(Boolean) } };
+            }
+            return api(host, token, "POST", `/api/2.0/vector-search/indexes/${p.indexName}/query`, body);
+        } });
+}

package/dist/plugins/deepl/src/index.js

@@ -0,0 +1,87 @@
+async function apiRequest(apiKey, isPro, method, endpoint, params) {
+    const baseUrl = isPro ? "https://api.deepl.com/v2" : "https://api-free.deepl.com/v2";
+    const url = new URL(`${baseUrl}${endpoint}`);
+    const opts = {
+        method,
+        headers: {
+            Authorization: `DeepL-Auth-Key ${apiKey}`,
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+    };
+    if (params && Object.keys(params).length > 0) {
+        if (method === "GET") {
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null)
+                    url.searchParams.set(k, String(v));
+            }
+        }
+        else {
+            opts.body = new URLSearchParams(Object.entries(params)
+                .filter(([, v]) => v !== undefined && v !== null)
+                .map(([k, v]) => [k, String(v)])).toString();
+        }
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`DeepL API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function getConn(ctx) {
+    const cfg = ctx.connection.config;
+    return {
+        apiKey: cfg.apiKey,
+        isPro: cfg.plan === "pro",
+    };
+}
+export default function deepl(rl) {
+    rl.setName("deepl");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "DeepL API authentication key",
+            env: "DEEPL_API_KEY",
+        },
+        plan: {
+            type: "string",
+            required: false,
+            description: "'free' (default) or 'pro'",
+            env: "DEEPL_PLAN",
+            default: "free",
+        },
+    });
+    rl.registerAction("language.translate", {
+        description: "Translate text to a target language",
+        inputSchema: {
+            text: { type: "string", required: true, description: "Text to translate" },
+            targetLang: { type: "string", required: true, description: "Target language code (e.g. DE, FR, ES, EN-US, EN-GB, JA, ZH)" },
+            sourceLang: { type: "string", required: false, description: "Source language code (auto-detected if omitted)" },
+        },
+        async execute(input, ctx) {
+            const { text, targetLang, sourceLang } = input;
+            const { apiKey, isPro } = getConn(ctx);
+            const params = {
+                text,
+                target_lang: targetLang,
+            };
+            if (sourceLang) {
+                params.source_lang = ["EN-GB", "EN-US"].includes(sourceLang) ? "EN" : sourceLang;
+            }
+            const data = (await apiRequest(apiKey, isPro, "POST", "/translate", params));
+            const translations = data.translations;
+            return translations?.[0] ?? data;
+        },
+    });
+    rl.registerAction("language.list", {
+        description: "List available target languages",
+        inputSchema: {
+            type: { type: "string", required: false, description: "'source' or 'target' (default: target)" },
+        },
+        async execute(input, ctx) {
+            const { type = "target" } = (input ?? {});
+            const { apiKey, isPro } = getConn(ctx);
+            return apiRequest(apiKey, isPro, "GET", "/languages", { type });
+        },
+    });
+}