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

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
      */

package/dist/services/playgroundService.js

@@ -7,7 +7,8 @@
  * @module services/playgroundService
  */
 import { defaultShouldStopPolling } from '../types/playground.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';
 /**
  * Default polling interval in milliseconds
@@ -64,14 +65,11 @@ export class PlaygroundService {
      * @param options - Fetch options
      * @returns The parsed JSON response
      */
-    async request(config, url, options = {}) {
-        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(() => ({}));
@@ -92,7 +90,7 @@ export class PlaygroundService {
      * @param options - Optional pagination parameters
      * @returns Array of playground sessions
      */
-    async listSessions(endpointConfig, workflowId, options) {
+    async listSessions(endpointConfig, workflowId, options, authProvider) {
         const config = this.getConfig(endpointConfig);
         let url = buildEndpointUrl(config, config.endpoints.playground.listSessions, {
             id: workflowId
@@ -109,7 +107,7 @@ export class PlaygroundService {
         if (queryString) {
             url = `${url}?${queryString}`;
         }
-        const response = await this.request(config, url);
+        const response = await this.request(config, url, {}, authProvider);
         return response.data ?? [];
     }
     /**
@@ -120,7 +118,7 @@ export class PlaygroundService {
      * @param metadata - Optional session metadata
      * @returns The created session
      */
-    async createSession(endpointConfig, workflowId, name, metadata) {
+    async createSession(endpointConfig, workflowId, name, metadata, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.createSession, {
             id: workflowId
@@ -128,7 +126,7 @@ export class PlaygroundService {
         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');
         }
@@ -140,12 +138,12 @@ export class PlaygroundService {
      * @param sessionId - The session UUID
      * @returns The session details
      */
-    async getSession(endpointConfig, sessionId) {
+    async getSession(endpointConfig, sessionId, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.getSession, {
             sessionId
         });
-        const response = await this.request(config, url);
+        const response = await this.request(config, url, {}, authProvider);
         if (!response.data) {
             throw new Error('Session not found');
         }
@@ -156,14 +154,14 @@ export class PlaygroundService {
      *
      * @param sessionId - The session UUID
      */
-    async deleteSession(endpointConfig, sessionId) {
+    async deleteSession(endpointConfig, sessionId, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.deleteSession, {
             sessionId
         });
         await this.request(config, url, {
             method: 'DELETE'
-        });
+        }, authProvider);
     }
     // =========================================================================
     // Message Handling
@@ -181,7 +179,7 @@ export class PlaygroundService {
      * @param options - Pagination options
      * @returns Messages and session status
      */
-    async getMessages(endpointConfig, sessionId, options = {}) {
+    async getMessages(endpointConfig, sessionId, options = {}, authProvider) {
         const config = this.getConfig(endpointConfig);
         let url = buildEndpointUrl(config, config.endpoints.playground.getMessages, {
             sessionId
@@ -203,7 +201,7 @@ export class PlaygroundService {
         if (queryString) {
             url = `${url}?${queryString}`;
         }
-        return this.request(config, url);
+        return this.request(config, url, {}, authProvider);
     }
     /**
      * Send a message to a playground session
@@ -213,7 +211,7 @@ export class PlaygroundService {
      * @param inputs - Optional additional inputs for workflow nodes
      * @returns The created message
      */
-    async sendMessage(endpointConfig, sessionId, content, inputs) {
+    async sendMessage(endpointConfig, sessionId, content, inputs, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.sendMessage, {
             sessionId
@@ -225,7 +223,7 @@ export class PlaygroundService {
         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');
         }
@@ -236,14 +234,14 @@ export class PlaygroundService {
      *
      * @param sessionId - The session UUID
      */
-    async stopExecution(endpointConfig, sessionId) {
+    async stopExecution(endpointConfig, sessionId, authProvider) {
         const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.stopExecution, {
             sessionId
         });
         await this.request(config, url, {
             method: 'POST'
-        });
+        }, authProvider);
     }
     // =========================================================================
     // Polling
@@ -257,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(endpointConfig, 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;
@@ -271,7 +269,7 @@ export class PlaygroundService {
             try {
                 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;