@flowdrop/flowdrop 1.5.0 → 1.6.0

package/dist/services/interruptService.js

@@ -7,10 +7,10 @@
  *
  * @module services/interruptService
  */
-import { defaultInterruptPollingConfig } from "../types/interrupt.js";
-import { buildEndpointUrl, getEndpointHeaders } from "../config/endpoints.js";
-import { getEndpointConfig } from "./api.js";
-import { logger } from "../utils/logger.js";
+import { defaultInterruptPollingConfig } from '../types/interrupt.js';
+import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
+import { getEndpointConfig } from './api.js';
+import { logger } from '../utils/logger.js';
 /**
  * Interrupt Service class
  *
@@ -29,8 +29,7 @@ export class InterruptService {
      */
     constructor() {
         this.pollingConfig = { ...defaultInterruptPollingConfig };
-        this.currentBackoff =
-            this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;
+        this.currentBackoff = this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;
     }
     /**
      * Get the singleton instance of InterruptService
@@ -50,8 +49,7 @@ export class InterruptService {
      */
     setPollingConfig(config) {
         this.pollingConfig = { ...this.pollingConfig, ...config };
-        this.currentBackoff =
-            this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;
+        this.currentBackoff = this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;
     }
     /**
      * Get the current polling configuration
@@ -79,10 +77,10 @@ export class InterruptService {
     getConfig() {
         const config = getEndpointConfig();
         if (!config) {
-            throw new Error("Endpoint configuration not set. Call setEndpointConfig() first.");
+            throw new Error('Endpoint configuration not set. Call setEndpointConfig() first.');
         }
         if (!config.endpoints.interrupts) {
-            throw new Error("Interrupt endpoints not configured.");
+            throw new Error('Interrupt endpoints not configured.');
         }
         return config;
     }
@@ -95,13 +93,13 @@ export class InterruptService {
      */
     async request(url, options = {}) {
         const config = this.getConfig();
-        const headers = getEndpointHeaders(config, "interrupts");
+        const headers = getEndpointHeaders(config, 'interrupts');
         const response = await fetch(url, {
             ...options,
             headers: {
                 ...headers,
-                ...options.headers,
-            },
+                ...options.headers
+            }
         });
         if (!response.ok) {
             const errorData = await response.json().catch(() => ({}));
@@ -124,11 +122,11 @@ export class InterruptService {
     async getInterrupt(interruptId) {
         const config = this.getConfig();
         const url = buildEndpointUrl(config, config.endpoints.interrupts.get, {
-            interruptId,
+            interruptId
         });
         const response = await this.request(url);
         if (!response.data) {
-            throw new Error("Interrupt not found");
+            throw new Error('Interrupt not found');
         }
         return response.data;
     }
@@ -142,15 +140,15 @@ export class InterruptService {
     async resolveInterrupt(interruptId, value) {
         const config = this.getConfig();
         const url = buildEndpointUrl(config, config.endpoints.interrupts.resolve, {
-            interruptId,
+            interruptId
         });
         const resolution = { value };
         const response = await this.request(url, {
-            method: "POST",
-            body: JSON.stringify(resolution),
+            method: 'POST',
+            body: JSON.stringify(resolution)
         });
         if (!response.data) {
-            throw new Error("Failed to resolve interrupt: No data returned");
+            throw new Error('Failed to resolve interrupt: No data returned');
         }
         return response.data;
     }
@@ -163,13 +161,13 @@ export class InterruptService {
     async cancelInterrupt(interruptId) {
         const config = this.getConfig();
         const url = buildEndpointUrl(config, config.endpoints.interrupts.cancel, {
-            interruptId,
+            interruptId
         });
         const response = await this.request(url, {
-            method: "POST",
+            method: 'POST'
         });
         if (!response.data) {
-            throw new Error("Failed to cancel interrupt: No data returned");
+            throw new Error('Failed to cancel interrupt: No data returned');
         }
         return response.data;
     }
@@ -182,7 +180,7 @@ export class InterruptService {
     async listSessionInterrupts(sessionId) {
         const config = this.getConfig();
         const url = buildEndpointUrl(config, config.endpoints.interrupts.listBySession, {
-            sessionId,
+            sessionId
         });
         const response = await this.request(url);
         return response.data ?? [];
@@ -196,7 +194,7 @@ export class InterruptService {
     async listPipelineInterrupts(pipelineId) {
         const config = this.getConfig();
         const url = buildEndpointUrl(config, config.endpoints.interrupts.listByPipeline, {
-            pipelineId,
+            pipelineId
         });
         const response = await this.request(url);
         return response.data ?? [];
@@ -215,32 +213,29 @@ export class InterruptService {
      */
     startPolling(sessionId, callback) {
         if (!this.pollingConfig.enabled) {
-            logger.warn("[InterruptService] Polling is disabled. Enable via setPollingConfig().");
+            logger.warn('[InterruptService] Polling is disabled. Enable via setPollingConfig().');
             return;
         }
         // Stop any existing polling
         this.stopPolling();
         this.pollingSessionId = sessionId;
-        this.currentBackoff =
-            this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;
+        this.currentBackoff = this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;
         const poll = async () => {
             if (this.pollingSessionId !== sessionId) {
                 return;
             }
             try {
                 const interrupts = await this.listSessionInterrupts(sessionId);
-                const pendingInterrupts = interrupts.filter((i) => i.status === "pending");
+                const pendingInterrupts = interrupts.filter((i) => i.status === 'pending');
                 // Reset backoff on successful request
-                this.currentBackoff =
-                    this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;
+                this.currentBackoff = this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;
                 // Call the callback with pending interrupts
                 callback(pendingInterrupts);
             }
             catch (error) {
-                logger.error("[InterruptService] Polling error:", error);
+                logger.error('[InterruptService] Polling error:', error);
                 // Exponential backoff on error
-                const maxBackoff = this.pollingConfig.maxBackoff ??
-                    defaultInterruptPollingConfig.maxBackoff;
+                const maxBackoff = this.pollingConfig.maxBackoff ?? defaultInterruptPollingConfig.maxBackoff;
                 this.currentBackoff = Math.min(this.currentBackoff * 2, maxBackoff);
             }
             // Schedule next poll
@@ -260,8 +255,7 @@ export class InterruptService {
             this.pollingInterval = null;
         }
         this.pollingSessionId = null;
-        this.currentBackoff =
-            this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;
+        this.currentBackoff = this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;
     }
     /**
      * Check if polling is active

package/dist/services/nodeExecutionService.d.ts

@@ -2,7 +2,7 @@
  * Node Execution Service
  * Handles fetching and managing node execution information from the backend
  */
-import type { NodeExecutionInfo } from "../types/index.js";
+import type { NodeExecutionInfo } from '../types/index.js';
 /**
  * Service for managing node execution information
  */

package/dist/services/nodeExecutionService.js

@@ -2,10 +2,10 @@
  * Node Execution Service
  * Handles fetching and managing node execution information from the backend
  */
-import { getEndpointConfig } from "./api.js";
-import { buildEndpointUrl } from "../config/endpoints.js";
-import { NODE_EXECUTION_CACHE_TIMEOUT_MS, PIPELINE_API_UNAVAILABLE_DURATION_MS, } from "../config/constants.js";
-import { logger } from "../utils/logger.js";
+import { getEndpointConfig } from './api.js';
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { NODE_EXECUTION_CACHE_TIMEOUT_MS, PIPELINE_API_UNAVAILABLE_DURATION_MS } from '../config/constants.js';
+import { logger } from '../utils/logger.js';
 /**
  * Service for managing node execution information
  */
@@ -33,9 +33,9 @@ export class NodeExecutionService {
         try {
             const endpointConfig = getEndpointConfig();
             if (!endpointConfig)
-                throw new Error("Endpoint config not available");
+                throw new Error('Endpoint config not available');
             const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.pipelines.get, {
-                id: pipelineId,
+                id: pipelineId
             });
             const response = await fetch(url);
             if (!response.ok) {
@@ -49,24 +49,24 @@ export class NodeExecutionService {
             const nodeStatus = nodeStatuses[nodeId];
             if (!nodeJob && !nodeStatus) {
                 return {
-                    status: "idle",
+                    status: 'idle',
                     executionCount: 0,
-                    isExecuting: false,
+                    isExecuting: false
                 };
             }
             const executionInfo = {
-                status: this.mapJobStatusToExecutionStatus(nodeStatus?.status || nodeJob?.status || "idle"),
+                status: this.mapJobStatusToExecutionStatus(nodeStatus?.status || nodeJob?.status || 'idle'),
                 executionCount: nodeJob?.execution_count || 0,
-                isExecuting: nodeStatus?.status === "running" || nodeJob?.status === "running",
+                isExecuting: nodeStatus?.status === 'running' || nodeJob?.status === 'running',
                 lastExecuted: nodeJob?.last_executed || nodeStatus?.last_executed,
                 lastExecutionDuration: nodeJob?.execution_time || nodeStatus?.execution_time,
-                lastError: nodeJob?.error || nodeStatus?.error,
+                lastError: nodeJob?.error || nodeStatus?.error
             };
             this.cache.set(nodeId, executionInfo);
             return executionInfo;
         }
         catch (error) {
-            logger.error("Failed to fetch node execution info:", error);
+            logger.error('Failed to fetch node execution info:', error);
             return null;
         }
     }
@@ -82,9 +82,9 @@ export class NodeExecutionService {
             const defaultExecutionInfo = {};
             nodeIds.forEach((nodeId) => {
                 defaultExecutionInfo[nodeId] = {
-                    status: "idle",
+                    status: 'idle',
                     executionCount: 0,
-                    isExecuting: false,
+                    isExecuting: false
                 };
             });
             return defaultExecutionInfo;
@@ -92,9 +92,9 @@ export class NodeExecutionService {
         try {
             const endpointConfig = getEndpointConfig();
             if (!endpointConfig)
-                throw new Error("Endpoint config not available");
+                throw new Error('Endpoint config not available');
             const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.pipelines.get, {
-                id: pipelineId,
+                id: pipelineId
             });
             const response = await fetch(url);
             if (!response.ok) {
@@ -103,14 +103,13 @@ export class NodeExecutionService {
                 if (response.status === 404) {
                     logger.warn(`Pipeline API endpoint not available for pipeline ${pipelineId}`);
                     this.apiUnavailable = true;
-                    this.apiUnavailableUntil =
-                        Date.now() + PIPELINE_API_UNAVAILABLE_DURATION_MS;
+                    this.apiUnavailableUntil = Date.now() + PIPELINE_API_UNAVAILABLE_DURATION_MS;
                     const defaultExecutionInfo = {};
                     nodeIds.forEach((nodeId) => {
                         defaultExecutionInfo[nodeId] = {
-                            status: "idle",
+                            status: 'idle',
                             executionCount: 0,
-                            isExecuting: false,
+                            isExecuting: false
                         };
                     });
                     return defaultExecutionInfo;
@@ -123,9 +122,9 @@ export class NodeExecutionService {
             // Initialize all nodes with default values
             nodeIds.forEach((nodeId) => {
                 executionInfoMap[nodeId] = {
-                    status: "idle",
+                    status: 'idle',
                     executionCount: 0,
-                    isExecuting: false,
+                    isExecuting: false
                 };
             });
             // Update with actual job data
@@ -135,10 +134,10 @@ export class NodeExecutionService {
                     executionInfoMap[nodeId] = {
                         status: this.mapJobStatusToExecutionStatus(job.status),
                         executionCount: job.execution_count || 0,
-                        isExecuting: job.status === "running",
+                        isExecuting: job.status === 'running',
                         lastExecuted: job.completed || job.started,
                         lastExecutionDuration: job.execution_time,
-                        lastError: job.error_message,
+                        lastError: job.error_message
                     };
                     // Update cache
                     this.cache.set(nodeId, executionInfoMap[nodeId]);
@@ -147,14 +146,14 @@ export class NodeExecutionService {
             return executionInfoMap;
         }
         catch (error) {
-            logger.error("Failed to fetch multiple node execution info:", error);
+            logger.error('Failed to fetch multiple node execution info:', error);
             // Return default values instead of empty object to prevent repeated calls
             const defaultExecutionInfo = {};
             nodeIds.forEach((nodeId) => {
                 defaultExecutionInfo[nodeId] = {
-                    status: "idle",
+                    status: 'idle',
                     executionCount: 0,
-                    isExecuting: false,
+                    isExecuting: false
                 };
             });
             return defaultExecutionInfo;
@@ -167,8 +166,8 @@ export class NodeExecutionService {
         try {
             const endpointConfig = getEndpointConfig();
             if (!endpointConfig)
-                throw new Error("Endpoint config not available");
-            const url = buildEndpointUrl(endpointConfig, "/node-execution-counts");
+                throw new Error('Endpoint config not available');
+            const url = buildEndpointUrl(endpointConfig, '/node-execution-counts');
             const response = await fetch(url);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
@@ -180,7 +179,7 @@ export class NodeExecutionService {
             return {};
         }
         catch (error) {
-            logger.error("Failed to fetch all node execution counts:", error);
+            logger.error('Failed to fetch all node execution counts:', error);
             return {};
         }
     }
@@ -219,10 +218,10 @@ export class NodeExecutionService {
         }
         else {
             this.cache.set(nodeId, {
-                status: "idle",
+                status: 'idle',
                 executionCount: 0,
                 isExecuting: false,
-                ...executionInfo,
+                ...executionInfo
             });
         }
     }
@@ -231,20 +230,20 @@ export class NodeExecutionService {
      */
     mapJobStatusToExecutionStatus(jobStatus) {
         switch (jobStatus) {
-            case "pending":
-                return "pending";
-            case "running":
-                return "running";
-            case "completed":
-                return "completed";
-            case "failed":
-                return "failed";
-            case "cancelled":
-                return "cancelled";
-            case "skipped":
-                return "skipped";
+            case 'pending':
+                return 'pending';
+            case 'running':
+                return 'running';
+            case 'completed':
+                return 'completed';
+            case 'failed':
+                return 'failed';
+            case 'cancelled':
+                return 'cancelled';
+            case 'skipped':
+                return 'skipped';
             default:
-                return "idle";
+                return 'idle';
         }
     }
     /**

package/dist/services/playgroundService.d.ts

@@ -6,7 +6,7 @@
  *
  * @module services/playgroundService
  */
-import type { PlaygroundSession, PlaygroundMessage, PlaygroundMessagesApiResponse, PlaygroundSessionStatus } from "../types/playground.js";
+import type { PlaygroundSession, PlaygroundMessage, PlaygroundMessagesApiResponse, PlaygroundSessionStatus } from '../types/playground.js';
 /**
  * Playground Service class
  *

package/dist/services/playgroundService.js

@@ -6,10 +6,10 @@
  *
  * @module services/playgroundService
  */
-import { defaultShouldStopPolling } from "../types/playground.js";
-import { buildEndpointUrl, getEndpointHeaders } from "../config/endpoints.js";
-import { getEndpointConfig } from "./api.js";
-import { logger } from "../utils/logger.js";
+import { defaultShouldStopPolling } from '../types/playground.js';
+import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
+import { getEndpointConfig } from './api.js';
+import { logger } from '../utils/logger.js';
 /**
  * Default polling interval in milliseconds
  */
@@ -51,7 +51,7 @@ export class PlaygroundService {
     getConfig() {
         const config = getEndpointConfig();
         if (!config) {
-            throw new Error("Endpoint configuration not set. Call setEndpointConfig() first.");
+            throw new Error('Endpoint configuration not set. Call setEndpointConfig() first.');
         }
         return config;
     }
@@ -64,13 +64,13 @@ export class PlaygroundService {
      */
     async request(url, options = {}) {
         const config = this.getConfig();
-        const headers = getEndpointHeaders(config, "playground");
+        const headers = getEndpointHeaders(config, 'playground');
         const response = await fetch(url, {
             ...options,
             headers: {
                 ...headers,
-                ...options.headers,
-            },
+                ...options.headers
+            }
         });
         if (!response.ok) {
             const errorData = await response.json().catch(() => ({}));
@@ -94,15 +94,15 @@ export class PlaygroundService {
     async listSessions(workflowId, options) {
         const config = this.getConfig();
         let url = buildEndpointUrl(config, config.endpoints.playground.listSessions, {
-            id: workflowId,
+            id: workflowId
         });
         // Add query parameters
         const params = new URLSearchParams();
         if (options?.limit !== undefined) {
-            params.append("limit", options.limit.toString());
+            params.append('limit', options.limit.toString());
         }
         if (options?.offset !== undefined) {
-            params.append("offset", options.offset.toString());
+            params.append('offset', options.offset.toString());
         }
         const queryString = params.toString();
         if (queryString) {
@@ -122,14 +122,14 @@ export class PlaygroundService {
     async createSession(workflowId, name, metadata) {
         const config = this.getConfig();
         const url = buildEndpointUrl(config, config.endpoints.playground.createSession, {
-            id: workflowId,
+            id: workflowId
         });
         const response = await this.request(url, {
-            method: "POST",
-            body: JSON.stringify({ name, metadata }),
+            method: 'POST',
+            body: JSON.stringify({ name, metadata })
         });
         if (!response.data) {
-            throw new Error("Failed to create session: No data returned");
+            throw new Error('Failed to create session: No data returned');
         }
         return response.data;
     }
@@ -142,11 +142,11 @@ export class PlaygroundService {
     async getSession(sessionId) {
         const config = this.getConfig();
         const url = buildEndpointUrl(config, config.endpoints.playground.getSession, {
-            sessionId,
+            sessionId
         });
         const response = await this.request(url);
         if (!response.data) {
-            throw new Error("Session not found");
+            throw new Error('Session not found');
         }
         return response.data;
     }
@@ -158,10 +158,10 @@ export class PlaygroundService {
     async deleteSession(sessionId) {
         const config = this.getConfig();
         const url = buildEndpointUrl(config, config.endpoints.playground.deleteSession, {
-            sessionId,
+            sessionId
         });
         await this.request(url, {
-            method: "DELETE",
+            method: 'DELETE'
         });
     }
     // =========================================================================
@@ -178,15 +178,15 @@ export class PlaygroundService {
     async getMessages(sessionId, since, limit) {
         const config = this.getConfig();
         let url = buildEndpointUrl(config, config.endpoints.playground.getMessages, {
-            sessionId,
+            sessionId
         });
         // Add query parameters
         const params = new URLSearchParams();
         if (since) {
-            params.append("since", since);
+            params.append('since', since);
         }
         if (limit !== undefined) {
-            params.append("limit", limit.toString());
+            params.append('limit', limit.toString());
         }
         const queryString = params.toString();
         if (queryString) {
@@ -205,18 +205,18 @@ export class PlaygroundService {
     async sendMessage(sessionId, content, inputs) {
         const config = this.getConfig();
         const url = buildEndpointUrl(config, config.endpoints.playground.sendMessage, {
-            sessionId,
+            sessionId
         });
         const requestBody = { content };
         if (inputs) {
             requestBody.inputs = inputs;
         }
         const response = await this.request(url, {
-            method: "POST",
-            body: JSON.stringify(requestBody),
+            method: 'POST',
+            body: JSON.stringify(requestBody)
         });
         if (!response.data) {
-            throw new Error("Failed to send message: No data returned");
+            throw new Error('Failed to send message: No data returned');
         }
         return response.data;
     }
@@ -228,10 +228,10 @@ export class PlaygroundService {
     async stopExecution(sessionId) {
         const config = this.getConfig();
         const url = buildEndpointUrl(config, config.endpoints.playground.stopExecution, {
-            sessionId,
+            sessionId
         });
         await this.request(url, {
-            method: "POST",
+            method: 'POST'
         });
     }
     // =========================================================================
@@ -274,7 +274,7 @@ export class PlaygroundService {
                 }
             }
             catch (error) {
-                logger.error("Polling error:", error);
+                logger.error('Polling error:', error);
                 // Exponential backoff on error
                 this.currentBackoff = Math.min(this.currentBackoff * 2, MAX_POLLING_BACKOFF);
             }

package/dist/services/portConfigApi.d.ts

@@ -2,8 +2,8 @@
  * Port Configuration API Service
  * Handles fetching port configuration from the backend
  */
-import type { PortConfig } from "../types/index.js";
-import type { EndpointConfig } from "../config/endpoints.js";
+import type { PortConfig } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
  * Fetch port configuration from API
  */

package/dist/services/portConfigApi.js

@@ -2,9 +2,9 @@
  * Port Configuration API Service
  * Handles fetching port configuration from the backend
  */
-import { buildEndpointUrl } from "../config/endpoints.js";
-import { DEFAULT_PORT_CONFIG } from "../config/defaultPortConfig.js";
-import { logger } from "../utils/logger.js";
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { DEFAULT_PORT_CONFIG } from '../config/defaultPortConfig.js';
+import { logger } from '../utils/logger.js';
 /**
  * Fetch port configuration from API
  */
@@ -12,7 +12,7 @@ export async function fetchPortConfig(endpointConfig) {
     try {
         const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.portConfig);
         const response = await fetch(url, {
-            headers: { "Content-Type": "application/json" },
+            headers: { 'Content-Type': 'application/json' }
         });
         if (!response.ok) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -21,13 +21,13 @@ export async function fetchPortConfig(endpointConfig) {
         const portConfig = data.data ?? data;
         // Validate the configuration has required fields
         if (!portConfig.dataTypes || !Array.isArray(portConfig.dataTypes)) {
-            logger.warn("Invalid port config received from API, using default");
+            logger.warn('Invalid port config received from API, using default');
             return DEFAULT_PORT_CONFIG;
         }
         return portConfig;
     }
     catch (error) {
-        logger.error("Error fetching port configuration:", error);
+        logger.error('Error fetching port configuration:', error);
         return DEFAULT_PORT_CONFIG;
     }
 }
@@ -35,13 +35,13 @@ export async function fetchPortConfig(endpointConfig) {
  * Validate port configuration structure
  */
 export function validatePortConfig(config) {
-    if (!config || typeof config !== "object") {
+    if (!config || typeof config !== 'object') {
         return false;
     }
     if (!config.dataTypes || !Array.isArray(config.dataTypes)) {
         return false;
     }
-    if (!config.defaultDataType || typeof config.defaultDataType !== "string") {
+    if (!config.defaultDataType || typeof config.defaultDataType !== 'string') {
         return false;
     }
     // Check that all data types have required fields

package/dist/services/settingsService.d.ts

@@ -7,8 +7,8 @@
  *
  * @module services/settingsService
  */
-import type { FlowDropSettings, PartialSettings } from "../types/settings.js";
-import type { EndpointConfig } from "../config/endpoints.js";
+import type { FlowDropSettings, PartialSettings } from '../types/settings.js';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
  * Set the endpoint configuration for settings API calls
  *