@flowdrop/flowdrop 1.4.0 → 1.5.0

package/dist/services/chatService.js

@@ -0,0 +1,131 @@
+/**
+ * Chat Service
+ *
+ * Handles API interactions for the LLM Chat feature including
+ * sending messages, retrieving history, and clearing history.
+ *
+ * @module services/chatService
+ */
+import { buildEndpointUrl, getEndpointHeaders } from "../config/endpoints.js";
+import { getEndpointConfig } from "./api.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Chat Service class
+ *
+ * Provides methods to interact with the chat API endpoints
+ * for LLM-powered workflow building assistance.
+ */
+export class ChatService {
+    static instance;
+    constructor() { }
+    /**
+     * Get the singleton instance of ChatService
+     *
+     * @returns The ChatService singleton instance
+     */
+    static getInstance() {
+        if (!ChatService.instance) {
+            ChatService.instance = new ChatService();
+        }
+        return ChatService.instance;
+    }
+    /**
+     * 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.");
+        }
+        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, "chat");
+        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);
+        }
+        const json = await response.json();
+        // Unwrap the { success, data } envelope used by the Drupal backend.
+        if (json && typeof json === "object" && "data" in json) {
+            return json.data;
+        }
+        return json;
+    }
+    // =========================================================================
+    // Chat Operations
+    // =========================================================================
+    /**
+     * Send a message to the chat endpoint
+     *
+     * @param workflowId - The workflow ID
+     * @param request - The chat request payload
+     * @returns The chat response from the LLM
+     */
+    async sendMessage(workflowId, request) {
+        const config = this.getConfig();
+        const url = buildEndpointUrl(config, config.endpoints.chat.sendMessage, {
+            id: workflowId,
+        });
+        logger.debug("[ChatService] Sending message to", url);
+        return this.request(url, {
+            method: "POST",
+            body: JSON.stringify(request),
+        });
+    }
+    /**
+     * Get conversation history for a workflow
+     *
+     * @param workflowId - The workflow ID
+     * @returns Array of chat history messages
+     */
+    async getHistory(workflowId) {
+        const config = this.getConfig();
+        const url = buildEndpointUrl(config, config.endpoints.chat.getHistory, {
+            id: workflowId,
+        });
+        logger.debug("[ChatService] Getting history from", url);
+        return this.request(url);
+    }
+    /**
+     * Clear conversation history for a workflow
+     *
+     * @param workflowId - The workflow ID
+     */
+    async clearHistory(workflowId) {
+        const config = this.getConfig();
+        const url = buildEndpointUrl(config, config.endpoints.chat.clearHistory, {
+            id: workflowId,
+        });
+        logger.debug("[ChatService] Clearing history at", url);
+        await fetch(url, {
+            method: "DELETE",
+            headers: getEndpointHeaders(config, "chat"),
+        });
+    }
+}
+/**
+ * Pre-instantiated ChatService singleton
+ */
+export const chatService = ChatService.getInstance();

package/dist/services/historyService.d.ts

