@flowdrop/flowdrop 1.4.0 → 1.6.0

package/dist/services/agentSpecExecutionService.js

@@ -6,9 +6,9 @@
  *
  * Follows the same singleton pattern as NodeExecutionService.
  */
-import { buildAgentSpecUrl, getAgentSpecAuthHeaders, } from "../config/agentSpecEndpoints.js";
-import { AgentSpecAdapter } from "../adapters/agentspec/AgentSpecAdapter.js";
-import { logger } from "../utils/logger.js";
+import { buildAgentSpecUrl, getAgentSpecAuthHeaders } from '../config/agentSpecEndpoints.js';
+import { AgentSpecAdapter } from '../adapters/agentspec/AgentSpecAdapter.js';
+import { logger } from '../utils/logger.js';
 /**
  * Service for executing FlowDrop workflows on Agent Spec runtimes.
  *
@@ -67,7 +67,7 @@ export class AgentSpecExecutionService {
             const url = buildAgentSpecUrl(this.config, this.config.endpoints.health);
             const response = await fetch(url, {
                 headers: getAgentSpecAuthHeaders(this.config),
-                signal: AbortSignal.timeout(5000),
+                signal: AbortSignal.timeout(5000)
             });
             return response.ok;
         }
@@ -90,29 +90,29 @@ export class AgentSpecExecutionService {
         // POST to runtime
         const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.execute);
         const response = await fetch(url, {
-            method: "POST",
+            method: 'POST',
             headers: getAgentSpecAuthHeaders(this.getConfig()),
             body: JSON.stringify({
                 flow: agentSpecFlow,
-                inputs: inputs || {},
+                inputs: inputs || {}
             }),
-            signal: AbortSignal.timeout(this.getConfig().timeout || 60000),
+            signal: AbortSignal.timeout(this.getConfig().timeout || 60000)
         });
         if (!response.ok) {
-            const errorText = await response.text().catch(() => "Unknown error");
+            const errorText = await response.text().catch(() => 'Unknown error');
             throw new Error(`Agent Spec runtime error (${response.status}): ${errorText}`);
         }
         const result = await response.json();
         const executionId = result.execution_id || result.id;
         if (!executionId) {
-            throw new Error("Runtime did not return an execution ID");
+            throw new Error('Runtime did not return an execution ID');
         }
         // Track execution
         const state = {
             id: executionId,
-            status: "running",
+            status: 'running',
             startedAt: new Date().toISOString(),
-            nodeStatuses: {},
+            nodeStatuses: {}
         };
         this.activeExecutions.set(executionId, state);
         // Build node name → FlowDrop node ID mapping for status updates
@@ -135,10 +135,10 @@ export class AgentSpecExecutionService {
         this.ensureConfigured();
         try {
             const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.status, {
-                id: executionId,
+                id: executionId
             });
             const response = await fetch(url, {
-                headers: getAgentSpecAuthHeaders(this.getConfig()),
+                headers: getAgentSpecAuthHeaders(this.getConfig())
             });
             if (!response.ok)
                 return null;
@@ -156,15 +156,15 @@ export class AgentSpecExecutionService {
         this.ensureConfigured();
         this.stopPolling(executionId);
         const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.cancel, {
-            id: executionId,
+            id: executionId
         });
         await fetch(url, {
-            method: "POST",
-            headers: getAgentSpecAuthHeaders(this.getConfig()),
+            method: 'POST',
+            headers: getAgentSpecAuthHeaders(this.getConfig())
         });
         const state = this.activeExecutions.get(executionId);
         if (state) {
-            state.status = "cancelled";
+            state.status = 'cancelled';
         }
     }
     /**
@@ -174,10 +174,10 @@ export class AgentSpecExecutionService {
         this.ensureConfigured();
         try {
             const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.results, {
-                id: executionId,
+                id: executionId
             });
             const response = await fetch(url, {
-                headers: getAgentSpecAuthHeaders(this.getConfig()),
+                headers: getAgentSpecAuthHeaders(this.getConfig())
             });
             if (!response.ok)
                 return null;
@@ -195,14 +195,14 @@ export class AgentSpecExecutionService {
         const agentSpecFlow = this.adapter.toAgentSpec(workflow);
         const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.validate);
         const response = await fetch(url, {
-            method: "POST",
+            method: 'POST',
             headers: getAgentSpecAuthHeaders(this.getConfig()),
-            body: JSON.stringify(agentSpecFlow),
+            body: JSON.stringify(agentSpecFlow)
         });
         if (!response.ok) {
             return {
                 valid: false,
-                errors: [`Runtime validation failed: ${response.status}`],
+                errors: [`Runtime validation failed: ${response.status}`]
             };
         }
         return await response.json();
@@ -221,7 +221,7 @@ export class AgentSpecExecutionService {
     // ========================================================================
     ensureConfigured() {
         if (!this.config) {
-            throw new Error("AgentSpecExecutionService not configured. Call configure() with runtime endpoint config first.");
+            throw new Error('AgentSpecExecutionService not configured. Call configure() with runtime endpoint config first.');
         }
     }
     /** Get the config, throwing if not configured */
