@flowdrop/flowdrop 2.0.0-beta.1 → 2.0.0-beta.3

package/dist/registry/builtinNodes.js

@@ -6,6 +6,7 @@
  * ensuring all built-in node types are available without user action.
  */
 import {} from './nodeComponentRegistry.js';
+import { FLOWDROP_SOURCE } from './builtinNodeTypes.js';
 import WorkflowNode from '../components/nodes/WorkflowNode.svelte';
 import SimpleNode from '../components/nodes/SimpleNode.svelte';
 import SquareNode from '../components/nodes/SquareNode.svelte';
@@ -15,10 +16,11 @@ import GatewayNode from '../components/nodes/GatewayNode.svelte';
 import NotesNode from '../components/nodes/NotesNode.svelte';
 import TerminalNode from '../components/nodes/TerminalNode.svelte';
 import IdeaNode from '../components/nodes/IdeaNode.svelte';
-/**
- * Source identifier for built-in FlowDrop components
- */
-export const FLOWDROP_SOURCE = 'flowdrop';
+// Pure type metadata + resolution helpers are re-exported for backward
+// compatibility — they now live in a component-free module so that
+// type-only consumers (e.g. utils/nodeTypes.ts, reachable from `core`) do
+// not statically pull in the node components below.
+export { FLOWDROP_SOURCE, BUILTIN_TYPE_ALIASES, BUILTIN_NODE_TYPES, resolveBuiltinAlias, isBuiltinType, getBuiltinTypes } from './builtinNodeTypes.js';
 /**
  * Built-in FlowDrop node component registrations.
  * These are the default node types that ship with FlowDrop.
@@ -124,52 +126,3 @@ export const BUILTIN_NODE_COMPONENTS = [
         statusSize: 'sm'
     }
 ];
-/**
- * Alias mapping for type resolution.
- * Maps alternative type names to their canonical registration.
- */
-export const BUILTIN_TYPE_ALIASES = {
-    default: 'workflowNode'
-};
-/**
- * Get the canonical type for a given type string.
- * Handles aliases like "default" -> "workflowNode".
- *
- * @param type - The type string to resolve
- * @returns The canonical type string
- */
-export function resolveBuiltinAlias(type) {
-    return BUILTIN_TYPE_ALIASES[type] ?? type;
-}
-/**
- * Check if a type is a built-in FlowDrop type.
- *
- * @param type - The type to check
- * @returns true if this is a built-in type
- */
-export function isBuiltinType(type) {
-    const canonicalType = resolveBuiltinAlias(type);
-    return BUILTIN_NODE_COMPONENTS.some((reg) => reg.type === canonicalType);
-}
-/**
- * Get all built-in type identifiers.
- *
- * @returns Array of built-in type strings
- */
-export function getBuiltinTypes() {
-    return BUILTIN_NODE_COMPONENTS.map((reg) => reg.type);
-}
-/**
- * Array of built-in type strings for runtime validation.
- */
-export const BUILTIN_NODE_TYPES = [
-    'workflowNode',
-    'simple',
-    'square',
-    'atom',
-    'tool',
-    'gateway',
-    'note',
-    'terminal',
-    'idea'
-];

package/dist/services/agentSpecExecutionService.d.ts

@@ -102,5 +102,3 @@ export declare class AgentSpecExecutionService {
     private mapSingleNodeStatus;
     private mapToFlowDropStatus;
 }
-/** Singleton instance */
-export declare const agentSpecExecutionService: AgentSpecExecutionService;

package/dist/services/agentSpecExecutionService.js

@@ -332,5 +332,3 @@ export class AgentSpecExecutionService {
         }
     }
 }
-/** Singleton instance */
-export const agentSpecExecutionService = AgentSpecExecutionService.getInstance();

package/dist/services/apiVariableService.js

@@ -5,8 +5,8 @@
  *
  * @module services/apiVariableService
  */
