@zudello/modelcontextprotocol 1.0.0 → 1.1.1

package/dist/services/zudello/admin.js

@@ -1,264 +1,595 @@
 /**
  * Admin service functions for Zudello MCP Server
- * Handles datasets, fields, and quick actions
+ * Handles datasets, field settings, and quick actions
+ * Uses General Store API with resource_type parameter
  */
 import { buildZudelloRequest } from "./core.js";
 import { logger } from "../../utils/logger.js";
+// ============================================================================
 // Dataset Functions
+// ============================================================================
+/**
+ * List all datasets with simplified response
+ */
 export async function listZudelloDatasets(authContext, options = {}) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const params = new URLSearchParams();
-        if (options.model)
-            params.append("model", options.model);
-        const query = params.toString() ? `?${params.toString()}` : "";
-        const url = `${apiBase}/api/v2/datasets${query}`;
+        const params = new URLSearchParams({
+            resource_type: "dataset",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        logger.info("Zudello list datasets request", { url, includeColumns: options.includeColumns });
         const response = await fetch(url, { method: "GET", headers });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("listZudelloDatasets failed", { status: response.status, error: errorText });
-            return { success: false, error: `Failed to list datasets: ${response.statusText}` };
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
         }
         const data = await response.json();
-        return { success: true, data: data.datasets || [] };
+        logger.info("Zudello list datasets response received", {
+            httpStatus: response.status,
+            success: data.success,
+            datasetCount: Array.isArray(data.data) ? data.data.length : 0,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to list datasets" };
+        }
+        // Return dataset list with optional column definitions
+        const datasets = (data.data || []).map((d) => ({
+            uuid: d.uuid,
+            name: d.payload?.name || "Unnamed Dataset",
+            datasetType: d.payload?.settings?.datasetType || "",
+            ...(options.includeColumns && { columnDefs: d.payload?.settings?.columnDefs || [] }),
+        }));
+        return { success: true, data: datasets };
     }
     catch (error) {
         logger.error("listZudelloDatasets error", {}, error);
         return { success: false, error: error.message };
     }
 }