@@ -237,10 +237,10 @@ export class AgentSpecExecutionService {
         const poll = async () => {
             try {
                 const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.status, {
-                    id: executionId,
+                    id: executionId
                 });
                 const response = await fetch(url, {
-                    headers: getAgentSpecAuthHeaders(this.getConfig()),
+                    headers: getAgentSpecAuthHeaders(this.getConfig())
                 });
                 if (!response.ok) {
                     throw new Error(`Status check failed: ${response.status}`);
@@ -256,27 +256,26 @@ export class AgentSpecExecutionService {
                     onNodeUpdate?.(nodeId, info);
                 }
                 // Check if execution is done
-                if (executionStatus === "completed" || executionStatus === "success") {
-                    state.status = "completed";
+                if (executionStatus === 'completed' || executionStatus === 'success') {
+                    state.status = 'completed';
                     this.stopPolling(executionId);
                     const results = await this.getResults(executionId);
                     onComplete?.(results || {});
                 }
-                else if (executionStatus === "failed" ||
-                    executionStatus === "error") {
-                    state.status = "failed";
+                else if (executionStatus === 'failed' || executionStatus === 'error') {
+                    state.status = 'failed';
                     this.stopPolling(executionId);
-                    const errorMsg = data.error || data.message || "Execution failed";
+                    const errorMsg = data.error || data.message || 'Execution failed';
                     onError?.(new Error(errorMsg));
                 }
-                else if (executionStatus === "cancelled") {
-                    state.status = "cancelled";
+                else if (executionStatus === 'cancelled') {
+                    state.status = 'cancelled';
                     this.stopPolling(executionId);
                 }
             }
             catch (error) {
                 // Don't stop polling on transient errors — let it retry
-                logger.error("[AgentSpecExecution] Polling error:", error);
+                logger.error('[AgentSpecExecution] Polling error:', error);
             }
         };
         // Initial poll immediately, then at interval
@@ -299,38 +298,38 @@ export class AgentSpecExecutionService {
         return result;
     }
     mapSingleNodeStatus(status) {
-        const runtimeStatus = (status.status || status.state || "idle");
+        const runtimeStatus = (status.status || status.state || 'idle');
         return {
             status: this.mapToFlowDropStatus(runtimeStatus),
             executionCount: status.execution_count || 0,
-            isExecuting: runtimeStatus === "running" || runtimeStatus === "executing",
+            isExecuting: runtimeStatus === 'running' || runtimeStatus === 'executing',
             lastExecuted: status.started_at,
             lastExecutionDuration: status.duration_ms,
-            lastError: status.error,
+            lastError: status.error
         };
     }
     mapToFlowDropStatus(runtimeStatus) {
         switch (runtimeStatus) {
-            case "running":
-            case "executing":
-                return "running";
-            case "completed":
-            case "success":
-            case "done":
-                return "completed";
-            case "failed":
-            case "error":
-                return "failed";
-            case "cancelled":
-            case "canceled":
-                return "cancelled";
-            case "pending":
-            case "queued":
-                return "pending";
-            case "skipped":
-                return "skipped";
+            case 'running':
+            case 'executing':
+                return 'running';
+            case 'completed':
+            case 'success':
+            case 'done':
+                return 'completed';
+            case 'failed':
+            case 'error':
+                return 'failed';
+            case 'cancelled':
+            case 'canceled':
+                return 'cancelled';
+            case 'pending':
+            case 'queued':
+                return 'pending';
+            case 'skipped':
+                return 'skipped';
             default:
-                return "idle";
+                return 'idle';
         }
     }
 }

package/dist/services/api.d.ts

@@ -2,8 +2,8 @@
  * Client-side API service for FlowDrop
  * Provides methods to interact with the backend APIs using configurable endpoints
  */
-import type { NodeMetadata, Workflow } from "../types/index.js";
-import type { EndpointConfig } from "../config/endpoints.js";
+import type { NodeMetadata, Workflow } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
  * Set the endpoint configuration at runtime
  */

package/dist/services/api.js

@@ -2,7 +2,7 @@
  * Client-side API service for FlowDrop
  * Provides methods to interact with the backend APIs using configurable endpoints
  */
-import { buildEndpointUrl, getEndpointMethod, getEndpointHeaders, } from "../config/endpoints.js";
+import { buildEndpointUrl, getEndpointMethod, getEndpointHeaders } from '../config/endpoints.js';
 let endpointConfig = null;
 /**
  * Set the endpoint configuration at runtime
@@ -21,7 +21,7 @@ export function getEndpointConfig() {
  */
 async function apiRequest(endpointKey, endpointPath, params, options = {}) {
     if (!endpointConfig) {
-        throw new Error("Endpoint configuration not set. Call setEndpointConfig() first.");
+        throw new Error('Endpoint configuration not set. Call setEndpointConfig() first.');
     }
     const url = buildEndpointUrl(endpointConfig, endpointPath, params);
     const method = getEndpointMethod(endpointConfig, endpointKey);
@@ -29,11 +29,11 @@ async function apiRequest(endpointKey, endpointPath, params, options = {}) {
     const response = await fetch(url, {
         method,
         headers,
-        ...options,
+        ...options
     });
     // Check if response is JSON
-    const contentType = response.headers.get("content-type");
-    const isJson = contentType?.includes("application/json");
+    const contentType = response.headers.get('content-type');
+    const isJson = contentType?.includes('application/json');
     if (!response.ok) {
         // Try to get error details
         let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
@@ -73,18 +73,18 @@ export const nodeApi = {
      */
     async getNodes(options) {
         if (!endpointConfig) {
-            throw new Error("Endpoint configuration not set");
+            throw new Error('Endpoint configuration not set');
         }
         const params = new URLSearchParams();
         if (options?.category)
-            params.append("category", options.category);
+            params.append('category', options.category);
         if (options?.search)
-            params.append("search", options.search);
+            params.append('search', options.search);
         if (options?.limit)
-            params.append("limit", options.limit.toString());
+            params.append('limit', options.limit.toString());
         if (options?.offset)
-            params.append("offset", options.offset.toString());
-        const response = await apiRequest("nodes.list", endpointConfig.endpoints.nodes.list + "?" + params.toString());
+            params.append('offset', options.offset.toString());
+        const response = await apiRequest('nodes.list', endpointConfig.endpoints.nodes.list + '?' + params.toString());
         return response.data || [];
     },
     /**
@@ -92,14 +92,14 @@ export const nodeApi = {
      */
     async getNode(id) {
         if (!endpointConfig) {
-            throw new Error("Endpoint configuration not set");
+            throw new Error('Endpoint configuration not set');
         }
-        const response = await apiRequest("nodes.get", endpointConfig.endpoints.nodes.get, { id });
+        const response = await apiRequest('nodes.get', endpointConfig.endpoints.nodes.get, { id });
         if (!response.data) {
-            throw new Error("Node not found");
+            throw new Error('Node not found');
         }
         return response.data;
-    },
+    }
 };
 /**
  * Workflow API methods
@@ -110,16 +110,16 @@ export const workflowApi = {
      */
     async getWorkflows(options) {
         if (!endpointConfig) {
-            throw new Error("Endpoint configuration not set");
+            throw new Error('Endpoint configuration not set');
         }
         const params = new URLSearchParams();
         if (options?.search)
-            params.append("search", options.search);
+            params.append('search', options.search);
         if (options?.limit)
-            params.append("limit", options.limit.toString());
+            params.append('limit', options.limit.toString());
         if (options?.offset)
-            params.append("offset", options.offset.toString());
-        const response = await apiRequest("workflows.list", endpointConfig.endpoints.workflows.list + "?" + params.toString());
+            params.append('offset', options.offset.toString());
+        const response = await apiRequest('workflows.list', endpointConfig.endpoints.workflows.list + '?' + params.toString());
         return response.data || [];
     },
     /**
@@ -127,11 +127,11 @@ export const workflowApi = {
      */
     async getWorkflow(id) {
         if (!endpointConfig) {
-            throw new Error("Endpoint configuration not set");
+            throw new Error('Endpoint configuration not set');
         }
-        const response = await apiRequest("workflows.get", endpointConfig.endpoints.workflows.get, { id });
+        const response = await apiRequest('workflows.get', endpointConfig.endpoints.workflows.get, { id });
         if (!response.data) {
-            throw new Error("Workflow not found");
+            throw new Error('Workflow not found');
         }
         return response.data;
     },
@@ -140,18 +140,18 @@ export const workflowApi = {
      */
     async createWorkflow(workflow) {
         if (!endpointConfig) {
-            throw new Error("Endpoint configuration not set");
+            throw new Error('Endpoint configuration not set');
         }
         // Apply the consumer-provided payload transform (e.g. Drupal's label mapping).
         // The default is the identity function — no CMS-specific logic in the core library.
         const transform = endpointConfig.transformWorkflowPayload ?? ((w) => w);
         const body = transform(workflow);
-        const response = await apiRequest("workflows.create", endpointConfig.endpoints.workflows.create, undefined, {
-            method: "POST",
-            body: JSON.stringify(body),
+        const response = await apiRequest('workflows.create', endpointConfig.endpoints.workflows.create, undefined, {
+            method: 'POST',
+            body: JSON.stringify(body)
         });
         if (!response.data) {
-            throw new Error("Failed to create workflow");
+            throw new Error('Failed to create workflow');
         }
         return response.data;
     },
@@ -160,18 +160,18 @@ export const workflowApi = {
      */
     async updateWorkflow(id, workflow) {
         if (!endpointConfig) {
-            throw new Error("Endpoint configuration not set");
+            throw new Error('Endpoint configuration not set');
         }
         // Apply the consumer-provided payload transform (e.g. Drupal's label mapping).
         // The default is the identity function — no CMS-specific logic in the core library.
         const transform = endpointConfig.transformWorkflowPayload ?? ((w) => w);
         const body = transform(workflow);
-        const response = await apiRequest("workflows.update", endpointConfig.endpoints.workflows.update, { id }, {
-            method: "PUT",
-            body: JSON.stringify(body),
+        const response = await apiRequest('workflows.update', endpointConfig.endpoints.workflows.update, { id }, {
+            method: 'PUT',
+            body: JSON.stringify(body)
         });
         if (!response.data) {
-            throw new Error("Failed to update workflow");
+            throw new Error('Failed to update workflow');
         }
         return response.data;
     },
@@ -180,9 +180,9 @@ export const workflowApi = {
      */
     async deleteWorkflow(id) {
         if (!endpointConfig) {
-            throw new Error("Endpoint configuration not set");
+            throw new Error('Endpoint configuration not set');
         }
-        await apiRequest("workflows.delete", endpointConfig.endpoints.workflows.delete, { id }, { method: "DELETE" });
+        await apiRequest('workflows.delete', endpointConfig.endpoints.workflows.delete, { id }, { method: 'DELETE' });
     },
     /**
      * Save workflow (create or update).
@@ -206,12 +206,12 @@ export const workflowApi = {
             const { id, ...workflowData } = workflow;
             return this.createWorkflow(workflowData);
         }
-    },
+    }
 };
 /**
  * Export the API service
  */
 export const api = {
     nodes: nodeApi,
-    workflows: workflowApi,
+    workflows: workflowApi
 };

package/dist/services/apiVariableService.d.ts

@@ -5,7 +5,7 @@
  *
  * @module services/apiVariableService
  */
-import type { VariableSchema, ApiVariablesConfig, AuthProvider } from "../types/index.js";
+import type { VariableSchema, ApiVariablesConfig, AuthProvider } from '../types/index.js';
 /**
  * Context for variable API requests
  */

package/dist/services/apiVariableService.js

@@ -5,9 +5,9 @@
  *
  * @module services/apiVariableService
  */
-import { getEndpointConfig } from "./api.js";
-import { logger } from "../utils/logger.js";
-import { DEFAULT_CACHE_TTL_MS } from "../config/constants.js";
+import { getEndpointConfig } from './api.js';
+import { logger } from '../utils/logger.js';
+import { DEFAULT_CACHE_TTL_MS } from '../config/constants.js';
 /**
  * Variable schema cache with TTL support
  * Key format: `variables:{workflowId}:{nodeId}`
@@ -48,7 +48,7 @@ export function resolveEndpointUrl(template, context) {
  * @returns A unique cache key string
  */
 function generateVariableCacheKey(workflowId, nodeId) {
-    return `variables:${workflowId || "unknown"}:${nodeId}`;
+    return `variables:${workflowId || 'unknown'}:${nodeId}`;
 }
 /**
  * Checks if a cached variable schema is still valid (not expired).
@@ -71,7 +71,7 @@ function isCacheValid(entry, ttl = DEFAULT_VARIABLE_CACHE_TTL) {
 function resolveBodyTemplates(body, context) {
     const resolved = {};
     for (const [key, value] of Object.entries(body)) {
-        if (typeof value === "string") {
+        if (typeof value === 'string') {
             // Resolve template variables in string values
             let resolvedValue = value;
             if (context.workflowId) {
@@ -80,9 +80,7 @@ function resolveBodyTemplates(body, context) {
             resolvedValue = resolvedValue.replace(/\{nodeId\}/g, encodeURIComponent(context.nodeId));
             resolved[key] = resolvedValue;
         }
-        else if (typeof value === "object" &&
-            value !== null &&
-            !Array.isArray(value)) {
+        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
             // Recursively resolve nested objects
             resolved[key] = resolveBodyTemplates(value, context);
         }
@@ -131,27 +129,27 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
             return {
                 success: true,
                 schema: cached.schema,
-                fromCache: true,
+                fromCache: true
             };
         }
     }
     // Resolve the URL with template variables
     let url = resolveEndpointUrl(endpoint.url, context);
     // If URL is relative, prepend base URL from endpoint config
-    if (url.startsWith("/")) {
+    if (url.startsWith('/')) {
         const currentConfig = getEndpointConfig();
         if (currentConfig?.baseUrl) {
-            const baseUrl = currentConfig.baseUrl.replace(/\/$/, "");
+            const baseUrl = currentConfig.baseUrl.replace(/\/$/, '');
             url = `${baseUrl}${url}`;
         }
     }
     // Prepare request options
-    const method = endpoint.method ?? "GET";
+    const method = endpoint.method ?? 'GET';
     const timeout = endpoint.timeout ?? 30000;
     const headers = {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-        ...endpoint.headers,
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        ...endpoint.headers
     };
     // Add auth headers from AuthProvider if available
     if (authProvider) {
@@ -160,22 +158,19 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
             Object.assign(headers, authHeaders);
         }
         catch (error) {
-            logger.warn("Failed to get auth headers:", error);
+            logger.warn('Failed to get auth headers:', error);
         }
     }
     // Add auth headers from endpoint config as fallback
     const currentConfig = getEndpointConfig();
     if (currentConfig?.auth) {
-        if (currentConfig.auth.type === "bearer" && currentConfig.auth.token) {
-            headers["Authorization"] =
-                headers["Authorization"] ?? `Bearer ${currentConfig.auth.token}`;
+        if (currentConfig.auth.type === 'bearer' && currentConfig.auth.token) {
+            headers['Authorization'] = headers['Authorization'] ?? `Bearer ${currentConfig.auth.token}`;
         }
-        else if (currentConfig.auth.type === "api_key" &&
-            currentConfig.auth.apiKey) {
-            headers["X-API-Key"] = headers["X-API-Key"] ?? currentConfig.auth.apiKey;
+        else if (currentConfig.auth.type === 'api_key' && currentConfig.auth.apiKey) {
+            headers['X-API-Key'] = headers['X-API-Key'] ?? currentConfig.auth.apiKey;
         }
-        else if (currentConfig.auth.type === "custom" &&
-            currentConfig.auth.headers) {
+        else if (currentConfig.auth.type === 'custom' && currentConfig.auth.headers) {
             Object.assign(headers, currentConfig.auth.headers);
         }
     }
@@ -183,10 +178,10 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
     const fetchOptions = {
         method,
         headers,
-        signal: AbortSignal.timeout(timeout),
+        signal: AbortSignal.timeout(timeout)
     };
     // Add body for non-GET requests
-    if (method !== "GET" && endpoint.body) {
+    if (method !== 'GET' && endpoint.body) {
         const resolvedBody = resolveBodyTemplates(endpoint.body, context);
         fetchOptions.body = JSON.stringify(resolvedBody);
     }
@@ -197,7 +192,7 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
             return {
                 success: true,
                 schema: { variables: {} },
-                fromCache: false,
+                fromCache: false
             };
         }
         if (!response.ok) {
@@ -212,13 +207,13 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
                 }
                 return {
                     success: false,
-                    error: "Authentication failed",
+                    error: 'Authentication failed'
                 };
             }
             const errorText = await response.text();
             return {
                 success: false,
-                error: `HTTP ${response.status}: ${errorText || response.statusText}`,
+                error: `HTTP ${response.status}: ${errorText || response.statusText}`
             };
         }
         const data = await response.json();
@@ -228,17 +223,15 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
         // 3. Wrapped in { schema: { variables: {...} } }
         // 4. Wrapped in { success: true, data: { variables: {...} } }
         let schema;
-        if (data.variables && typeof data.variables === "object") {
+        if (data.variables && typeof data.variables === 'object') {
             // Direct VariableSchema
             schema = data;
         }
-        else if (data.data?.variables &&
-            typeof data.data.variables === "object") {
+        else if (data.data?.variables && typeof data.data.variables === 'object') {
             // Wrapped in { data: ... }
             schema = data.data;
         }
-        else if (data.schema?.variables &&
-            typeof data.schema.variables === "object") {
+        else if (data.schema?.variables && typeof data.schema.variables === 'object') {
             // Wrapped in { schema: ... }
             schema = data.schema;
         }
@@ -249,7 +242,7 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
         if (!schema) {
             return {
                 success: false,
-                error: "Invalid variable schema format received from endpoint",
+                error: 'Invalid variable schema format received from endpoint'
             };
         }
         // Cache the schema (if caching is enabled)
@@ -257,32 +250,32 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
             variableCache.set(cacheKey, {
                 schema,
                 cachedAt: Date.now(),
-                cacheKey,
+                cacheKey
             });
         }
         return {
             success: true,
             schema,
-            fromCache: false,
+            fromCache: false
         };
     }
     catch (error) {
         // Handle specific error types
         if (error instanceof Error) {
-            if (error.name === "AbortError" || error.name === "TimeoutError") {
+            if (error.name === 'AbortError' || error.name === 'TimeoutError') {
                 return {
                     success: false,
-                    error: `Request timed out after ${timeout}ms`,
+                    error: `Request timed out after ${timeout}ms`
                 };
             }
             return {
                 success: false,
-                error: error.message,
+                error: error.message
             };
         }
         return {
             success: false,
-            error: "Unknown error occurred while fetching variable schema",
+            error: 'Unknown error occurred while fetching variable schema'
         };
     }
 }