-import { logger } from '../utils/logger.js';
 import { DEFAULT_CACHE_TTL_MS } from '../config/constants.js';
+import { authenticatedFetch } from '../utils/fetchWithAuth.js';
 /**
  * Variable schema cache with TTL support
  * Key format: `variables:{workflowId}:{nodeId}`
@@ -142,25 +142,9 @@ export async function fetchVariableSchema(endpointConfig, workflowId, nodeId, co
     // Prepare request options
     const method = endpoint.method ?? 'GET';
     const timeout = endpoint.timeout ?? 30000;
-    const headers = {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-        ...endpoint.headers
-    };
-    // Add auth headers from AuthProvider if available
-    if (authProvider) {
-        try {
-            const authHeaders = await authProvider.getAuthHeaders();
-            Object.assign(headers, authHeaders);
-        }
-        catch (error) {
-            logger.warn('Failed to get auth headers:', error);
-        }
-    }
     // Prepare fetch options
     const fetchOptions = {
         method,
-        headers,
         signal: AbortSignal.timeout(timeout)
     };
     // Add body for non-GET requests
@@ -169,7 +153,16 @@ export async function fetchVariableSchema(endpointConfig, workflowId, nodeId, co
         fetchOptions.body = JSON.stringify(resolvedBody);
     }
     try {
-        const response = await fetch(url, fetchOptions);
+        // authenticatedFetch merges auth headers and transparently refreshes +
+        // retries once on 401 via the provider's onUnauthorized hook.
+        const response = await authenticatedFetch(url, fetchOptions, {
+            authProvider,
+            baseHeaders: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                ...endpoint.headers
+            }
+        });
         // Handle 404 as "no variables available"
         if (response.status === 404) {
             return {
@@ -179,15 +172,8 @@ export async function fetchVariableSchema(endpointConfig, workflowId, nodeId, co
             };
         }
         if (!response.ok) {
-            // Handle authentication errors
+            // Auth errors remain after the provider's refresh attempt.
             if (response.status === 401 || response.status === 403) {
-                if (authProvider?.onUnauthorized) {
-                    const refreshed = await authProvider.onUnauthorized();
-                    if (refreshed) {
-                        // Retry with refreshed auth
-                        return fetchVariableSchema(endpointConfig, workflowId, nodeId, config, authProvider);
-                    }
-                }
                 return {
                     success: false,
                     error: 'Authentication failed'

package/dist/services/categoriesApi.js

@@ -2,7 +2,8 @@
  * Categories API Service
  * Handles fetching category definitions from the backend
  */
-import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { authenticatedFetch } from '../utils/fetchWithAuth.js';
 import { DEFAULT_CATEGORIES } from '../config/defaultCategories.js';
 import { logger } from '../utils/logger.js';
 /**
@@ -11,11 +12,7 @@ import { logger } from '../utils/logger.js';
 export async function fetchCategories(endpointConfig, authProvider) {
     try {
         const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.categories);
-        const configHeaders = getEndpointHeaders(endpointConfig, 'categories');
-        const authHeaders = authProvider ? await authProvider.getAuthHeaders() : {};
-        const response = await fetch(url, {
-            headers: { ...configHeaders, ...authHeaders }
-        });
+        const response = await authenticatedFetch(url, {}, { config: endpointConfig, endpointKey: 'categories', authProvider });
         if (!response.ok) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
         }

package/dist/services/chatService.d.ts

@@ -8,6 +8,7 @@
  */
 import type { ChatRequest, ChatResponse, ChatHistoryMessage } from '../types/chat.js';
 import type { EndpointConfig } from '../config/endpoints.js';
+import type { AuthProvider } from '../types/auth.js';
 /**
  * Chat Service class
  *
@@ -48,20 +49,20 @@ export declare class ChatService {
      * @param request - The chat request payload
      * @returns The chat response from the LLM
      */
