@flowdrop/flowdrop 1.0.0

package/dist/stores/interruptStore.svelte.js

@@ -0,0 +1,346 @@
+/**
+ * Interrupt Store (Svelte 5 Runes)
+ *
+ * Rune-based reactive state for managing interrupt state using a lightweight state machine.
+ * Ensures valid state transitions and prevents deadlocks.
+ *
+ * @module stores/interruptStore
+ */
+import { SvelteMap } from 'svelte/reactivity';
+import { initialState, transition, isTerminalState, isSubmitting as checkIsSubmitting, hasError as checkHasError, getErrorMessage, getResolvedValue, toLegacyStatus } from '../types/interruptState.js';
+import { logger } from '../utils/logger.js';
+// =========================================================================
+// Core Reactive State
+// =========================================================================
+/**
+ * Reactive map of all interrupts by ID.
+ * Uses SvelteMap for deep reactivity with Svelte 5 runes.
+ * Key: interrupt ID, Value: Interrupt object with state
+ */
+let interrupts = $state(new SvelteMap());
+// =========================================================================
+// Getter Functions (replace derived stores)
+// =========================================================================
+/**
+ * Get the reactive interrupts map.
+ * Use this in components within $derived() for reactivity.
+ */
+export function getInterruptsMap() {
+    return interrupts;
+}
+/**
+ * Get pending interrupt IDs (interrupts not in a terminal state)
+ */
+export function getPendingInterruptIds() {
+    const pending = [];
+    interrupts.forEach((interrupt, id) => {
+        if (!isTerminalState(interrupt.machineState)) {
+            pending.push(id);
+        }
+    });
+    return pending;
+}
+/**
+ * Get pending interrupts array (interrupts not in a terminal state)
+ */
+export function getPendingInterrupts() {
+    const pending = [];
+    interrupts.forEach((interrupt) => {
+        if (!isTerminalState(interrupt.machineState)) {
+            pending.push(interrupt);
+        }
+    });
+    return pending;
+}
+/**
+ * Get count of pending interrupts
+ */
+export function getPendingInterruptCount() {
+    return getPendingInterruptIds().length;
+}
+/**
+ * Get resolved interrupts array
+ */
+export function getResolvedInterrupts() {
+    const resolved = [];
+    interrupts.forEach((interrupt) => {
+        if (interrupt.machineState.status === 'resolved') {
+            resolved.push(interrupt);
+        }
+    });
+    return resolved;
+}
+/**
+ * Check if any interrupt is currently submitting
+ */
+export function getIsAnySubmitting() {
+    for (const interrupt of interrupts.values()) {
+        if (checkIsSubmitting(interrupt.machineState)) {
+            return true;
+        }
+    }
+    return false;
+}
+// =========================================================================
+// State Machine Actions
+// =========================================================================
+/**
+ * Apply a state machine action to an interrupt
+ *
+ * @param interruptId - The interrupt ID
+ * @param action - The action to apply
+ * @returns Transition result with validity and any errors
+ */
+function applyAction(interruptId, action) {
+    const interrupt = interrupts.get(interruptId);
+    if (!interrupt) {
+        return {
+            state: initialState,
+            valid: false,
+            error: `Interrupt not found: ${interruptId}`
+        };
+    }
+    const result = transition(interrupt.machineState, action);
+    if (result.valid) {
+        const current = interrupts.get(interruptId);
+        if (current) {
+            // Update machine state and sync legacy fields
+            const newInterrupt = {
+                ...current,
+                machineState: result.state,
+                status: toLegacyStatus(result.state),
+                responseValue: getResolvedValue(result.state) ?? current.responseValue,
+                resolvedAt: result.state.status === 'resolved'
+                    ? result.state.resolvedAt
+                    : result.state.status === 'cancelled'
+                        ? result.state.cancelledAt
+                        : current.resolvedAt
+            };
+            interrupts.set(interruptId, newInterrupt);
+        }
+    }
+    else {
+        logger.warn(`[InterruptStore] Invalid transition: ${result.error}`);
+    }
+    return result;
+}
+// =========================================================================
+// Public Actions
+// =========================================================================
+/**
+ * Interrupt store actions for modifying state
+ */
+export const interruptActions = {
+    /**
+     * Add or update an interrupt in the store
+     *
+     * @param interrupt - The interrupt to add or update
+     */
+    addInterrupt: (interrupt) => {
+        const existing = interrupts.get(interrupt.id);
+        // Preserve existing machine state if interrupt already exists
+        const machineState = existing?.machineState ?? initialState;
+        const interruptWithState = {
+            ...interrupt,
+            machineState
+        };
+        interrupts.set(interrupt.id, interruptWithState);
+    },
+    /**
+     * Add multiple interrupts to the store
+     *
+     * @param interruptList - Array of interrupts to add
+     */
+    addInterrupts: (interruptList) => {
+        if (interruptList.length === 0)
+            return;
+        interruptList.forEach((interrupt) => {
+            const existing = interrupts.get(interrupt.id);
+            const machineState = existing?.machineState ?? initialState;
+            const interruptWithState = {
+                ...interrupt,
+                machineState
+            };
+            interrupts.set(interrupt.id, interruptWithState);
+        });
+    },
+    /**
+     * Start submitting an interrupt (user clicked submit)
+     *
+     * @param interruptId - The interrupt ID
+     * @param value - The value being submitted
+     * @returns Transition result
+     */
+    startSubmit: (interruptId, value) => {
+        return applyAction(interruptId, { type: 'SUBMIT', value });
+    },
+    /**
+     * Start cancelling an interrupt (user clicked cancel)
+     *
+     * @param interruptId - The interrupt ID
+     * @returns Transition result
+     */
+    startCancel: (interruptId) => {
+        return applyAction(interruptId, { type: 'CANCEL' });
+    },
+    /**
+     * Mark submission as successful
+     *
+     * @param interruptId - The interrupt ID
+     * @returns Transition result
+     */
+    submitSuccess: (interruptId) => {
+        return applyAction(interruptId, { type: 'SUCCESS' });
+    },
+    /**
+     * Mark submission as failed
+     *
+     * @param interruptId - The interrupt ID
+     * @param error - Error message
+     * @returns Transition result
+     */
+    submitFailure: (interruptId, error) => {
+        return applyAction(interruptId, { type: 'FAILURE', error });
+    },
+    /**
+     * Retry a failed submission
+     *
+     * @param interruptId - The interrupt ID
+     * @returns Transition result
+     */
+    retry: (interruptId) => {
+        return applyAction(interruptId, { type: 'RETRY' });
+    },
+    /**
+     * Reset an interrupt to idle state
+     *
+     * @param interruptId - The interrupt ID
+     * @returns Transition result
+     */
+    resetInterrupt: (interruptId) => {
+        return applyAction(interruptId, { type: 'RESET' });
+    },
+    /**
+     * Mark an interrupt as resolved with the user's response
+     *
+     * @param interruptId - The interrupt ID
+     * @param value - The resolved value
+     */
+    resolveInterrupt: (interruptId, value) => {
+        const submitResult = applyAction(interruptId, { type: 'SUBMIT', value });
+        if (submitResult.valid) {
+            applyAction(interruptId, { type: 'SUCCESS' });
+        }
+    },
+    /**
+     * Mark an interrupt as cancelled
+     *
+     * @param interruptId - The interrupt ID
+     */
+    cancelInterrupt: (interruptId) => {
+        const cancelResult = applyAction(interruptId, { type: 'CANCEL' });
+        if (cancelResult.valid) {
+            applyAction(interruptId, { type: 'SUCCESS' });
+        }
+    },
+    /**
+     * Remove an interrupt from the store
+     *
+     * @param interruptId - The interrupt ID to remove
+     */
+    removeInterrupt: (interruptId) => {
+        interrupts.delete(interruptId);
+    },
+    /**
+     * Clear all interrupts for a specific session
+     *
+     * @param sessionId - The session ID to clear interrupts for
+     */
+    clearSessionInterrupts: (sessionId) => {
+        const toDelete = [];
+        interrupts.forEach((interrupt, id) => {
+            if (interrupt.sessionId === sessionId) {
+                toDelete.push(id);
+            }
+        });
+        toDelete.forEach((id) => interrupts.delete(id));
+    },
+    /**
+     * Alias for clearSessionInterrupts
+     */
+    clearInterrupts: () => {
+        interrupts.clear();
+    },
+    /**
+     * Reset all interrupt state
+     */
+    reset: () => {
+        interrupts.clear();
+    }
+};
+// =========================================================================
+// Utilities
+// =========================================================================
+/**
+ * Get an interrupt by ID
+ *
+ * @param interruptId - The interrupt ID
+ * @returns The interrupt or undefined
+ */
+export function getInterrupt(interruptId) {
+    return interrupts.get(interruptId);
+}
+/**
+ * Check if an interrupt is pending (not resolved or cancelled)
+ *
+ * @param interruptId - The interrupt ID
+ * @returns True if the interrupt exists and is pending
+ */
+export function isInterruptPending(interruptId) {
+    const interrupt = interrupts.get(interruptId);
+    return interrupt ? !isTerminalState(interrupt.machineState) : false;
+}
+/**
+ * Check if an interrupt is currently submitting
+ *
+ * @param interruptId - The interrupt ID
+ * @returns True if the interrupt is being submitted
+ */
+export function isInterruptSubmitting(interruptId) {
+    const interrupt = interrupts.get(interruptId);
+    return interrupt ? checkIsSubmitting(interrupt.machineState) : false;
+}
+/**
+ * Get the error for an interrupt
+ *
+ * @param interruptId - The interrupt ID
+ * @returns The error message or undefined
+ */
+export function getInterruptError(interruptId) {
+    const interrupt = interrupts.get(interruptId);
+    return interrupt ? getErrorMessage(interrupt.machineState) : undefined;
+}
+/**
+ * Get an interrupt by its associated message ID
+ *
+ * @param messageId - The message ID
+ * @returns The interrupt or undefined
+ */
+export function getInterruptByMessageId(messageId) {
+    for (const interrupt of interrupts.values()) {
+        if (interrupt.messageId === messageId) {
+            return interrupt;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if an interrupt has an error
+ *
+ * @param interruptId - The interrupt ID
+ * @returns True if the interrupt has an error
+ */
+export function interruptHasError(interruptId) {
+    const interrupt = interrupts.get(interruptId);
+    return interrupt ? checkHasError(interrupt.machineState) : false;
+}

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

@@ -0,0 +1,230 @@
+/**
+ * Playground Store
+ *
+ * Svelte 5 rune-based state for managing playground state including sessions,
+ * messages, and execution status.
+ *
+ * @module stores/playgroundStore
+ */
+import type { PlaygroundSession, PlaygroundMessage, PlaygroundInputField, PlaygroundSessionStatus, PlaygroundMessagesApiResponse } from '../types/playground.js';
+import type { Workflow } from '../types/index.js';
+/**
+ * Get the current session
+ */
+export declare function getCurrentSession(): PlaygroundSession | null;
+/**
+ * Get all sessions
+ */
+export declare function getSessions(): PlaygroundSession[];
+/**
+ * Get all messages
+ */
+export declare function getMessages(): PlaygroundMessage[];
+/**
+ * Get executing state
+ */
+export declare function getIsExecuting(): boolean;
+/**
+ * Get loading state
+ */
+export declare function getIsLoading(): boolean;
+/**
+ * Get error state
+ */
+export declare function getError(): string | null;
+/**
+ * Get the current workflow
+ */
+export declare function getCurrentWorkflow(): Workflow | null;
+/**
+ * Get the last poll timestamp
+ */
+export declare function getLastPollTimestamp(): string | null;
+/**
+ * Get current session status
+ */
+export declare function getSessionStatus(): PlaygroundSessionStatus;
+/**
+ * Get message count
+ */
+export declare function getMessageCount(): number;
+/**
+ * Get chat messages (excludes log messages)
+ */
+export declare function getChatMessages(): PlaygroundMessage[];
+/**
+ * Get log messages only
+ */
+export declare function getLogMessages(): PlaygroundMessage[];
+/**
+ * Get the latest message
+ */
+export declare function getLatestMessage(): PlaygroundMessage | null;
+/**
+ * Get input fields from workflow input nodes
+ *
+ * Analyzes the workflow to extract input nodes and their configuration
+ * schemas for auto-generating input forms.
+ */
+export declare function getInputFields(): PlaygroundInputField[];
+/**
+ * Check if workflow has a chat input
+ */
+export declare function getHasChatInput(): boolean;
+/**
+ * Get session count
+ */
+export declare function getSessionCount(): number;
+/**
+ * Playground store actions for modifying state
+ */
+export declare const playgroundActions: {
+    /**
+     * Set the current workflow
+     *
+     * @param workflow - The workflow to test
+     */
+    setWorkflow: (workflow: Workflow | null) => void;
+    /**
+     * Set the current session
+     *
+     * @param session - The session to set as active
+     */
+    setCurrentSession: (session: PlaygroundSession | null) => void;
+    /**
+     * Update session status
+     *
+     * @param status - The new status
+     */
+    updateSessionStatus: (status: PlaygroundSessionStatus) => void;
+    /**
+     * Set the sessions list
+     *
+     * @param sessionList - Array of sessions
+     */
+    setSessions: (sessionList: PlaygroundSession[]) => void;
+    /**
+     * Add a new session to the list
+     *
+     * @param session - The session to add
+     */
+    addSession: (session: PlaygroundSession) => void;
+    /**
+     * Remove a session from the list
+     *
+     * @param sessionId - The session ID to remove
+     */
+    removeSession: (sessionId: string) => void;
+    /**
+     * Set messages for the current session
+     * Messages are automatically sorted chronologically
+     *
+     * @param messageList - Array of messages
+     */
+    setMessages: (messageList: PlaygroundMessage[]) => void;
+    /**
+     * Add a message to the current session
+     * Messages are automatically sorted chronologically after adding
+     *
+     * @param message - The message to add
+     */
+    addMessage: (message: PlaygroundMessage) => void;
+    /**
+     * Add multiple messages to the current session
+     * Messages are deduplicated and automatically sorted chronologically
+     *
+     * @param newMessages - Array of messages to add
+     */
+    addMessages: (newMessages: PlaygroundMessage[]) => void;
+    /**
+     * Clear all messages
+     */
+    clearMessages: () => void;
+    /**
+     * Set the executing state
+     *
+     * @param executing - Whether execution is in progress
+     */
+    setExecuting: (executing: boolean) => void;
+    /**
+     * Set the loading state
+     *
+     * @param loading - Whether loading is in progress
+     */
+    setLoading: (loading: boolean) => void;
+    /**
+     * Set an error message
+     *
+     * @param errorMessage - The error message or null to clear
+     */
+    setError: (errorMessage: string | null) => void;
+    /**
+     * Update the last poll timestamp
+     *
+     * @param timestamp - ISO 8601 timestamp
+     */
+    updateLastPollTimestamp: (timestamp: string) => void;
+    /**
+     * Reset all playground state
+     */
+    reset: () => void;
+    /**
+     * Switch to a different session
+     *
+     * @param sessionId - The session ID to switch to
+     */
+    switchSession: (sessionId: string) => void;
+};
+/**
+ * Create a polling callback that processes poll responses.
+ * This is the single source of truth for how poll responses update stores.
+ * Used by mount.ts, Playground.svelte, and refreshSessionMessages.
+ *
+ * @param isTerminalStatus - Function to determine if a status clears isExecuting (default: defaultIsTerminalStatus)
+ * @returns A callback suitable for playgroundService.startPolling() or pushMessages()
+ */
+export declare function createPollingCallback(isTerminalStatus?: (status: PlaygroundSessionStatus) => boolean): (response: PlaygroundMessagesApiResponse) => void;
+/**
+ * Get the current session ID
+ *
+ * @returns The current session ID or null
+ */
+export declare function getCurrentSessionId(): string | null;
+/**
+ * Check if a specific session is selected
+ *
+ * @param sessionId - The session ID to check
+ * @returns True if the session is currently selected
+ */
+export declare function isSessionSelected(sessionId: string): boolean;
+/**
+ * Get all messages as a snapshot
+ *
+ * @returns Array of all messages
+ */
+export declare function getMessagesSnapshot(): PlaygroundMessage[];
+/**
+ * Get the latest message timestamp for polling
+ *
+ * @returns ISO 8601 timestamp of the latest message, or null
+ */
+export declare function getLatestMessageTimestamp(): string | null;
+/**
+ * Subscribe to session status changes using $effect.root.
+ * This is designed for use in non-component contexts (e.g., mount.ts).
+ *
+ * @param callback - Called when session status changes
+ * @returns Cleanup function to stop the subscription
+ */
+export declare function subscribeToSessionStatus(callback: (status: PlaygroundSessionStatus, previousStatus: PlaygroundSessionStatus) => void): () => void;
+/**
+ * Refresh messages for the current session
+ *
+ * This function is useful after interrupt resolution when polling
+ * has stopped but new messages may exist on the server.
+ *
+ * @param fetchMessages - Async function to fetch messages from the API
+ * @param isTerminalStatus - Optional override for terminal status check
+ * @returns Promise that resolves when messages are refreshed
+ */
+export declare function refreshSessionMessages(fetchMessages: (sessionId: string) => Promise<PlaygroundMessagesApiResponse>, isTerminalStatus?: (status: PlaygroundSessionStatus) => boolean): Promise<void>;