@@ -140,8 +140,10 @@ export declare class HistoryService {
      * Cancel the current transaction without committing
      *
      * Discards the transaction without adding to history.
+     * Returns the snapshot captured at transaction start so the caller
+     * can restore the store to its pre-transaction state.
      */
-    cancelTransaction(): void;
+    cancelTransaction(): Workflow | null;
     /**
      * Clear all history
      *
@@ -189,9 +191,9 @@ export declare class HistoryService {
     /**
      * Create a deep clone of a workflow
      *
-     * Uses JSON parse/stringify to properly strip non-serializable values
-     * like functions (e.g., onConfigOpen callbacks) that are added to nodes
-     * at runtime but shouldn't be persisted in history.
+     * Strips non-serializable values (e.g., onConfigOpen callbacks) before cloning
+     * so structuredClone doesn't throw on function references.
+     * Falls back to JSON round-trip if structuredClone still fails (e.g., Svelte proxies).
      */
     private cloneWorkflow;
     /**

package/dist/services/historyService.js

@@ -182,11 +182,15 @@ export class HistoryService {
      * Cancel the current transaction without committing
      *
      * Discards the transaction without adding to history.
+     * Returns the snapshot captured at transaction start so the caller
+     * can restore the store to its pre-transaction state.
      */
     cancelTransaction() {
+        const snapshot = this.transactionSnapshot;
         this.inTransaction = false;
         this.transactionSnapshot = null;
         this.transactionDescription = null;
+        return snapshot;
     }
     /**
      * Clear all history
@@ -292,14 +296,25 @@ export class HistoryService {
     /**
      * Create a deep clone of a workflow
      *
-     * Uses JSON parse/stringify to properly strip non-serializable values
-     * like functions (e.g., onConfigOpen callbacks) that are added to nodes
-     * at runtime but shouldn't be persisted in history.
+     * Strips non-serializable values (e.g., onConfigOpen callbacks) before cloning
+     * so structuredClone doesn't throw on function references.
+     * Falls back to JSON round-trip if structuredClone still fails (e.g., Svelte proxies).
      */
     cloneWorkflow(workflow) {
-        // Always use JSON parse/stringify to strip functions and other non-serializable values
-        // structuredClone would fail on workflows containing callback functions
-        return JSON.parse(JSON.stringify(workflow));
+        const cleaned = {
+            ...workflow,
+            nodes: workflow.nodes.map((n) => ({
+                ...n,
+                data: { ...n.data, onConfigOpen: undefined },
+            })),
+        };
+        try {
+            return structuredClone(cleaned);
+        }
+        catch {
+            // Fallback for environments where structuredClone can't handle proxied objects
+            return JSON.parse(JSON.stringify(cleaned));
+        }
     }
     /**
      * Notify all subscribers of state changes

package/dist/stores/interruptStore.svelte.js

@@ -56,7 +56,12 @@ export function getPendingInterrupts() {
  * Get count of pending interrupts
  */
 export function getPendingInterruptCount() {
-    return getPendingInterruptIds().length;
+    let count = 0;
+    for (const interrupt of interrupts.values()) {
+        if (!isTerminalState(interrupt.machineState))
+            count++;
+    }
+    return count;
 }
 /**
  * Get resolved interrupts array

package/dist/stores/playgroundStore.svelte.d.ts

@@ -124,7 +124,7 @@ export declare const playgroundActions: {
     setMessages: (messageList: PlaygroundMessage[]) => void;
     /**
      * Add a message to the current session
-     * Messages are automatically sorted chronologically after adding
+     * Uses binary search insertion for O(log n) instead of full sort.
      *
      * @param message - The message to add
      */

package/dist/stores/playgroundStore.svelte.js

@@ -324,12 +324,21 @@ export const playgroundActions = {
     },
     /**
      * Add a message to the current session
-     * Messages are automatically sorted chronologically after adding
+     * Uses binary search insertion for O(log n) instead of full sort.
      *
      * @param message - The message to add
      */
     addMessage: (message) => {
-        _messages = sortMessagesChronologically([..._messages, message]);
+        const seq = message.sequenceNumber ?? 0;
+        let lo = 0, hi = _messages.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if ((_messages[mid].sequenceNumber ?? 0) <= seq)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        _messages = [..._messages.slice(0, lo), message, ..._messages.slice(lo)];
     },
     /**
      * Add multiple messages to the current session

package/dist/stores/portCoordinateStore.svelte.d.ts

@@ -36,6 +36,10 @@ export declare function updateNodePortCoordinates(node: WorkflowNodeType, getInt
  * @param nodeId - ID of the node to remove
  */
 export declare function removeNodePortCoordinates(nodeId: string): void;
+/**
+ * Clear all port coordinates (lifecycle cleanup).
+ */
+export declare function clearPortCoordinates(): void;
 /**
  * Get coordinates for a specific handle.
  *

package/dist/stores/portCoordinateStore.svelte.js

@@ -126,27 +126,19 @@ export function updateNodePortCoordinates(node, getInternalNode) {
     const internalNode = getInternalNode(node.id);
     if (!internalNode)
         return;
-    // Remove old entries for this node.
-    // untrack prevents this read from creating a reactive dependency on `coordinates`
-    // inside any $effect that calls this function — otherwise the effect would re-run
-    // every time we mutate `coordinates`, creating an infinite reactive loop during drag.
-    const keysToDelete = untrack(() => {
-        const keys = [];
+    // Build a new map with all entries except this node's, then add recomputed entries.
+    // Single assignment fires one reactive notification instead of N deletes + M sets.
+    const newMap = new SvelteMap();
+    untrack(() => {
         for (const [key, coord] of coordinates) {
-            if (coord.nodeId === node.id) {
-                keys.push(key);
-            }
+            if (coord.nodeId !== node.id)
+                newMap.set(key, coord);
         }
-        return keys;
     });
-    for (const key of keysToDelete) {
-        coordinates.delete(key);
-    }
-    // Add new entries
-    const coords = computeNodePortCoordinates(node, internalNode);
-    for (const coord of coords) {
-        coordinates.set(coord.handleId, coord);
+    for (const coord of computeNodePortCoordinates(node, internalNode)) {
+        newMap.set(coord.handleId, coord);
     }
+    coordinates = newMap;
 }
 /**
  * Remove all coordinates for a node (on node delete).
@@ -154,18 +146,20 @@ export function updateNodePortCoordinates(node, getInternalNode) {
  * @param nodeId - ID of the node to remove
  */
 export function removeNodePortCoordinates(nodeId) {
-    const keysToDelete = untrack(() => {
-        const keys = [];
+    const newMap = new SvelteMap();
+    untrack(() => {
         for (const [key, coord] of coordinates) {
-            if (coord.nodeId === nodeId) {
-                keys.push(key);
-            }
+            if (coord.nodeId !== nodeId)
+                newMap.set(key, coord);
         }
-        return keys;
     });
-    for (const key of keysToDelete) {
-        coordinates.delete(key);
-    }
+    coordinates = newMap;
+}
+/**
+ * Clear all port coordinates (lifecycle cleanup).
+ */
+export function clearPortCoordinates() {
+    coordinates = new SvelteMap();
 }
 /**
  * Get coordinates for a specific handle.

package/dist/stores/workflowStore.svelte.d.ts

@@ -22,6 +22,10 @@ export declare function getWorkflowStore(): Workflow | null;
 /**
  * Get the current dirty state reactively
  *
+ * Reads both _editVersion and _savedVersion, so Svelte tracks them
+ * as reactive dependencies — any component using this will re-render
+ * when dirty state changes.
+ *
  * @returns true if there are unsaved changes
  */
 export declare function getIsDirty(): boolean;
@@ -121,9 +125,10 @@ export declare function setOnDirtyStateChange(callback: ((isDirty: boolean) => v
  */
 export declare function setOnWorkflowChange(callback: ((workflow: Workflow, changeType: WorkflowChangeType) => void) | null): void;
 /**
- * Mark the current workflow state as saved
+ * Mark the current workflow state as saved.
  *
- * Clears the dirty state by updating the saved snapshot.
+ * Captures the current edit version so isDirty becomes false.
+ * Call this after a successful backend save.
  */
 export declare function markAsSaved(): void;
 /**
@@ -132,6 +137,19 @@ export declare function markAsSaved(): void;
  * @returns true if there are unsaved changes
  */
 export declare function isDirty(): boolean;
+/**
+ * Get the current edit version.
+ *
+ * Use this for the save verification protocol:
+ * 1. Before save: `const v = getEditVersion()`
+ * 2. Include `v` in the save request payload
+ * 3. Backend echoes `v` in the response
+ * 4. If echoed version matches: `markAsSaved()`
+ * 5. If not: the save didn't persist the version you submitted — reset from backend response
+ *
+ * @returns The current monotonic edit version
+ */
+export declare function getEditVersion(): number;
 /**
  * Enable or disable history recording
  *
@@ -246,6 +264,17 @@ export declare const workflowActions: {
         description?: string;
         metadata?: Partial<Workflow["metadata"]>;
     }) => void;
+    /**
+     * Swap a node — atomically replaces nodes and edges with a descriptive history entry.
+     *
+     * Unlike batchUpdate, this uses `"node_swap"` as the change type and
+     * records a meaningful description for the undo history.
+     */
+    swapNode: (updates: {
+        nodes: WorkflowNode[];
+        edges: WorkflowEdge[];
+        description?: string;
+    }) => void;
     /**
      * Push current state to history manually
      *