-    sendMessage(endpointConfig: EndpointConfig | null, workflowId: string, request: ChatRequest): Promise<ChatResponse>;
+    sendMessage(endpointConfig: EndpointConfig | null, workflowId: string, request: ChatRequest, authProvider?: AuthProvider): Promise<ChatResponse>;
     /**
      * Get conversation history for a workflow
      *
      * @param workflowId - The workflow ID
      * @returns Array of chat history messages
      */
-    getHistory(endpointConfig: EndpointConfig | null, workflowId: string): Promise<ChatHistoryMessage[]>;
+    getHistory(endpointConfig: EndpointConfig | null, workflowId: string, authProvider?: AuthProvider): Promise<ChatHistoryMessage[]>;
     /**
      * Clear conversation history for a workflow
      *
      * @param workflowId - The workflow ID
      */
-    clearHistory(endpointConfig: EndpointConfig | null, workflowId: string): Promise<void>;
+    clearHistory(endpointConfig: EndpointConfig | null, workflowId: string, authProvider?: AuthProvider): Promise<void>;
 }
 /**
  * Pre-instantiated ChatService singleton

package/dist/services/chatService.js

@@ -6,7 +6,8 @@
  *
  * @module services/chatService
  */
-import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { authenticatedFetch } from '../utils/fetchWithAuth.js';
 import { logger } from '../utils/logger.js';
 /**
  * Chat Service class
@@ -50,14 +51,11 @@ export class ChatService {
      * @param options - Fetch options
      * @returns The parsed JSON response
      */