-export async function getZudelloDataset(authContext, uuid) {
+/**
+ * Get a specific dataset by UUID
+ */
+export async function getZudelloDataset(authContext, datasetUuid) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const response = await fetch(`${apiBase}/api/v2/datasets/${uuid}`, { method: "GET", headers });
+        const params = new URLSearchParams({
+            resource_type: "dataset",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${datasetUuid}?${params.toString()}`;
+        logger.info("Zudello get dataset request", { url, datasetUuid });
+        const response = await fetch(url, { method: "GET", headers });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("getZudelloDataset failed", { uuid, status: response.status, error: errorText });
-            return { success: false, error: `Failed to get dataset: ${response.statusText}` };
+            if (response.status === 404) {
+                return { success: false, error: `Dataset not found: ${datasetUuid}` };
+            }
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello get dataset response received", {
+            httpStatus: response.status,
+            success: data.success,
+            hasData: !!data.data,
+        });
+        if (!data.success || !data.data) {
+            return { success: false, error: `Dataset not found: ${datasetUuid}` };
         }
-        return { success: true, data: await response.json() };
+        return { success: true, data: data.data };
     }
     catch (error) {
-        logger.error("getZudelloDataset error", { uuid }, error);
+        logger.error("getZudelloDataset error", { datasetUuid }, error);
         return { success: false, error: error.message };
     }
 }
-export async function createZudelloDataset(authContext, dataset) {
+/**
+ * Create a new dataset
+ */
+export async function createZudelloDataset(authContext, name, columnDefs, datasetType = "", onDimensionMismatch) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const response = await fetch(`${apiBase}/api/v2/datasets`, {
+        const params = new URLSearchParams({
+            resource_type: "dataset",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        const payload = {
+            payload: {
+                uuid: "",
+                name,
+                settings: {
+                    datasetType,
+                    columnDefs,
+                    ...(onDimensionMismatch && { on_dimension_mismatch: onDimensionMismatch }),
+                },
+            },
+        };
+        logger.info("Zudello create dataset request", {
+            url,
+            name,
+            columnCount: columnDefs.length,
+            datasetType,
+        });
+        const response = await fetch(url, {
             method: "POST",
             headers,
-            body: JSON.stringify(dataset),
+            body: JSON.stringify(payload),
         });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("createZudelloDataset failed", { status: response.status, error: errorText });
-            return { success: false, error: `Failed to create dataset: ${response.statusText}` };
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
         }
-        return { success: true, data: await response.json() };
+        const data = await response.json();
+        logger.info("Zudello create dataset response received", {
+            httpStatus: response.status,
+            success: data.success,
+            uuid: data.data?.uuid,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to create dataset" };
+        }
+        // Sync payload.uuid with resource uuid
+        const createdUuid = data.data?.uuid;
+        if (createdUuid) {
+            logger.info("Zudello syncing payload.uuid with resource uuid", { createdUuid });
+            const syncResult = await updateZudelloDataset(authContext, createdUuid, name, columnDefs, datasetType, onDimensionMismatch);
+            if (!syncResult.success) {
+                logger.warn("Zudello failed to sync payload.uuid - dataset may be in inconsistent state", {
+                    createdUuid,
+                    error: syncResult.error,
+                });
+                return { success: true, data: data.data };
+            }
+            return { success: true, data: syncResult.data };
+        }
+        return { success: true, data: data.data };
     }
     catch (error) {
-        logger.error("createZudelloDataset error", {}, error);
+        logger.error("createZudelloDataset error", { name }, error);
         return { success: false, error: error.message };
     }
 }
-export async function updateZudelloDataset(authContext, uuid, updates) {
+/**
+ * Update an existing dataset
+ */
+export async function updateZudelloDataset(authContext, datasetUuid, name, columnDefs, datasetType = "", onDimensionMismatch) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const response = await fetch(`${apiBase}/api/v2/datasets/${uuid}`, {
-            method: "PATCH",
+        const params = new URLSearchParams({
+            resource_type: "dataset",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${datasetUuid}?${params.toString()}`;
+        const payload = {
+            payload: {
+                uuid: datasetUuid,
+                name,
+                settings: {
+                    datasetType,
+                    columnDefs,
+                    ...(onDimensionMismatch && { on_dimension_mismatch: onDimensionMismatch }),
+                },
+            },
+        };
+        logger.info("Zudello update dataset request", {
+            url,
+            datasetUuid,
+            name,
+            columnCount: columnDefs.length,
+            datasetType,
+        });
+        const response = await fetch(url, {
+            method: "PUT",
             headers,
-            body: JSON.stringify(updates),
+            body: JSON.stringify(payload),
         });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("updateZudelloDataset failed", { uuid, status: response.status, error: errorText });
-            return { success: false, error: `Failed to update dataset: ${response.statusText}` };
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello update dataset response received", {
+            httpStatus: response.status,
+            success: data.success,
+            version: data.data?.version,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to update dataset" };
         }
-        return { success: true, data: await response.json() };
+        return { success: true, data: data.data };
     }
     catch (error) {
-        logger.error("updateZudelloDataset error", { uuid }, error);
+        logger.error("updateZudelloDataset error", { datasetUuid }, error);
         return { success: false, error: error.message };
     }
 }
