@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.2

package/dist/services/nodeExecutionService.js

@@ -2,7 +2,6 @@
  * 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';
@@ -26,12 +25,11 @@ export class NodeExecutionService {
     /**
      * Get execution information for a specific node from pipeline data
      */
-    async getNodeExecutionInfo(nodeId, pipelineId) {
+    async getNodeExecutionInfo(endpointConfig, nodeId, pipelineId) {
         if (!pipelineId) {
             return null;
         }
         try {
-            const endpointConfig = getEndpointConfig();
             if (!endpointConfig)
                 throw new Error('Endpoint config not available');
             const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.pipelines.get, {
@@ -45,24 +43,7 @@ export class NodeExecutionService {
             const pipelineData = raw.data ?? raw;
             const jobs = pipelineData.jobs || [];
             const nodeStatuses = pipelineData.node_statuses || {};
-            // Find the job for this node
-            const nodeJob = jobs.find((job) => job.node_id === nodeId);
-            const nodeStatus = nodeStatuses[nodeId];
-            if (!nodeJob && !nodeStatus) {
-                return {
-                    status: 'idle',
-                    executionCount: 0,
-                    isExecuting: false
-                };
-            }
-            const executionInfo = {
-                status: this.mapJobStatusToExecutionStatus(nodeStatus?.status || nodeJob?.status || 'idle'),
-                executionCount: nodeJob?.execution_count || 0,
-                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
-            };
+            const executionInfo = this.buildNodeExecutionInfo(nodeId, nodeStatuses[nodeId], jobs);
             this.cache.set(nodeId, executionInfo);
             return executionInfo;
         }
@@ -74,7 +55,7 @@ export class NodeExecutionService {
     /**
      * Get execution information for multiple nodes from pipeline data
      */
-    async getMultipleNodeExecutionInfo(nodeIds, pipelineId) {
+    async getMultipleNodeExecutionInfo(endpointConfig, nodeIds, pipelineId) {
         if (!pipelineId) {
             return {};
         }
@@ -91,7 +72,6 @@ export class NodeExecutionService {
             return defaultExecutionInfo;
         }
         try {
-            const endpointConfig = getEndpointConfig();
             if (!endpointConfig)
                 throw new Error('Endpoint config not available');
             const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.pipelines.get, {
@@ -120,28 +100,11 @@ export class NodeExecutionService {
             const raw = await response.json();
             const result = raw.data ?? raw;
             const jobs = result.jobs || [];
+            const nodeStatuses = result.node_statuses || {};
             const executionInfoMap = {};
-            // Initialize all nodes with default values
             nodeIds.forEach((nodeId) => {
-                executionInfoMap[nodeId] = {
-                    status: 'idle',
-                    executionCount: 0,
-                    isExecuting: false
-                };
-            });
-            // Update with actual job data
-            jobs.forEach((job) => {
-                const nodeId = job.node_id;
-                if (nodeIds.includes(nodeId)) {
-                    executionInfoMap[nodeId] = {
-                        status: this.mapJobStatusToExecutionStatus(job.status),
-                        executionCount: job.execution_count || 0,
-                        isExecuting: job.status === 'running',
-                        lastExecuted: job.completed || job.started,
-                        lastExecutionDuration: job.execution_time,
-                        lastError: job.error_message
-                    };
-                    // Update cache
+                executionInfoMap[nodeId] = this.buildNodeExecutionInfo(nodeId, nodeStatuses[nodeId], jobs);
+                if (executionInfoMap[nodeId].status !== 'idle' || executionInfoMap[nodeId].jobs) {
                     this.cache.set(nodeId, executionInfoMap[nodeId]);
                 }
             });
@@ -164,9 +127,8 @@ export class NodeExecutionService {
     /**
      * Get all node execution counts
      */
-    async getAllNodeExecutionCounts() {
+    async getAllNodeExecutionCounts(endpointConfig) {
         try {
-            const endpointConfig = getEndpointConfig();
             if (!endpointConfig)
                 throw new Error('Endpoint config not available');
             const url = buildEndpointUrl(endpointConfig, '/node-execution-counts');
@@ -227,6 +189,66 @@ export class NodeExecutionService {
             });
         }
     }
+    /**
+     * Build execution info for one node from the pipeline payload.
+     *
+     * The `node_statuses` entry is the backend-resolved summary (latest job's
+     * status, timing from the most recent run, `executions` count); the per-job
+     * history is attached from the `jobs` array so loop iterations stay
+     * inspectable. Falls back to the node's jobs when no entry exists (older
+     * backends).
+     */
+    buildNodeExecutionInfo(nodeId, entry, jobs) {
+        const nodeJobs = jobs.filter((job) => job.node_id === nodeId);
+        if (!entry && nodeJobs.length === 0) {
+            return {
+                status: 'idle',
+                executionCount: 0,
+                isExecuting: false
+            };
+        }
+        // Fallback for payloads without a node_statuses entry: the last job in
+        // pipeline order mirrors the backend's latest-wins resolution.
+        const lastJob = nodeJobs[nodeJobs.length - 1];
+        const status = entry?.status ?? lastJob?.status ?? 'idle';
+        const startedCount = nodeJobs.filter((job) => job.started).length;
+        const executionInfo = {
+            status: this.mapJobStatusToExecutionStatus(status),
+            executionCount: entry?.executions ?? startedCount,
+            isExecuting: status === 'running' || nodeJobs.some((job) => job.status === 'running'),
+            lastExecuted: entry?.last_executed ?? lastJob?.completed ?? lastJob?.started ?? undefined,
+            lastExecutionDuration: entry?.execution_time ?? lastJob?.execution_time ?? undefined,
+            lastExecutionDurationUs: entry?.execution_time_us ?? lastJob?.execution_time_us ?? undefined,
+            lastError: entry?.error ?? lastJob?.error_message ?? undefined
+        };
+        if (nodeJobs.length > 0) {
+            executionInfo.jobs = nodeJobs.map((job) => this.mapJobToNodeJobExecution(job));
+        }
+        return executionInfo;
+    }
+    /**
+     * Map a pipeline job payload entry to a NodeJobExecution history item.
+     */
+    mapJobToNodeJobExecution(job) {
+        let executionTime = job.execution_time;
+        if (executionTime == null && job.started && job.completed) {
+            const started = Date.parse(job.started);
+            const completed = Date.parse(job.completed);
+            if (!Number.isNaN(started) && !Number.isNaN(completed)) {
+                executionTime = completed - started;
+            }
+        }
+        return {
+            id: job.id,
+            label: job.label,
+            status: this.mapJobStatusToExecutionStatus(job.status),
+            started: job.started,
+            completed: job.completed,
+            executionTime,
+            executionTimeUs: job.execution_time_us ?? (executionTime != null ? executionTime * 1000 : undefined),
+            error: job.error_message ?? job.error
+        };
+    }
     /**
      * Map job status to execution status
      */
@@ -244,6 +266,10 @@ export class NodeExecutionService {
                 return 'cancelled';
             case 'skipped':
                 return 'skipped';
+            case 'paused':
+                return 'paused';
+            case 'interrupted':
+                return 'interrupted';
             default:
                 return 'idle';
         }

package/dist/services/playgroundService.d.ts

@@ -7,6 +7,8 @@
  * @module services/playgroundService
  */
 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.
@@ -41,7 +43,10 @@ export declare class PlaygroundService {
      */
     static getInstance(): PlaygroundService;
     /**
-     * Get the endpoint configuration
+     * Validate and return the endpoint configuration passed by the caller.
+     *
+     * Callers thread the config from `getInstance().api.config`; this enforces
+     * the legacy "throws if not configured" contract.
      *
      * @throws Error if endpoint configuration is not set
      * @returns The endpoint configuration
@@ -50,6 +55,7 @@ export declare class PlaygroundService {
     /**
      * Generic API request helper
      *
+     * @param config - The endpoint configuration
      * @param url - The URL to fetch
      * @param options - Fetch options
      * @returns The parsed JSON response
@@ -62,10 +68,10 @@ export declare class PlaygroundService {
      * @param options - Optional pagination parameters
      * @returns Array of playground sessions
      */
-    listSessions(workflowId: string, options?: {
+    listSessions(endpointConfig: EndpointConfig | null, workflowId: string, options?: {
         limit?: number;
         offset?: number;
-    }): Promise<PlaygroundSession[]>;
+    }, authProvider?: AuthProvider): Promise<PlaygroundSession[]>;
     /**
      * Create a new playground session
      *
@@ -74,20 +80,20 @@ export declare class PlaygroundService {
      * @param metadata - Optional session metadata
      * @returns The created session
      */
-    createSession(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(sessionId: string): Promise<PlaygroundSession>;
+    getSession(endpointConfig: EndpointConfig | null, sessionId: string, authProvider?: AuthProvider): Promise<PlaygroundSession>;
     /**
      * Delete a playground session
      *
      * @param sessionId - The session UUID
      */
-    deleteSession(sessionId: string): Promise<void>;
+    deleteSession(endpointConfig: EndpointConfig | null, sessionId: string, authProvider?: AuthProvider): Promise<void>;
     /**
      * Get messages from a playground session.
      *
@@ -101,7 +107,7 @@ export declare class PlaygroundService {
      * @param options - Pagination options
      * @returns Messages and session status
      */
-    getMessages(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
      *
@@ -110,13 +116,13 @@ export declare class PlaygroundService {
      * @param inputs - Optional additional inputs for workflow nodes
      * @returns The created message
      */
-    sendMessage(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(sessionId: string): Promise<void>;
+    stopExecution(endpointConfig: EndpointConfig | null, sessionId: string, authProvider?: AuthProvider): Promise<void>;
     /**
      * Start polling for new messages
      *
@@ -126,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(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
      */

package/dist/services/playgroundService.js

@@ -7,8 +7,8 @@
  * @module services/playgroundService
  */
 import { defaultShouldStopPolling } from '../types/playground.js';
-import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
-import { getEndpointConfig } from './api.js';
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { authenticatedFetch } from '../utils/fetchWithAuth.js';
 import { logger } from '../utils/logger.js';
 /**
  * Default polling interval in milliseconds
@@ -43,34 +43,33 @@ export class PlaygroundService {
         return PlaygroundService.instance;
     }
     /**
-     * Get the endpoint configuration
+     * Validate and return the endpoint configuration passed by the caller.
+     *
+     * Callers thread the config from `getInstance().api.config`; this enforces
+     * the legacy "throws if not configured" contract.
      *
      * @throws Error if endpoint configuration is not set
      * @returns The endpoint configuration
      */
-    getConfig() {
-        const config = getEndpointConfig();
+    getConfig(config) {
         if (!config) {
-            throw new Error('Endpoint configuration not set. Call setEndpointConfig() first.');
+            throw new Error('Endpoint configuration not set. Configure the instance via fd.api.configure().');
         }
         return config;
     }
     /**
      * Generic API request helper
      *
+     * @param config - The endpoint configuration
      * @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, 'playground');
-        const response = await fetch(url, {
-            ...options,
-            headers: {
-                ...headers,
-                ...options.headers
-            }
+    async request(config, url, options = {}, authProvider) {
+        const response = await authenticatedFetch(url, options, {
+            config,
+            endpointKey: 'playground',
+            authProvider
         });
         if (!response.ok) {
             const errorData = await response.json().catch(() => ({}));
@@ -91,8 +90,8 @@ export class PlaygroundService {
      * @param options - Optional pagination parameters
      * @returns Array of playground sessions
      */
-    async listSessions(workflowId, options) {
-        const config = this.getConfig();
+    async listSessions(endpointConfig, workflowId, options, authProvider) {
+        const config = this.getConfig(endpointConfig);
         let url = buildEndpointUrl(config, config.endpoints.playground.listSessions, {
             id: workflowId
         });
@@ -108,7 +107,7 @@ export class PlaygroundService {
         if (queryString) {
             url = `${url}?${queryString}`;
         }
-        const response = await this.request(url);
+        const response = await this.request(config, url, {}, authProvider);
         return response.data ?? [];
     }
     /**
@@ -119,15 +118,15 @@ export class PlaygroundService {
      * @param metadata - Optional session metadata
      * @returns The created session
      */
-    async createSession(workflowId, name, metadata) {
-        const config = this.getConfig();
+    async createSession(endpointConfig, workflowId, name, metadata, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.createSession, {
             id: workflowId
         });
-        const response = await this.request(url, {
+        const response = await this.request(config, url, {
             method: 'POST',
             body: JSON.stringify({ name, metadata })
-        });
+        }, authProvider);
         if (!response.data) {
             throw new Error('Failed to create session: No data returned');
         }
@@ -139,12 +138,12 @@ export class PlaygroundService {
      * @param sessionId - The session UUID
      * @returns The session details
      */
-    async getSession(sessionId) {
-        const config = this.getConfig();
+    async getSession(endpointConfig, sessionId, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.getSession, {
             sessionId
         });
-        const response = await this.request(url);
+        const response = await this.request(config, url, {}, authProvider);
         if (!response.data) {
             throw new Error('Session not found');
         }
@@ -155,14 +154,14 @@ export class PlaygroundService {
      *
      * @param sessionId - The session UUID
      */
-    async deleteSession(sessionId) {
-        const config = this.getConfig();
+    async deleteSession(endpointConfig, sessionId, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.deleteSession, {
             sessionId
         });
-        await this.request(url, {
+        await this.request(config, url, {
             method: 'DELETE'
-        });
+        }, authProvider);
     }
     // =========================================================================
     // Message Handling
@@ -180,8 +179,8 @@ export class PlaygroundService {
      * @param options - Pagination options
      * @returns Messages and session status
      */
-    async getMessages(sessionId, options = {}) {
-        const config = this.getConfig();
+    async getMessages(endpointConfig, sessionId, options = {}, authProvider) {
+        const config = this.getConfig(endpointConfig);
         let url = buildEndpointUrl(config, config.endpoints.playground.getMessages, {
             sessionId
         });
@@ -202,7 +201,7 @@ export class PlaygroundService {
         if (queryString) {
             url = `${url}?${queryString}`;
         }
-        return this.request(url);
+        return this.request(config, url, {}, authProvider);
     }
     /**
      * Send a message to a playground session
@@ -212,8 +211,8 @@ export class PlaygroundService {
      * @param inputs - Optional additional inputs for workflow nodes
      * @returns The created message
      */
-    async sendMessage(sessionId, content, inputs) {
-        const config = this.getConfig();
+    async sendMessage(endpointConfig, sessionId, content, inputs, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.sendMessage, {
             sessionId
         });
@@ -221,10 +220,10 @@ export class PlaygroundService {
         if (inputs) {
             requestBody.inputs = inputs;
         }
-        const response = await this.request(url, {
+        const response = await this.request(config, url, {
             method: 'POST',
             body: JSON.stringify(requestBody)
-        });
+        }, authProvider);
         if (!response.data) {
             throw new Error('Failed to send message: No data returned');
         }
@@ -235,14 +234,14 @@ export class PlaygroundService {
      *
      * @param sessionId - The session UUID
      */
-    async stopExecution(sessionId) {
-        const config = this.getConfig();
+    async stopExecution(endpointConfig, sessionId, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.stopExecution, {
             sessionId
         });
-        await this.request(url, {
+        await this.request(config, url, {
             method: 'POST'
-        });
+        }, authProvider);
     }
     // =========================================================================
     // Polling
@@ -256,7 +255,7 @@ export 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(sessionId, callback, interval = DEFAULT_POLLING_INTERVAL, shouldStopPolling, initialSequenceNumber) {
+    startPolling(endpointConfig, sessionId, callback, interval = DEFAULT_POLLING_INTERVAL, shouldStopPolling, initialSequenceNumber, authProvider) {
         // Stop any existing polling
         this.stopPolling();
         this.pollingSessionId = sessionId;
@@ -268,9 +267,9 @@ export class PlaygroundService {
                 return;
             }
             try {
-                const response = await this.getMessages(sessionId, {
+                const response = await this.getMessages(endpointConfig, sessionId, {
                     since: this.lastSequenceNumber ?? undefined
-                });
+                }, authProvider);
                 // Update last sequence number cursor
                 if (response.data && response.data.length > 0) {
                     const lastMessage = response.data[response.data.length - 1];

package/dist/services/portConfigApi.js

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

package/dist/services/settingsService.d.ts

@@ -9,12 +9,15 @@
  */
 import type { FlowDropSettings, PartialSettings } from '../types/settings.js';
 import type { EndpointConfig } from '../config/endpoints.js';
+import type { AuthProvider } from '../types/auth.js';
 /**
- * Set the endpoint configuration for settings API calls
+ * Set the endpoint configuration (and optional auth provider) for settings API
+ * calls.
  *
  * @param config - Endpoint configuration
+ * @param provider - Optional auth provider supplying request auth headers
  */
-export declare function setSettingsEndpointConfig(config: EndpointConfig): void;
+export declare function setSettingsEndpointConfig(config: EndpointConfig, provider?: AuthProvider): void;
 /**
  * Get the current endpoint configuration
  *
@@ -62,8 +65,9 @@ export declare class SettingsService {
      * Create a new settings service instance
      *
      * @param config - Endpoint configuration
+     * @param authProvider - Optional auth provider applied to settings requests
      */
-    constructor(config: EndpointConfig);
+    constructor(config: EndpointConfig, authProvider?: AuthProvider);
     /**
      * Get user preferences from the backend
      *
@@ -87,6 +91,7 @@ export declare class SettingsService {
  * Create a settings service instance
  *
  * @param config - Endpoint configuration
+ * @param authProvider - Optional auth provider applied to settings requests
  * @returns SettingsService instance
  */
-export declare function createSettingsService(config: EndpointConfig): SettingsService;
+export declare function createSettingsService(config: EndpointConfig, authProvider?: AuthProvider): SettingsService;

package/dist/services/settingsService.js

@@ -7,7 +7,8 @@
  *
  * @module services/settingsService
  */
-import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { authenticatedFetch } from '../utils/fetchWithAuth.js';
 // =========================================================================
 // Configuration
 // =========================================================================
@@ -16,12 +17,20 @@ import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
  */
 let endpointConfig = null;
 /**
- * Set the endpoint configuration for settings API calls
+ * Auth provider reference, applied to every settings request so the backend
+ * sync path authenticates consistently with the rest of the library.
+ */
+let authProvider;
+/**
+ * Set the endpoint configuration (and optional auth provider) for settings API
+ * calls.
  *
  * @param config - Endpoint configuration
+ * @param provider - Optional auth provider supplying request auth headers
  */
-export function setSettingsEndpointConfig(config) {
+export function setSettingsEndpointConfig(config, provider) {
     endpointConfig = config;
+    authProvider = provider;
 }
 /**
  * Get the current endpoint configuration
@@ -47,10 +56,10 @@ async function settingsRequest(endpointKey, endpointPath, options = {}) {
         throw new Error('Endpoint configuration not set. Call setSettingsEndpointConfig() first.');
     }
     const url = buildEndpointUrl(endpointConfig, endpointPath);
-    const headers = getEndpointHeaders(endpointConfig, endpointKey);
-    const response = await fetch(url, {
-        headers,
-        ...options
+    const response = await authenticatedFetch(url, options, {
+        config: endpointConfig,
+        endpointKey,
+        authProvider
     });
     // Check if response is JSON
     const contentType = response.headers.get('content-type');
@@ -151,11 +160,12 @@ export class SettingsService {
      * Create a new settings service instance
      *
      * @param config - Endpoint configuration
+     * @param authProvider - Optional auth provider applied to settings requests
      */
-    constructor(config) {
+    constructor(config, authProvider) {
         this.config = config;
-        // Also set the module-level config
-        setSettingsEndpointConfig(config);
+        // Also set the module-level config + auth provider
+        setSettingsEndpointConfig(config, authProvider);
     }
     /**
      * Get user preferences from the backend
@@ -189,8 +199,9 @@ export class SettingsService {
  * Create a settings service instance
  *
  * @param config - Endpoint configuration
+ * @param authProvider - Optional auth provider applied to settings requests
  * @returns SettingsService instance
  */
-export function createSettingsService(config) {
-    return new SettingsService(config);
+export function createSettingsService(config, authProvider) {
+    return new SettingsService(config, authProvider);
 }

package/dist/services/variableService.d.ts

@@ -6,6 +6,7 @@
  * @module services/variableService
  */
 import type { WorkflowNode, WorkflowEdge, VariableSchema, TemplateVariable, TemplateVariablesConfig, AuthProvider } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
  * Options for deriving available variables.
  */
@@ -138,4 +139,4 @@ export declare function mergeVariableSchemas(primary: VariableSchema, secondary:
  * const schema = await getVariableSchema(node, nodes, edges, config, workflowId, authProvider);
  * ```
  */
-export declare function getVariableSchema(node: WorkflowNode, nodes: WorkflowNode[], edges: WorkflowEdge[], config: TemplateVariablesConfig, workflowId?: string, authProvider?: AuthProvider): Promise<VariableSchema>;
+export declare function getVariableSchema(endpointConfig: EndpointConfig | null, node: WorkflowNode, nodes: WorkflowNode[], edges: WorkflowEdge[], config: TemplateVariablesConfig, workflowId?: string, authProvider?: AuthProvider): Promise<VariableSchema>;

package/dist/services/variableService.js

@@ -405,14 +405,14 @@ export function mergeVariableSchemas(primary, secondary) {
  * const schema = await getVariableSchema(node, nodes, edges, config, workflowId, authProvider);
  * ```
  */
-export async function getVariableSchema(node, nodes, edges, config, workflowId, authProvider) {
+export async function getVariableSchema(endpointConfig, node, nodes, edges, config, workflowId, authProvider) {
     let resultSchema = { variables: {} };
     // Try API mode first (if configured)
     if (config.api) {
         try {
             // Import API variable service dynamically to avoid circular dependencies
             const { fetchVariableSchema } = await import('./apiVariableService.js');
-            const apiResult = await fetchVariableSchema(workflowId, node.id, config.api, authProvider);
+            const apiResult = await fetchVariableSchema(endpointConfig, workflowId, node.id, config.api, authProvider);
             if (apiResult.success && apiResult.schema) {
                 resultSchema = apiResult.schema;
                 // Merge with static schema if configured