-    async request(config, url, options = {}) {
-        const headers = getEndpointHeaders(config, 'chat');
-        const response = await fetch(url, {
-            ...options,
-            headers: {
-                ...headers,
-                ...options.headers
-            }
+    async request(config, url, options = {}, authProvider) {
+        const response = await authenticatedFetch(url, options, {
+            config,
+            endpointKey: 'chat',
+            authProvider
         });
         if (!response.ok) {
             const errorData = await response.json().catch(() => ({}));
@@ -83,7 +81,7 @@ export class ChatService {
      * @param request - The chat request payload
      * @returns The chat response from the LLM
      */
-    async sendMessage(endpointConfig, workflowId, request) {
+    async sendMessage(endpointConfig, workflowId, request, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.chat.sendMessage, {
             id: workflowId
@@ -92,7 +90,7 @@ export class ChatService {
         return this.request(config, url, {
             method: 'POST',
             body: JSON.stringify(request)
-        });
+        }, authProvider);
     }
     /**
      * Get conversation history for a workflow
@@ -100,29 +98,26 @@ export class ChatService {
      * @param workflowId - The workflow ID
      * @returns Array of chat history messages
      */
-    async getHistory(endpointConfig, workflowId) {
+    async getHistory(endpointConfig, workflowId, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.chat.getHistory, {
             id: workflowId
         });
         logger.debug('[ChatService] Getting history from', url);
-        return this.request(config, url);
+        return this.request(config, url, {}, authProvider);
     }
     /**
      * Clear conversation history for a workflow
      *
      * @param workflowId - The workflow ID
      */
-    async clearHistory(endpointConfig, workflowId) {
+    async clearHistory(endpointConfig, workflowId, authProvider) {
         const config = this.getConfig(endpointConfig);
         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')
-        });
+        await authenticatedFetch(url, { method: 'DELETE' }, { config, endpointKey: 'chat', authProvider });
     }
 }
 /**

package/dist/services/interruptService.d.ts

@@ -9,6 +9,7 @@
  */
 import type { Interrupt, InterruptPollingConfig } from '../types/interrupt.js';
 import type { EndpointConfig } from '../config/endpoints.js';
+import type { AuthProvider } from '../types/auth.js';
 /**
  * Interrupt Service class
  *
@@ -75,7 +76,7 @@ export declare class InterruptService {
      * @param interruptId - The interrupt UUID
      * @returns The interrupt details
      */
-    getInterrupt(endpointConfig: EndpointConfig | null, interruptId: string): Promise<Interrupt>;
+    getInterrupt(endpointConfig: EndpointConfig | null, interruptId: string, authProvider?: AuthProvider): Promise<Interrupt>;
     /**
      * Resolve an interrupt with user response
      *
@@ -83,28 +84,28 @@ export declare class InterruptService {
      * @param value - The user's response value
      * @returns The updated interrupt
      */
-    resolveInterrupt(endpointConfig: EndpointConfig | null, interruptId: string, value: unknown): Promise<Interrupt>;
+    resolveInterrupt(endpointConfig: EndpointConfig | null, interruptId: string, value: unknown, authProvider?: AuthProvider): Promise<Interrupt>;
     /**
      * Cancel a pending interrupt
      *
      * @param interruptId - The interrupt UUID
      * @returns The updated interrupt
      */
-    cancelInterrupt(endpointConfig: EndpointConfig | null, interruptId: string): Promise<Interrupt>;
+    cancelInterrupt(endpointConfig: EndpointConfig | null, interruptId: string, authProvider?: AuthProvider): Promise<Interrupt>;
     /**
      * List interrupts for a playground session
      *
      * @param sessionId - The session UUID
      * @returns Array of interrupts for the session
      */
-    listSessionInterrupts(endpointConfig: EndpointConfig | null, sessionId: string): Promise<Interrupt[]>;
+    listSessionInterrupts(endpointConfig: EndpointConfig | null, sessionId: string, authProvider?: AuthProvider): Promise<Interrupt[]>;
     /**
      * List interrupts for a pipeline
      *
      * @param pipelineId - The pipeline UUID
      * @returns Array of interrupts for the pipeline
      */
-    listPipelineInterrupts(endpointConfig: EndpointConfig | null, pipelineId: string): Promise<Interrupt[]>;
+    listPipelineInterrupts(endpointConfig: EndpointConfig | null, pipelineId: string, authProvider?: AuthProvider): Promise<Interrupt[]>;
     /**
      * Start polling for interrupts in a session
      *
@@ -114,7 +115,7 @@ export declare class InterruptService {
      * @param sessionId - The session UUID to poll
      * @param callback - Callback function to handle new interrupts
      */
-    startPolling(endpointConfig: EndpointConfig | null, sessionId: string, callback: (interrupts: Interrupt[]) => void): void;
+    startPolling(endpointConfig: EndpointConfig | null, sessionId: string, callback: (interrupts: Interrupt[]) => void, authProvider?: AuthProvider): void;
     /**
      * Stop polling for interrupts
      */

package/dist/services/interruptService.js

@@ -8,7 +8,8 @@
  * @module services/interruptService
  */
 import { defaultInterruptPollingConfig } from '../types/interrupt.js';
-import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { authenticatedFetch } from '../utils/fetchWithAuth.js';
 import { logger } from '../utils/logger.js';
 /**
  * Interrupt Service class
@@ -92,14 +93,11 @@ export class InterruptService {
      * @param options - Fetch options
      * @returns The parsed JSON response
      */
-    async request(config, url, options = {}) {
-        const headers = getEndpointHeaders(config, 'interrupts');
-        const response = await fetch(url, {
-            ...options,
-            headers: {
-                ...headers,
-                ...options.headers
-            }
+    async request(config, url, options = {}, authProvider) {
+        const response = await authenticatedFetch(url, options, {
+            config,
+            endpointKey: 'interrupts',
+            authProvider
         });
         if (!response.ok) {
             const errorData = await response.json().catch(() => ({}));
@@ -119,12 +117,12 @@ export class InterruptService {
      * @param interruptId - The interrupt UUID
      * @returns The interrupt details
      */
-    async getInterrupt(endpointConfig, interruptId) {
+    async getInterrupt(endpointConfig, interruptId, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.interrupts.get, {
             interruptId
         });
-        const response = await this.request(config, url);
+        const response = await this.request(config, url, {}, authProvider);
         if (!response.data) {
             throw new Error('Interrupt not found');
         }
@@ -137,7 +135,7 @@ export class InterruptService {
      * @param value - The user's response value
      * @returns The updated interrupt
      */
-    async resolveInterrupt(endpointConfig, interruptId, value) {
+    async resolveInterrupt(endpointConfig, interruptId, value, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.interrupts.resolve, {
             interruptId
@@ -146,7 +144,7 @@ export class InterruptService {
         const response = await this.request(config, url, {
             method: 'POST',
             body: JSON.stringify(resolution)
-        });
+        }, authProvider);
         if (!response.data) {
             throw new Error('Failed to resolve interrupt: No data returned');
         }
@@ -158,14 +156,14 @@ export class InterruptService {
      * @param interruptId - The interrupt UUID
      * @returns The updated interrupt
      */
-    async cancelInterrupt(endpointConfig, interruptId) {
+    async cancelInterrupt(endpointConfig, interruptId, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.interrupts.cancel, {
             interruptId
         });
         const response = await this.request(config, url, {
             method: 'POST'
-        });
+        }, authProvider);
         if (!response.data) {
             throw new Error('Failed to cancel interrupt: No data returned');
         }
@@ -177,12 +175,12 @@ export class InterruptService {
      * @param sessionId - The session UUID
      * @returns Array of interrupts for the session
      */
-    async listSessionInterrupts(endpointConfig, sessionId) {
+    async listSessionInterrupts(endpointConfig, sessionId, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.interrupts.listBySession, {
             sessionId
         });
-        const response = await this.request(config, url);
+        const response = await this.request(config, url, {}, authProvider);
         return response.data ?? [];
     }
     /**
@@ -191,12 +189,12 @@ export class InterruptService {
      * @param pipelineId - The pipeline UUID
      * @returns Array of interrupts for the pipeline
      */
-    async listPipelineInterrupts(endpointConfig, pipelineId) {
+    async listPipelineInterrupts(endpointConfig, pipelineId, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.interrupts.listByPipeline, {
             pipelineId
         });
-        const response = await this.request(config, url);
+        const response = await this.request(config, url, {}, authProvider);
         return response.data ?? [];
     }
     // =========================================================================
@@ -211,7 +209,7 @@ export class InterruptService {
      * @param sessionId - The session UUID to poll
      * @param callback - Callback function to handle new interrupts
      */
-    startPolling(endpointConfig, sessionId, callback) {
+    startPolling(endpointConfig, sessionId, callback, authProvider) {
         if (!this.pollingConfig.enabled) {
             logger.warn('[InterruptService] Polling is disabled. Enable via setPollingConfig().');
             return;
@@ -225,7 +223,7 @@ export class InterruptService {
                 return;
             }
             try {
-                const interrupts = await this.listSessionInterrupts(endpointConfig, sessionId);
+                const interrupts = await this.listSessionInterrupts(endpointConfig, sessionId, authProvider);
                 const pendingInterrupts = interrupts.filter((i) => i.status === 'pending');
                 // Reset backoff on successful request
                 this.currentBackoff = this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;

package/dist/services/playgroundService.d.ts

@@ -8,6 +8,7 @@
  */
 import type { PlaygroundSession, PlaygroundMessage, PlaygroundMessagesApiResponse, PlaygroundSessionStatus } from '../types/playground.js';
 import type { EndpointConfig } from '../config/endpoints.js';
+import type { AuthProvider } from '../types/auth.js';
 /**
  * Pagination options for {@link PlaygroundService.getMessages}.
  * `since`, `before`, and `latest` are mutually exclusive.
@@ -70,7 +71,7 @@ export declare class PlaygroundService {
     listSessions(endpointConfig: EndpointConfig | null, workflowId: string, options?: {
         limit?: number;
         offset?: number;
-    }): Promise<PlaygroundSession[]>;
+    }, authProvider?: AuthProvider): Promise<PlaygroundSession[]>;
     /**
      * Create a new playground session
      *
@@ -79,20 +80,20 @@ export declare class PlaygroundService {
      * @param metadata - Optional session metadata
      * @returns The created session
      */
-    createSession(endpointConfig: EndpointConfig | null, workflowId: string, name?: string, metadata?: Record<string, unknown>): Promise<PlaygroundSession>;
+    createSession(endpointConfig: EndpointConfig | null, workflowId: string, name?: string, metadata?: Record<string, unknown>, authProvider?: AuthProvider): Promise<PlaygroundSession>;
     /**
      * Get a playground session by ID
      *
      * @param sessionId - The session UUID
      * @returns The session details
      */
-    getSession(endpointConfig: EndpointConfig | null, sessionId: string): Promise<PlaygroundSession>;
+    getSession(endpointConfig: EndpointConfig | null, sessionId: string, authProvider?: AuthProvider): Promise<PlaygroundSession>;
     /**
      * Delete a playground session
      *
      * @param sessionId - The session UUID
      */
-    deleteSession(endpointConfig: EndpointConfig | null, sessionId: string): Promise<void>;
+    deleteSession(endpointConfig: EndpointConfig | null, sessionId: string, authProvider?: AuthProvider): Promise<void>;
     /**
      * Get messages from a playground session.
      *
@@ -106,7 +107,7 @@ export declare class PlaygroundService {
      * @param options - Pagination options
      * @returns Messages and session status
      */
-    getMessages(endpointConfig: EndpointConfig | null, sessionId: string, options?: GetMessagesOptions): Promise<PlaygroundMessagesApiResponse>;
+    getMessages(endpointConfig: EndpointConfig | null, sessionId: string, options?: GetMessagesOptions, authProvider?: AuthProvider): Promise<PlaygroundMessagesApiResponse>;
     /**
      * Send a message to a playground session
      *
@@ -115,13 +116,13 @@ export declare class PlaygroundService {
      * @param inputs - Optional additional inputs for workflow nodes
      * @returns The created message
      */
-    sendMessage(endpointConfig: EndpointConfig | null, sessionId: string, content: string, inputs?: Record<string, unknown>): Promise<PlaygroundMessage>;
+    sendMessage(endpointConfig: EndpointConfig | null, sessionId: string, content: string, inputs?: Record<string, unknown>, authProvider?: AuthProvider): Promise<PlaygroundMessage>;
     /**
      * Stop execution in a playground session
      *
      * @param sessionId - The session UUID
      */
-    stopExecution(endpointConfig: EndpointConfig | null, sessionId: string): Promise<void>;
+    stopExecution(endpointConfig: EndpointConfig | null, sessionId: string, authProvider?: AuthProvider): Promise<void>;
     /**
      * Start polling for new messages
      *
@@ -131,7 +132,7 @@ export declare class PlaygroundService {
      * @param shouldStopPolling - Optional override for stop conditions (default: defaultShouldStopPolling)
      * @param initialSequenceNumber - Optional sequence number to seed polling from (avoids re-fetching already loaded messages)
      */
-    startPolling(endpointConfig: EndpointConfig | null, sessionId: string, callback: (response: PlaygroundMessagesApiResponse) => void, interval?: number, shouldStopPolling?: (status: PlaygroundSessionStatus) => boolean, initialSequenceNumber?: number | null): void;
+    startPolling(endpointConfig: EndpointConfig | null, sessionId: string, callback: (response: PlaygroundMessagesApiResponse) => void, interval?: number, shouldStopPolling?: (status: PlaygroundSessionStatus) => boolean, initialSequenceNumber?: number | null, authProvider?: AuthProvider): void;
     /**
      * Stop polling for messages
      */