-// Field Functions
-export async function listZudelloFields(authContext, options = {}) {
+// ============================================================================
+// Field Settings Functions
+// ============================================================================
+/**
+ * List all field settings with simplified or full response
+ */
+export async function listZudelloFieldSettings(authContext, options = {}) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const params = new URLSearchParams();
-        if (options.model)
-            params.append("model", options.model);
-        const query = params.toString() ? `?${params.toString()}` : "";
-        const url = `${apiBase}/api/v2/fields${query}`;
+        const params = new URLSearchParams({
+            resource_type: "field_settings",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        logger.info("Zudello list field settings request", { url, fullObject: options.fullObject });
         const response = await fetch(url, { method: "GET", headers });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("listZudelloFields failed", { status: response.status, error: errorText });
-            return { success: false, error: `Failed to list fields: ${response.statusText}` };
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
         }
         const data = await response.json();
-        return { success: true, data: data.fields || [] };
+        logger.info("Zudello list field settings response received", {
+            httpStatus: response.status,
+            success: data.success,
+            fieldCount: Array.isArray(data.data) ? data.data.length : 0,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to list field settings" };
+        }
+        if (options.fullObject) {
+            return { success: true, data: data.data || [] };
+        }
+        // Return simplified summaries
+        const summaries = (data.data || []).map((fs) => ({
+            uuid: fs.uuid,
+            path: fs.payload?.path || "",
+            label: fs.payload?.label || "",
+            model_name: fs.payload?.model_name || "",
+            context: fs.context || {},
+        }));
+        return { success: true, data: summaries };
     }
     catch (error) {
-        logger.error("listZudelloFields error", {}, error);
+        logger.error("listZudelloFieldSettings error", {}, error);
         return { success: false, error: error.message };
     }
 }
-export async function getZudelloField(authContext, uuid) {
+/**
+ * Get a specific field settings by UUID
+ */
+export async function getZudelloFieldSettings(authContext, fieldUuid) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const response = await fetch(`${apiBase}/api/v2/fields/${uuid}`, { method: "GET", headers });
+        const params = new URLSearchParams({
+            resource_type: "field_settings",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${fieldUuid}?${params.toString()}`;
+        logger.info("Zudello get field settings request", { url, fieldUuid });
+        const response = await fetch(url, { method: "GET", headers });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("getZudelloField failed", { uuid, status: response.status, error: errorText });
-            return { success: false, error: `Failed to get field: ${response.statusText}` };
+            if (response.status === 404) {
+                return { success: false, error: `Field settings not found: ${fieldUuid}` };
+            }
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello get field settings response received", {
+            httpStatus: response.status,
+            success: data.success,
+            hasData: !!data.data,
+        });
+        if (!data.success || !data.data) {
+            return { success: false, error: `Field settings not found: ${fieldUuid}` };
         }
-        return { success: true, data: await response.json() };
+        return { success: true, data: data.data };
     }
     catch (error) {
-        logger.error("getZudelloField error", { uuid }, error);
+        logger.error("getZudelloFieldSettings error", { fieldUuid }, error);
         return { success: false, error: error.message };
     }
 }
-export async function createZudelloField(authContext, field) {
+/**
+ * Create a new field settings
+ */
+export async function createZudelloFieldSettings(authContext, payload, context = {}) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const response = await fetch(`${apiBase}/api/v2/fields`, {
+        const params = new URLSearchParams({
+            resource_type: "field_settings",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        const body = {
+            payload,
+            context,
+        };
+        logger.info("Zudello create field settings request", {
+            url,
+            path: payload.path,
+            label: payload.label,
+            model_name: payload.model_name,
+            context,
+        });
+        const response = await fetch(url, {
             method: "POST",
             headers,
-            body: JSON.stringify(field),
+            body: JSON.stringify(body),
         });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("createZudelloField failed", { status: response.status, error: errorText });
-            return { success: false, error: `Failed to create field: ${response.statusText}` };
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello create field settings response received", {
+            httpStatus: response.status,
+            success: data.success,
+            uuid: data.data?.uuid,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to create field settings" };
+        }
+        // Sync payload.uuid with resource uuid
+        const createdUuid = data.data?.uuid;
+        if (createdUuid && !payload.uuid) {
+            logger.info("Zudello syncing payload.uuid with resource uuid", { createdUuid });
+            const syncResult = await updateZudelloFieldSettings(authContext, createdUuid, { ...payload, uuid: createdUuid }, context);
+            if (!syncResult.success) {
+                logger.warn("Zudello failed to sync field settings payload.uuid", {
+                    createdUuid,
+                    error: syncResult.error,
+                });
+                return { success: true, data: data.data };
+            }
+            return { success: true, data: syncResult.data };
         }
-        return { success: true, data: await response.json() };
+        return { success: true, data: data.data };
     }
     catch (error) {
-        logger.error("createZudelloField error", {}, error);
+        logger.error("createZudelloFieldSettings error", { path: payload.path }, error);
         return { success: false, error: error.message };
     }
 }
-export async function updateZudelloField(authContext, uuid, updates) {
+/**
+ * Update an existing field settings
+ */
+export async function updateZudelloFieldSettings(authContext, fieldUuid, payload, context = {}) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const response = await fetch(`${apiBase}/api/v2/fields/${uuid}`, {
-            method: "PATCH",
+        const params = new URLSearchParams({
+            resource_type: "field_settings",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${fieldUuid}?${params.toString()}`;
+        // Ensure payload.uuid matches the resource uuid
+        const body = {
+            payload: { ...payload, uuid: fieldUuid },
+            context,
+        };
+        logger.info("Zudello update field settings request", {
+            url,
+            fieldUuid,
+            path: payload.path,
+            label: payload.label,
+        });
+        const response = await fetch(url, {
+            method: "PUT",
             headers,
-            body: JSON.stringify(updates),
+            body: JSON.stringify(body),
         });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("updateZudelloField failed", { uuid, status: response.status, error: errorText });
-            return { success: false, error: `Failed to update field: ${response.statusText}` };
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
         }
-        return { success: true, data: await response.json() };
+        const data = await response.json();
+        logger.info("Zudello update field settings response received", {
+            httpStatus: response.status,
+            success: data.success,
+            version: data.data?.version,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to update field settings" };
+        }
+        return { success: true, data: data.data };
     }
     catch (error) {
-        logger.error("updateZudelloField error", { uuid }, error);
+        logger.error("updateZudelloFieldSettings error", { fieldUuid }, error);
         return { success: false, error: error.message };
     }
 }
+// ============================================================================
 // Quick Action Functions
-export async function listZudelloQuickActions(authContext, options = {}) {
+// ============================================================================
+/**
+ * List quick actions
+ */
+export async function listZudelloQuickActions(authContext) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const params = new URLSearchParams();
-        if (options.model)
-            params.append("model", options.model);
-        const query = params.toString() ? `?${params.toString()}` : "";
-        const url = `${apiBase}/api/v2/quick-actions${query}`;
+        const params = new URLSearchParams({
+            resource_type: "quick_actions",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        logger.info("Zudello list quick actions request", { url });
         const response = await fetch(url, { method: "GET", headers });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("listZudelloQuickActions failed", { status: response.status, error: errorText });
-            return { success: false, error: `Failed to list quick actions: ${response.statusText}` };
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
         }
         const data = await response.json();
-        return { success: true, data: data.quickActions || [] };
+        logger.info("Zudello list quick actions response received", {
+            httpStatus: response.status,
+            success: data.success,
+            resultCount: Array.isArray(data.data) ? data.data.length : 0,
+        });
+        return { success: true, data: data.data || [] };
     }
     catch (error) {
         logger.error("listZudelloQuickActions error", {}, error);
         return { success: false, error: error.message };
     }
 }
-export async function getZudelloQuickAction(authContext, uuid) {
+/**
+ * Get a single quick action by UUID
+ */
+export async function getZudelloQuickAction(authContext, quickActionUuid) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const response = await fetch(`${apiBase}/api/v2/quick-actions/${uuid}`, { method: "GET", headers });
+        const params = new URLSearchParams({
+            resource_type: "quick_actions",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${quickActionUuid}?${params.toString()}`;
+        logger.info("Zudello get quick action request", { url, quickActionUuid });
+        const response = await fetch(url, { method: "GET", headers });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("getZudelloQuickAction failed", { uuid, status: response.status, error: errorText });
-            return { success: false, error: `Failed to get quick action: ${response.statusText}` };
+            if (response.status === 404) {
+                return { success: false, error: `Quick action not found: ${quickActionUuid}` };
+            }
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello get quick action response received", {
+            httpStatus: response.status,
+            success: data.success,
+            hasData: !!data.data,
+        });
+        if (!data.success || !data.data) {
+            return { success: false, error: `Quick action not found with UUID: ${quickActionUuid}` };
         }
-        return { success: true, data: await response.json() };
+        return { success: true, data: data.data };
     }
     catch (error) {
-        logger.error("getZudelloQuickAction error", { uuid }, error);
+        logger.error("getZudelloQuickAction error", { quickActionUuid }, error);
         return { success: false, error: error.message };
     }
 }
-export async function createZudelloQuickAction(authContext, action) {
+/**
+ * Create a new quick action
+ */
+export async function createZudelloQuickAction(authContext, payload) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const response = await fetch(`${apiBase}/api/v2/quick-actions`, {
+        const params = new URLSearchParams({
+            resource_type: "quick_actions",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        const body = { payload };
+        logger.info("Zudello create quick action request", {
+            url,
+            key: payload.key,
+            name: payload.name,
+        });
+        const response = await fetch(url, {
             method: "POST",
             headers,
-            body: JSON.stringify(action),
+            body: JSON.stringify(body),
         });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("createZudelloQuickAction failed", { status: response.status, error: errorText });
-            return { success: false, error: `Failed to create quick action: ${response.statusText}` };
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
         }
-        return { success: true, data: await response.json() };
+        const data = await response.json();
+        logger.info("Zudello create quick action response received", {
+            httpStatus: response.status,
+            success: data.success,
+            uuid: data.data?.uuid,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to create quick action" };
+        }
+        return { success: true, data: data.data };
     }
     catch (error) {
-        logger.error("createZudelloQuickAction error", {}, error);
+        logger.error("createZudelloQuickAction error", { key: payload.key }, error);
         return { success: false, error: error.message };
     }
 }
-export async function updateZudelloQuickAction(authContext, uuid, updates) {
+/**
+ * Update an existing quick action
+ */
+export async function updateZudelloQuickAction(authContext, quickActionUuid, payload) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const response = await fetch(`${apiBase}/api/v2/quick-actions/${uuid}`, {
-            method: "PATCH",
+        const params = new URLSearchParams({
+            resource_type: "quick_actions",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${quickActionUuid}?${params.toString()}`;
+        const body = { payload };
+        logger.info("Zudello update quick action request", {
+            url,
+            quickActionUuid,
+            key: payload.key,
+            name: payload.name,
+        });
+        const response = await fetch(url, {
+            method: "PUT",
             headers,
-            body: JSON.stringify(updates),
+            body: JSON.stringify(body),
         });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("updateZudelloQuickAction failed", { uuid, status: response.status, error: errorText });
-            return { success: false, error: `Failed to update quick action: ${response.statusText}` };
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello update quick action response received", {
+            httpStatus: response.status,
+            success: data.success,
+            version: data.data?.version,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to update quick action" };
         }
-        return { success: true, data: await response.json() };
+        return { success: true, data: data.data };
     }
     catch (error) {
-        logger.error("updateZudelloQuickAction error", { uuid }, error);
+        logger.error("updateZudelloQuickAction error", { quickActionUuid }, error);
         return { success: false, error: error.message };
     }
 }
-export async function triggerZudelloQuickAction(authContext, uuid, resourceUuids) {
+/**
+ * Trigger a quick action on one or more documents
+ * This fires a button event that sentences can listen to
+ */
+export async function triggerZudelloQuickAction(authContext, key, documentUuids) {
     try {
         const { headers, apiBase } = buildZudelloRequest(authContext);
-        const response = await fetch(`${apiBase}/api/v2/quick-actions/${uuid}/trigger`, {
+        const url = `${apiBase}/team-data/v1/resources/button`;
+        const body = {
+            key,
+            uuids: documentUuids,
+        };
+        logger.info("Zudello trigger quick action request", {
+            url,
+            key,
+            documentCount: documentUuids.length,
+        });
+        const response = await fetch(url, {
             method: "POST",
             headers,
-            body: JSON.stringify({ resourceUuids }),
+            body: JSON.stringify(body),
         });
         if (!response.ok) {
-            const errorText = await response.text();
-            logger.error("triggerZudelloQuickAction failed", { uuid, status: response.status, error: errorText });
-            return { success: false, error: `Failed to trigger quick action: ${response.statusText}` };
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
         }
-        return { success: true, data: await response.json() };
+        const data = await response.json();
+        logger.info("Zudello trigger quick action response received", {
+            httpStatus: response.status,
+            success: data.success,
+            succeeded: data.succeeded?.length || 0,
+            failed: data.failed?.length || 0,
+        });
+        return {
+            success: true,
+            data: {
+                success: data.success,
+                status: data.status,
+                succeeded: data.succeeded || [],
+                failed: data.failed || [],
+            },
+        };
     }
     catch (error) {
-        logger.error("triggerZudelloQuickAction error", { uuid }, error);
+        logger.error("triggerZudelloQuickAction error", { key }, error);
         return { success: false, error: error.message };
     }
 }
+// ============================================================================
+// Legacy Aliases (for backward compatibility)
+// ============================================================================
+// These aliases maintain backward compatibility with old function names
+export const listZudelloFields = listZudelloFieldSettings;
+export const getZudelloField = getZudelloFieldSettings;
+export const createZudelloField = createZudelloFieldSettings;
+export const updateZudelloField = updateZudelloFieldSettings;
 //# sourceMappingURL=admin.js.map