@d34dman/flowdrop 0.0.36 → 0.0.38

package/dist/playground/mount.js

@@ -43,13 +43,13 @@
  * })(Drupal, window.FlowDrop);
  * ```
  */
-import { mount, unmount } from "svelte";
-import Playground from "../components/playground/Playground.svelte";
-import PlaygroundModal from "../components/playground/PlaygroundModal.svelte";
-import { setEndpointConfig } from "../services/api.js";
-import { playgroundService } from "../services/playgroundService.js";
-import { currentSession, sessions, messages, playgroundActions } from "../stores/playgroundStore.js";
-import { get } from "svelte/store";
+import { mount, unmount } from 'svelte';
+import Playground from '../components/playground/Playground.svelte';
+import PlaygroundModal from '../components/playground/PlaygroundModal.svelte';
+import { setEndpointConfig } from '../services/api.js';
+import { playgroundService } from '../services/playgroundService.js';
+import { currentSession, sessions, messages, playgroundActions } from '../stores/playgroundStore.js';
+import { get } from 'svelte/store';
 /**
  * Mount the Playground component in a container
  *
@@ -80,23 +80,23 @@ import { get } from "svelte/store";
  * ```
  */
 export async function mountPlayground(container, options) {
-    const { workflowId, workflow, mode = "standalone", initialSessionId, endpointConfig, config = {}, height = "100%", width = "100%", onClose } = options;
+    const { workflowId, workflow, mode = 'standalone', initialSessionId, endpointConfig, config = {}, height = '100%', width = '100%', onClose } = options;
     // Validate required parameters
     if (!workflowId) {
-        throw new Error("workflowId is required for mountPlayground()");
+        throw new Error('workflowId is required for mountPlayground()');
     }
     if (!container) {
-        throw new Error("container element is required for mountPlayground()");
+        throw new Error('container element is required for mountPlayground()');
     }
     // Validate onClose for modal mode
-    if (mode === "modal" && !onClose) {
-        throw new Error("onClose callback is required for modal mode");
+    if (mode === 'modal' && !onClose) {
+        throw new Error('onClose callback is required for modal mode');
     }
     // Set endpoint configuration if provided
     let finalEndpointConfig;
     if (endpointConfig) {
         // Merge with default configuration to ensure all required endpoints are present
-        const { defaultEndpointConfig } = await import("../config/endpoints.js");
+        const { defaultEndpointConfig } = await import('../config/endpoints.js');
         finalEndpointConfig = {
             ...defaultEndpointConfig,
             ...endpointConfig,
@@ -111,7 +111,7 @@ export async function mountPlayground(container, options) {
     // For modal mode, PlaygroundModal creates its own backdrop, so we mount directly to body
     // For other modes, use the provided container
     let targetContainer = container;
-    if (mode === "modal") {
+    if (mode === 'modal') {
         // For modal mode, create a container in the body
         // PlaygroundModal will handle the backdrop itself
         targetContainer = document.body;
@@ -122,10 +122,12 @@ export async function mountPlayground(container, options) {
         container.style.width = width;
     }
     // Mount the appropriate component
-    const svelteApp = mount(mode === "modal" ? PlaygroundModal : Playground, {
-        target: targetContainer,
-        props: mode === "modal"
-            ? {
+    // Separate the mount calls to avoid TypeScript inference issues with different props types
+    let svelteApp;
+    if (mode === 'modal') {
+        svelteApp = mount(PlaygroundModal, {
+            target: targetContainer,
+            props: {
                 isOpen: true,
                 workflowId,
                 workflow,
@@ -138,7 +140,12 @@ export async function mountPlayground(container, options) {
                     }
                 }
             }
-            : {
+        });
+    }
+    else {
+        svelteApp = mount(Playground, {
+            target: targetContainer,
+            props: {
                 workflowId,
                 workflow,
                 mode,
@@ -147,12 +154,13 @@ export async function mountPlayground(container, options) {
                 config,
                 onClose
             }
-    });
+        });
+    }
     // Store state for cleanup
     const state = {
         svelteApp,
         container: targetContainer,
-        originalContainer: mode === "modal" ? container : undefined,
+        originalContainer: mode === 'modal' ? container : undefined,
         workflowId
     };
     // Create the mounted playground interface
@@ -203,7 +211,7 @@ export async function mountPlayground(container, options) {
  * ```
  */
 export function unmountPlayground(app) {
-    if (app && typeof app.destroy === "function") {
+    if (app && typeof app.destroy === 'function') {
         app.destroy();
     }
 }

package/dist/services/interruptService.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Interrupt Service
+ *
+ * Handles API interactions for Human-in-the-Loop (HITL) interrupts,
+ * including fetching interrupt details, resolving interrupts with user
+ * responses, and optional dedicated polling for interrupt status.
+ *
+ * @module services/interruptService
+ */
+import type { Interrupt, InterruptPollingConfig } from '../types/interrupt.js';
+/**
+ * Interrupt Service class
+ *
+ * Provides methods to interact with interrupt API endpoints including
+ * fetching, resolving, cancelling, and listing interrupts.
+ * Supports optional dedicated polling for interrupt status.
+ */
+export declare class InterruptService {
+    private static instance;
+    private pollingInterval;
+    private pollingSessionId;
+    private currentBackoff;
+    private pollingConfig;
+    /**
+     * Private constructor for singleton pattern
+     */
+    private constructor();
+    /**
+     * Get the singleton instance of InterruptService
+     *
+     * @returns The InterruptService singleton instance
+     */
+    static getInstance(): InterruptService;
+    /**
+     * Configure interrupt polling settings
+     *
+     * @param config - Polling configuration options
+     */
+    setPollingConfig(config: Partial<InterruptPollingConfig>): void;
+    /**
+     * Get the current polling configuration
+     *
+     * @returns Current polling configuration
+     */
+    getPollingConfig(): InterruptPollingConfig;
+    /**
+     * Check if interrupt endpoints are configured
+     *
+     * @returns True if interrupt endpoints are available
+     */
+    isConfigured(): boolean;
+    /**
+     * Get the endpoint configuration
+     *
+     * @throws Error if endpoint configuration is not set
+     * @returns The endpoint configuration
+     */
+    private getConfig;
+    /**
+     * Generic API request helper
+     *
+     * @param url - The URL to fetch
+     * @param options - Fetch options
+     * @returns The parsed JSON response
+     */
+    private request;
+    /**
+     * Get interrupt details by ID
+     *
+     * @param interruptId - The interrupt UUID
+     * @returns The interrupt details
+     */
+    getInterrupt(interruptId: string): Promise<Interrupt>;
+    /**
+     * Resolve an interrupt with user response
+     *
+     * @param interruptId - The interrupt UUID
+     * @param value - The user's response value
+     * @returns The updated interrupt
+     */
+    resolveInterrupt(interruptId: string, value: unknown): Promise<Interrupt>;
+    /**
+     * Cancel a pending interrupt
+     *
+     * @param interruptId - The interrupt UUID
+     * @returns The updated interrupt
+     */
+    cancelInterrupt(interruptId: string): Promise<Interrupt>;
+    /**
+     * List interrupts for a playground session
+     *
+     * @param sessionId - The session UUID
+     * @returns Array of interrupts for the session
+     */
+    listSessionInterrupts(sessionId: string): Promise<Interrupt[]>;
+    /**
+     * List interrupts for a pipeline
+     *
+     * @param pipelineId - The pipeline UUID
+     * @returns Array of interrupts for the pipeline
+     */
+    listPipelineInterrupts(pipelineId: string): Promise<Interrupt[]>;
+    /**
+     * Start polling for interrupts in a session
+     *
+     * This is optional - interrupts are typically detected via message metadata.
+     * Use this for scenarios where dedicated polling is preferred.
+     *
+     * @param sessionId - The session UUID to poll
+     * @param callback - Callback function to handle new interrupts
+     */
+    startPolling(sessionId: string, callback: (interrupts: Interrupt[]) => void): void;
+    /**
+     * Stop polling for interrupts
+     */
+    stopPolling(): void;
+    /**
+     * Check if polling is active
+     *
+     * @returns True if polling is active
+     */
+    isPolling(): boolean;
+    /**
+     * Get the current polling session ID
+     *
+     * @returns The session ID being polled, or null
+     */
+    getPollingSessionId(): string | null;
+}
+/**
+ * Export singleton instance
+ */
+export declare const interruptService: InterruptService;

package/dist/services/interruptService.js

@@ -0,0 +1,279 @@
+/**
+ * Interrupt Service
+ *
+ * Handles API interactions for Human-in-the-Loop (HITL) interrupts,
+ * including fetching interrupt details, resolving interrupts with user
+ * responses, and optional dedicated polling for interrupt status.
+ *
+ * @module services/interruptService
+ */
+import { defaultInterruptPollingConfig } from '../types/interrupt.js';
+import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
+import { getEndpointConfig } from './api.js';
+/**
+ * Interrupt Service class
+ *
+ * Provides methods to interact with interrupt API endpoints including
+ * fetching, resolving, cancelling, and listing interrupts.
+ * Supports optional dedicated polling for interrupt status.
+ */
+export class InterruptService {
+    static instance;
+    pollingInterval = null;
+    pollingSessionId = null;
+    currentBackoff;
+    pollingConfig;
+    /**
+     * Private constructor for singleton pattern
+     */
+    constructor() {
+        this.pollingConfig = { ...defaultInterruptPollingConfig };
+        this.currentBackoff = this.pollingConfig.interval ?? 2000;
+    }
+    /**
+     * Get the singleton instance of InterruptService
+     *
+     * @returns The InterruptService singleton instance
+     */
+    static getInstance() {
+        if (!InterruptService.instance) {
+            InterruptService.instance = new InterruptService();
+        }
+        return InterruptService.instance;
+    }
+    /**
+     * Configure interrupt polling settings
+     *
+     * @param config - Polling configuration options
+     */
+    setPollingConfig(config) {
+        this.pollingConfig = { ...this.pollingConfig, ...config };
+        this.currentBackoff = this.pollingConfig.interval ?? 2000;
+    }
+    /**
+     * Get the current polling configuration
+     *
+     * @returns Current polling configuration
+     */
+    getPollingConfig() {
+        return { ...this.pollingConfig };
+    }
+    /**
+     * Check if interrupt endpoints are configured
+     *
+     * @returns True if interrupt endpoints are available
+     */
+    isConfigured() {
+        const config = getEndpointConfig();
+        return Boolean(config?.endpoints?.interrupts);
+    }
+    /**
+     * Get the endpoint configuration
+     *
+     * @throws Error if endpoint configuration is not set
+     * @returns The endpoint configuration
+     */
+    getConfig() {
+        const config = getEndpointConfig();
+        if (!config) {
+            throw new Error('Endpoint configuration not set. Call setEndpointConfig() first.');
+        }
+        if (!config.endpoints.interrupts) {
+            throw new Error('Interrupt endpoints not configured.');
+        }
+        return config;
+    }
+    /**
+     * Generic API request helper
+     *
+     * @param url - The URL to fetch
+     * @param options - Fetch options
+     * @returns The parsed JSON response
+     */
+    async request(url, options = {}) {
+        const config = this.getConfig();
+        const headers = getEndpointHeaders(config, 'interrupts');
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                ...headers,
+                ...options.headers
+            }
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            const errorMessage = errorData.error ||
+                errorData.message ||
+                `HTTP ${response.status}: ${response.statusText}`;
+            throw new Error(errorMessage);
+        }
+        return response.json();
+    }
+    // =========================================================================
+    // Interrupt Operations
+    // =========================================================================
+    /**
+     * Get interrupt details by ID
+     *
+     * @param interruptId - The interrupt UUID
+     * @returns The interrupt details
+     */
+    async getInterrupt(interruptId) {
+        const config = this.getConfig();
+        const url = buildEndpointUrl(config, config.endpoints.interrupts.get, {
+            interruptId
+        });
+        const response = await this.request(url);
+        if (!response.data) {
+            throw new Error('Interrupt not found');
+        }
+        return response.data;
+    }
+    /**
+     * Resolve an interrupt with user response
+     *
+     * @param interruptId - The interrupt UUID
+     * @param value - The user's response value
+     * @returns The updated interrupt
+     */
+    async resolveInterrupt(interruptId, value) {
+        const config = this.getConfig();
+        const url = buildEndpointUrl(config, config.endpoints.interrupts.resolve, {
+            interruptId
+        });
+        const resolution = { value };
+        const response = await this.request(url, {
+            method: 'POST',
+            body: JSON.stringify(resolution)
+        });
+        if (!response.data) {
+            throw new Error('Failed to resolve interrupt: No data returned');
+        }
+        return response.data;
+    }
+    /**
+     * Cancel a pending interrupt
+     *
+     * @param interruptId - The interrupt UUID
+     * @returns The updated interrupt
+     */
+    async cancelInterrupt(interruptId) {
+        const config = this.getConfig();
+        const url = buildEndpointUrl(config, config.endpoints.interrupts.cancel, {
+            interruptId
+        });
+        const response = await this.request(url, {
+            method: 'POST'
+        });
+        if (!response.data) {
+            throw new Error('Failed to cancel interrupt: No data returned');
+        }
+        return response.data;
+    }
+    /**
+     * List interrupts for a playground session
+     *
+     * @param sessionId - The session UUID
+     * @returns Array of interrupts for the session
+     */
+    async listSessionInterrupts(sessionId) {
+        const config = this.getConfig();
+        const url = buildEndpointUrl(config, config.endpoints.interrupts.listBySession, {
+            sessionId
+        });
+        const response = await this.request(url);
+        return response.data ?? [];
+    }
+    /**
+     * List interrupts for a pipeline
+     *
+     * @param pipelineId - The pipeline UUID
+     * @returns Array of interrupts for the pipeline
+     */
+    async listPipelineInterrupts(pipelineId) {
+        const config = this.getConfig();
+        const url = buildEndpointUrl(config, config.endpoints.interrupts.listByPipeline, {
+            pipelineId
+        });
+        const response = await this.request(url);
+        return response.data ?? [];
+    }
+    // =========================================================================
+    // Polling (Optional)
+    // =========================================================================
+    /**
+     * Start polling for interrupts in a session
+     *
+     * This is optional - interrupts are typically detected via message metadata.
+     * Use this for scenarios where dedicated polling is preferred.
+     *
+     * @param sessionId - The session UUID to poll
+     * @param callback - Callback function to handle new interrupts
+     */
+    startPolling(sessionId, callback) {
+        if (!this.pollingConfig.enabled) {
+            console.warn('[InterruptService] Polling is disabled. Enable via setPollingConfig().');
+            return;
+        }
+        // Stop any existing polling
+        this.stopPolling();
+        this.pollingSessionId = sessionId;
+        this.currentBackoff = this.pollingConfig.interval ?? 2000;
+        const poll = async () => {
+            if (this.pollingSessionId !== sessionId) {
+                return;
+            }
+            try {
+                const interrupts = await this.listSessionInterrupts(sessionId);
+                const pendingInterrupts = interrupts.filter((i) => i.status === 'pending');
+                // Reset backoff on successful request
+                this.currentBackoff = this.pollingConfig.interval ?? 2000;
+                // Call the callback with pending interrupts
+                callback(pendingInterrupts);
+            }
+            catch (error) {
+                console.error('[InterruptService] Polling error:', error);
+                // Exponential backoff on error
+                const maxBackoff = this.pollingConfig.maxBackoff ?? 10000;
+                this.currentBackoff = Math.min(this.currentBackoff * 2, maxBackoff);
+            }
+            // Schedule next poll
+            if (this.pollingSessionId === sessionId) {
+                this.pollingInterval = setTimeout(poll, this.currentBackoff);
+            }
+        };
+        // Start polling immediately
+        void poll();
+    }
+    /**
+     * Stop polling for interrupts
+     */
+    stopPolling() {
+        if (this.pollingInterval) {
+            clearTimeout(this.pollingInterval);
+            this.pollingInterval = null;
+        }
+        this.pollingSessionId = null;
+        this.currentBackoff = this.pollingConfig.interval ?? 2000;
+    }
+    /**
+     * Check if polling is active
+     *
+     * @returns True if polling is active
+     */
+    isPolling() {
+        return this.pollingSessionId !== null;
+    }
+    /**
+     * Get the current polling session ID
+     *
+     * @returns The session ID being polled, or null
+     */
+    getPollingSessionId() {
+        return this.pollingSessionId;
+    }
+}
+/**
+ * Export singleton instance
+ */
+export const interruptService = InterruptService.getInstance();