@flowdrop/flowdrop 1.0.1 → 1.2.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,7 +29,8 @@ 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
@@ -49,7 +50,8 @@ 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
@@ -77,10 +79,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;
     }
@@ -93,13 +95,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(() => ({}));
@@ -122,11 +124,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;
     }
@@ -140,15 +142,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;
     }
@@ -161,13 +163,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;
     }
@@ -180,7 +182,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 ?? [];
@@ -194,7 +196,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 ?? [];
@@ -213,29 +215,32 @@ 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
@@ -255,7 +260,8 @@ 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,13 +103,14 @@ 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;
@@ -122,9 +123,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
@@ -134,10 +135,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]);
@@ -146,14 +147,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;
@@ -166,8 +167,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}`);
@@ -179,7 +180,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 {};
         }
     }
@@ -218,10 +219,10 @@ export class NodeExecutionService {
         }
         else {
             this.cache.set(nodeId, {
-                status: 'idle',
+                status: "idle",
                 executionCount: 0,
                 isExecuting: false,
-                ...executionInfo
+                ...executionInfo,
             });
         }
     }
@@ -230,20 +231,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
  *