@finatic/client 0.0.133 → 0.0.135

package/dist/index.js

@@ -3,23 +3,12 @@
 var uuid = require('uuid');
 
 /**
- * API-related types for Finatic Connect SDK
- */
-var SessionState;
-(function (SessionState) {
-    SessionState["PENDING"] = "PENDING";
-    SessionState["AUTHENTICATING"] = "AUTHENTICATING";
-    SessionState["ACTIVE"] = "ACTIVE";
-    SessionState["COMPLETED"] = "COMPLETED";
-    SessionState["EXPIRED"] = "EXPIRED";
-})(SessionState || (SessionState = {}));
-
-/**
- * Core types for Finatic Connect SDK
+ * Pagination-related types and classes
  */
 class PaginatedResult {
     constructor(data, paginationInfo, navigationCallback) {
         this.data = data;
+        this.navigationCallback = navigationCallback;
         this.metadata = {
             hasMore: paginationInfo.has_more,
             nextOffset: paginationInfo.next_offset,
@@ -29,7 +18,6 @@ class PaginatedResult {
             hasNext: paginationInfo.has_more,
             hasPrevious: paginationInfo.current_offset > 0,
         };
-        this.navigationCallback = navigationCallback;
     }
     get hasNext() {
         return this.metadata.hasNext;
@@ -40,10 +28,6 @@ class PaginatedResult {
     get currentPage() {
         return this.metadata.currentPage;
     }
-    /**
-     * Navigate to the next page
-     * @returns Promise<PaginatedResult<T> | null> - Next page result or null if no next page
-     */
     async nextPage() {
         if (!this.hasNext || !this.navigationCallback) {
             return null;
@@ -52,14 +36,10 @@ class PaginatedResult {
             return await this.navigationCallback(this.metadata.nextOffset, this.metadata.limit);
         }
         catch (error) {
-            console.error('Error navigating to next page:', error);
+            console.error('Error fetching next page:', error);
             return null;
         }
     }
-    /**
-     * Navigate to the previous page
-     * @returns Promise<PaginatedResult<T> | null> - Previous page result or null if no previous page
-     */
     async previousPage() {
         if (!this.hasPrevious || !this.navigationCallback) {
             return null;
@@ -69,61 +49,74 @@ class PaginatedResult {
             return await this.navigationCallback(previousOffset, this.metadata.limit);
         }
         catch (error) {
-            console.error('Error navigating to previous page:', error);
+            console.error('Error fetching previous page:', error);
             return null;
         }
     }
-    /**
-     * Navigate to a specific page
-     * @param pageNumber - The page number to navigate to (1-based)
-     * @returns Promise<PaginatedResult<T> | null> - Page result or null if page doesn't exist
-     */
     async goToPage(pageNumber) {
-        if (pageNumber < 1 || !this.navigationCallback) {
+        if (!this.navigationCallback || pageNumber < 1) {
             return null;
         }
-        const targetOffset = (pageNumber - 1) * this.metadata.limit;
+        const offset = (pageNumber - 1) * this.metadata.limit;
         try {
-            return await this.navigationCallback(targetOffset, this.metadata.limit);
+            return await this.navigationCallback(offset, this.metadata.limit);
         }
         catch (error) {
-            console.error('Error navigating to page:', pageNumber, error);
+            console.error('Error fetching page:', pageNumber, error);
             return null;
         }
     }
-    /**
-     * Get the first page
-     * @returns Promise<PaginatedResult<T> | null> - First page result or null if error
-     */
     async firstPage() {
-        return this.goToPage(1);
+        if (!this.navigationCallback) {
+            return null;
+        }
+        try {
+            return await this.navigationCallback(0, this.metadata.limit);
+        }
+        catch (error) {
+            console.error('Error fetching first page:', error);
+            return null;
+        }
     }
-    /**
-     * Get the last page (this is a best effort - we don't know the total count)
-     * @returns Promise<PaginatedResult<T> | null> - Last page result or null if error
-     */
     async lastPage() {
         if (!this.navigationCallback) {
             return null;
         }
         const findLast = async (page) => {
-            const next = await page.nextPage();
-            if (next) {
-                return findLast(next);
+            if (!page.hasNext) {
+                return page;
             }
-            return page;
+            const nextPage = await page.nextPage();
+            if (!nextPage) {
+                return page;
+            }
+            return findLast(nextPage);
         };
-        return findLast(this);
+        try {
+            return await findLast(this);
+        }
+        catch (error) {
+            console.error('Error fetching last page:', error);
+            return null;
+        }
     }
-    /**
-     * Get pagination info as a string
-     * @returns string - Human readable pagination info
-     */
     getPaginationInfo() {
-        return `Page ${this.currentPage} (${this.metadata.currentOffset + 1}-${this.metadata.currentOffset + this.metadata.limit}) - ${this.hasNext ? 'Has more' : 'Last page'}`;
+        return `Page ${this.currentPage} (${this.metadata.currentOffset + 1}-${this.metadata.currentOffset + this.metadata.limit})`;
     }
 }
 
+/**
+ * Authentication-related types
+ */
+var SessionState;
+(function (SessionState) {
+    SessionState["PENDING"] = "PENDING";
+    SessionState["AUTHENTICATING"] = "AUTHENTICATING";
+    SessionState["ACTIVE"] = "ACTIVE";
+    SessionState["COMPLETED"] = "COMPLETED";
+    SessionState["EXPIRED"] = "EXPIRED";
+})(SessionState || (SessionState = {}));
+
 class BaseError extends Error {
     constructor(message, code = 'UNKNOWN_ERROR') {
         super(message);
@@ -366,11 +359,68 @@ class ApiClient {
                 url.searchParams.append(key, value);
             });
         }
+        // Build comprehensive headers object with all available session data
+        const comprehensiveHeaders = {
+            'Content-Type': 'application/json',
+        };
+        // Add device info if available
+        if (this.deviceInfo) {
+            comprehensiveHeaders['X-Device-Info'] = JSON.stringify({
+                ip_address: this.deviceInfo.ip_address || '',
+                user_agent: this.deviceInfo.user_agent || '',
+                fingerprint: this.deviceInfo.fingerprint || '',
+            });
+        }
+        // Add session headers if available (filter out empty values)
+        if (this.currentSessionId && this.currentSessionId.trim() !== '') {
+            comprehensiveHeaders['X-Session-ID'] = this.currentSessionId;
+            comprehensiveHeaders['Session-ID'] = this.currentSessionId;
+        }
+        if (this.companyId && this.companyId.trim() !== '') {
+            comprehensiveHeaders['X-Company-ID'] = this.companyId;
+        }
+        if (this.csrfToken && this.csrfToken.trim() !== '') {
+            comprehensiveHeaders['X-CSRF-Token'] = this.csrfToken;
+        }
+        // Add any additional headers from options (these will override defaults)
+        if (options.headers) {
+            Object.entries(options.headers).forEach(([key, value]) => {
+                if (value !== undefined && value !== null && value.trim() !== '') {
+                    comprehensiveHeaders[key] = value;
+                }
+            });
+        }
+        // Safari-specific fix: Ensure all headers are explicitly set and not empty
+        // Safari can be strict about header formatting and empty values
+        const safariSafeHeaders = {};
+        Object.entries(comprehensiveHeaders).forEach(([key, value]) => {
+            if (value && value.trim() !== '') {
+                // Ensure header names are properly formatted for Safari
+                const normalizedKey = key.trim();
+                const normalizedValue = value.trim();
+                safariSafeHeaders[normalizedKey] = normalizedValue;
+            }
+        });
+        // Debug logging for development
+        if (typeof window !== 'undefined' && window.location.hostname === 'localhost') {
+            console.log('Request to:', url.toString());
+            console.log('Safari-safe headers:', safariSafeHeaders);
+            console.log('Browser:', navigator.userAgent);
+            console.log('Session ID:', this.currentSessionId);
+            console.log('Company ID:', this.companyId);
+            console.log('CSRF Token:', this.csrfToken);
+        }
         const response = await fetch(url.toString(), {
             method: options.method,
-            headers: options.headers,
+            headers: safariSafeHeaders,
             body: options.body ? JSON.stringify(options.body) : undefined,
         });
+        // Debug logging for response
+        if (typeof window !== 'undefined' && window.location.hostname === 'localhost') {
+            console.log('Response status:', response.status);
+            console.log('Response headers:', Object.fromEntries(response.headers.entries()));
+            console.log('Request was made with headers:', safariSafeHeaders);
+        }
         if (!response.ok) {
             const error = await response.json();
             throw this.handleError(response.status, error);
@@ -619,63 +669,47 @@ class ApiClient {
         });
     }
     // Portfolio Management
-    async getHoldings(accessToken) {
+    async getHoldings() {
+        const accessToken = await this.getValidAccessToken();
         return this.request('/portfolio/holdings', {
             method: 'GET',
             headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${accessToken}`,
+                'Authorization': `Bearer ${accessToken}`,
             },
         });
     }
-    async getOrders(accessToken) {
-        return this.request('/orders/', {
+    async getOrders() {
+        const accessToken = await this.getValidAccessToken();
+        return this.request('/data/orders', {
             method: 'GET',
             headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${accessToken}`,
+                'Authorization': `Bearer ${accessToken}`,
             },
         });
     }
-    async getPortfolio(accessToken) {
+    async getPortfolio() {
+        const accessToken = await this.getValidAccessToken();
         const response = await this.request('/portfolio/', {
             method: 'GET',
             headers: {
-                Authorization: `Bearer ${accessToken}`,
+                'Authorization': `Bearer ${accessToken}`,
                 'Content-Type': 'application/json',
             },
         });
         return response;
     }
-    async placeOrder(accessToken, order) {
-        await this.request('/orders/', {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-                'Content-Type': 'application/json',
-            },
-            body: order,
-        });
-    }
-    // New methods with automatic token management
-    async getHoldingsAuto() {
-        const accessToken = await this.getValidAccessToken();
-        return this.getHoldings(accessToken);
-    }
-    async getOrdersAuto() {
-        const accessToken = await this.getValidAccessToken();
-        return this.getOrders(accessToken);
-    }
-    async getPortfolioAuto() {
-        const accessToken = await this.getValidAccessToken();
-        return this.getPortfolio(accessToken);
-    }
-    async placeOrderAuto(order) {
-        const accessToken = await this.getValidAccessToken();
-        return this.placeOrder(accessToken, order);
-    }
     // Enhanced Trading Methods with Session Management
-    async placeBrokerOrder(accessToken, params, extras = {}) {
+    async placeBrokerOrder(params, extras = {}, connection_id) {
+        const accessToken = await this.getValidAccessToken();
+        // Get broker and account from context or params
+        const broker = params.broker || this.tradingContext.broker;
+        const accountNumber = params.accountNumber || this.tradingContext.accountNumber;
+        if (!broker) {
+            throw new Error('Broker not set. Call setBroker() or pass broker parameter.');
+        }
+        if (!accountNumber) {
+            throw new Error('Account not set. Call setAccount() or pass accountNumber parameter.');
+        }
         // Merge context with provided parameters
         const fullParams = {
             broker: (params.broker || this.tradingContext.broker) ||
@@ -695,9 +729,15 @@ class ApiClient {
             timeInForce: params.timeInForce || 'day',
             price: params.price,
             stopPrice: params.stopPrice,
+            order_id: params.order_id,
         };
-        // Build request body with snake_case parameter names
+        // Build request body with camelCase parameter names
         const requestBody = this.buildOrderRequestBody(fullParams, extras);
+        // Add query parameters if connection_id is provided
+        const queryParams = {};
+        if (connection_id) {
+            queryParams.connection_id = connection_id;
+        }
         return this.request('/brokers/orders', {
             method: 'POST',
             headers: {
@@ -708,17 +748,41 @@ class ApiClient {
                 'X-Device-Info': JSON.stringify(this.deviceInfo),
             },
             body: requestBody,
+            params: queryParams,
         });
     }
-    async cancelBrokerOrder(orderId, broker, extras = {}) {
-        const targetBroker = broker ||
-            this.tradingContext.broker ||
-            (() => {
-                throw new Error('Broker not set. Call setBroker() or pass broker parameter.');
-            })();
-        // Build optional body for extras if provided
-        const body = Object.keys(extras).length > 0 ? { order: extras } : undefined;
-        return this.request(`/brokers/orders/${targetBroker}/${orderId}`, {
+    async cancelBrokerOrder(orderId, broker, extras = {}, connection_id) {
+        await this.getValidAccessToken();
+        const selectedBroker = broker || this.tradingContext.broker;
+        if (!selectedBroker) {
+            throw new Error('Broker not set. Call setBroker() or pass broker parameter.');
+        }
+        const accountNumber = this.tradingContext.accountNumber;
+        // Build query parameters as required by API documentation
+        const queryParams = {
+            broker: selectedBroker,
+            order_id: orderId,
+        };
+        // Add optional parameters if available
+        if (accountNumber) {
+            queryParams.account_number = accountNumber.toString();
+        }
+        if (connection_id) {
+            queryParams.connection_id = connection_id;
+        }
+        // Build optional request body if extras are provided
+        let body = undefined;
+        if (Object.keys(extras).length > 0) {
+            body = {
+                broker: selectedBroker,
+                order: {
+                    order_id: orderId,
+                    account_number: accountNumber,
+                    ...extras
+                }
+            };
+        }
+        return this.request('/brokers/orders', {
             method: 'DELETE',
             headers: {
                 'Content-Type': 'application/json',
@@ -727,16 +791,22 @@ class ApiClient {
                 'X-Device-Info': JSON.stringify(this.deviceInfo),
             },
             body,
+            params: queryParams,
         });
     }
-    async modifyBrokerOrder(orderId, params, broker, extras = {}) {
-        const targetBroker = broker ||
-            this.tradingContext.broker ||
-            (() => {
-                throw new Error('Broker not set. Call setBroker() or pass broker parameter.');
-            })();
-        // Build request body with snake_case parameter names and include broker
-        const requestBody = this.buildModifyRequestBody(params, extras, targetBroker);
+    async modifyBrokerOrder(orderId, params, broker, extras = {}, connection_id) {
+        await this.getValidAccessToken();
+        const selectedBroker = broker || this.tradingContext.broker;
+        if (!selectedBroker) {
+            throw new Error('Broker not set. Call setBroker() or pass broker parameter.');
+        }
+        // Build request body with camelCase parameter names and include broker
+        const requestBody = this.buildModifyRequestBody(params, extras, selectedBroker);
+        // Add query parameters if connection_id is provided
+        const queryParams = {};
+        if (connection_id) {
+            queryParams.connection_id = connection_id;
+        }
         return this.request(`/brokers/orders/${orderId}`, {
             method: 'PATCH',
             headers: {
@@ -746,6 +816,7 @@ class ApiClient {
                 'X-Device-Info': JSON.stringify(this.deviceInfo),
             },
             body: requestBody,
+            params: queryParams,
         });
     }
     // Context management methods
@@ -766,392 +837,340 @@ class ApiClient {
         this.tradingContext = {};
     }
     // Stock convenience methods
-    async placeStockMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras = {}) {
-        return this.placeBrokerOrder(accessToken, {
-            broker,
-            accountNumber,
+    async placeStockMarketOrder(symbol, orderQty, action, broker, accountNumber, extras = {}, connection_id) {
+        return this.placeBrokerOrder({
             symbol,
             orderQty,
             action,
             orderType: 'Market',
             assetType: 'Stock',
             timeInForce: 'day',
-        }, extras);
-    }
-    async placeStockLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
-        return this.placeBrokerOrder(accessToken, {
             broker,
             accountNumber,
+        }, extras, connection_id);
+    }
+    async placeStockLimitOrder(symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}, connection_id) {
+        return this.placeBrokerOrder({
             symbol,
             orderQty,
             action,
             orderType: 'Limit',
             assetType: 'Stock',
-            timeInForce,
             price,
-        }, extras);
-    }
-    async placeStockStopOrder(accessToken, symbol, orderQty, action, stopPrice, timeInForce = 'day', broker, accountNumber, extras = {}) {
-        return this.placeBrokerOrder(accessToken, {
+            timeInForce,
             broker,
             accountNumber,
+        }, extras, connection_id);
+    }
+    async placeStockStopOrder(symbol, orderQty, action, stopPrice, timeInForce = 'day', broker, accountNumber, extras = {}, connection_id) {
+        return this.placeBrokerOrder({
             symbol,
             orderQty,
             action,
             orderType: 'Stop',
             assetType: 'Stock',
-            timeInForce,
             stopPrice,
-        }, extras);
-    }
-    // Crypto convenience methods
-    async placeCryptoMarketOrder(accessToken, symbol, orderQty, action, options = {}, broker, accountNumber, extras = {}) {
-        const orderParams = {
+            timeInForce,
             broker,
             accountNumber,
+        }, extras, connection_id);
+    }
+    // Crypto convenience methods
+    async placeCryptoMarketOrder(symbol, orderQty, action, options = {}, broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             symbol,
-            orderQty: options.quantity || orderQty,
+            orderQty,
             action,
             orderType: 'Market',
             assetType: 'Crypto',
-            timeInForce: 'gtc', // Crypto typically uses GTC
-        };
-        // Add notional if provided
-        if (options.notional) {
-            orderParams.notional = options.notional;
-        }
-        return this.placeBrokerOrder(accessToken, orderParams, extras);
-    }
-    async placeCryptoLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', options = {}, broker, accountNumber, extras = {}) {
-        const orderParams = {
+            timeInForce: 'day',
             broker,
             accountNumber,
+            ...options,
+        }, extras);
+    }
+    async placeCryptoLimitOrder(symbol, orderQty, action, price, timeInForce = 'gtc', options = {}, broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             symbol,
-            orderQty: options.quantity || orderQty,
+            orderQty,
             action,
             orderType: 'Limit',
             assetType: 'Crypto',
-            timeInForce,
             price,
-        };
-        // Add notional if provided
-        if (options.notional) {
-            orderParams.notional = options.notional;
-        }
-        return this.placeBrokerOrder(accessToken, orderParams, extras);
-    }
-    // Options convenience methods
-    async placeOptionsMarketOrder(accessToken, symbol, orderQty, action, options, broker, accountNumber, extras = {}) {
-        const orderParams = {
+            timeInForce,
             broker,
             accountNumber,
+            ...options,
+        }, extras);
+    }
+    // Options convenience methods
+    async placeOptionsMarketOrder(symbol, orderQty, action, options, broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             symbol,
             orderQty,
             action,
             orderType: 'Market',
             assetType: 'Option',
             timeInForce: 'day',
-        };
-        // Add options-specific parameters to extras
-        const targetBroker = broker || this.tradingContext.broker;
-        const optionsExtras = {
-            ...extras,
-            ...(targetBroker && {
-                [targetBroker]: {
-                    ...extras[targetBroker],
-                    strikePrice: options.strikePrice,
-                    expirationDate: options.expirationDate,
-                    optionType: options.optionType,
-                    contractSize: options.contractSize || 100,
-                },
-            }),
-        };
-        return this.placeBrokerOrder(accessToken, orderParams, optionsExtras);
-    }
-    async placeOptionsLimitOrder(accessToken, symbol, orderQty, action, price, options, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
-        const orderParams = {
             broker,
             accountNumber,
+            ...options,
+        }, extras);
+    }
+    async placeOptionsLimitOrder(symbol, orderQty, action, price, options, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             symbol,
             orderQty,
             action,
             orderType: 'Limit',
             assetType: 'Option',
-            timeInForce,
             price,
-        };
-        // Add options-specific parameters to extras
-        const targetBroker = broker || this.tradingContext.broker;
-        const optionsExtras = {
-            ...extras,
-            ...(targetBroker && {
-                [targetBroker]: {
-                    ...extras[targetBroker],
-                    strikePrice: options.strikePrice,
-                    expirationDate: options.expirationDate,
-                    optionType: options.optionType,
-                    contractSize: options.contractSize || 100,
-                },
-            }),
-        };
-        return this.placeBrokerOrder(accessToken, orderParams, optionsExtras);
-    }
-    // Futures convenience methods
-    async placeFuturesMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras = {}) {
-        return this.placeBrokerOrder(accessToken, {
+            timeInForce,
             broker,
             accountNumber,
+            ...options,
+        }, extras);
+    }
+    // Futures convenience methods
+    async placeFuturesMarketOrder(symbol, orderQty, action, broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             symbol,
             orderQty,
             action,
             orderType: 'Market',
-            assetType: 'Futures',
+            assetType: 'Future',
             timeInForce: 'day',
-        }, extras);
-    }
-    async placeFuturesLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
-        return this.placeBrokerOrder(accessToken, {
             broker,
             accountNumber,
+        }, extras);
+    }
+    async placeFuturesLimitOrder(symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             symbol,
             orderQty,
             action,
             orderType: 'Limit',
-            assetType: 'Futures',
-            timeInForce,
+            assetType: 'Future',
             price,
+            timeInForce,
+            broker,
+            accountNumber,
         }, extras);
     }
     buildOrderRequestBody(params, extras = {}) {
         const baseOrder = {
-            order_type: params.orderType,
-            asset_type: params.assetType,
+            order_id: params.order_id,
+            orderType: params.orderType,
+            assetType: params.assetType,
             action: params.action,
-            time_in_force: params.timeInForce.toLowerCase(),
-            account_number: params.accountNumber,
+            timeInForce: params.timeInForce,
+            accountNumber: params.accountNumber,
             symbol: params.symbol,
-            order_qty: params.orderQty,
+            orderQty: params.orderQty,
         };
         if (params.price !== undefined)
             baseOrder.price = params.price;
         if (params.stopPrice !== undefined)
-            baseOrder.stop_price = params.stopPrice;
-        // Apply broker-specific defaults
-        const brokerExtras = this.applyBrokerDefaults(params.broker, extras[params.broker] || {});
+            baseOrder.stopPrice = params.stopPrice;
+        // Apply broker-specific defaults – map camelCase extras property keys to snake_case before merging
+        const brokerExtras = this.applyBrokerDefaults(params.broker, extras);
         return {
             broker: params.broker,
-            ...baseOrder,
-            ...brokerExtras,
+            order: {
+                ...baseOrder,
+                ...brokerExtras,
+            },
         };
     }
     buildModifyRequestBody(params, extras, broker) {
-        const requestBody = {
-            broker: broker,
-        };
+        const order = {};
+        if (params.order_id !== undefined)
+            order.order_id = params.order_id;
         if (params.orderType !== undefined)
-            requestBody.order_type = params.orderType;
+            order.orderType = params.orderType;
         if (params.assetType !== undefined)
-            requestBody.asset_type = params.assetType;
+            order.assetType = params.assetType;
         if (params.action !== undefined)
-            requestBody.action = params.action;
+            order.action = params.action;
         if (params.timeInForce !== undefined)
-            requestBody.time_in_force = params.timeInForce.toLowerCase();
+            order.timeInForce = params.timeInForce;
         if (params.accountNumber !== undefined)
-            requestBody.account_number = params.accountNumber;
+            order.accountNumber = params.accountNumber;
         if (params.symbol !== undefined)
-            requestBody.symbol = params.symbol;
+            order.symbol = params.symbol;
         if (params.orderQty !== undefined)
-            requestBody.order_qty = params.orderQty;
+            order.orderQty = params.orderQty;
         if (params.price !== undefined)
-            requestBody.price = params.price;
+            order.price = params.price;
         if (params.stopPrice !== undefined)
-            requestBody.stop_price = params.stopPrice;
-        // Apply broker-specific defaults
-        const brokerExtras = this.applyBrokerDefaults(broker, extras[broker] || {});
+            order.stopPrice = params.stopPrice;
+        // Apply broker-specific defaults (handles snake_case conversion)
+        const brokerExtras = this.applyBrokerDefaults(broker, extras);
         return {
-            ...requestBody,
-            ...brokerExtras,
+            broker,
+            order: {
+                ...order,
+                ...brokerExtras,
+            },
         };
     }
     applyBrokerDefaults(broker, extras) {
+        // If the caller provided a broker-scoped extras object (e.g. { ninjaTrader: { ... } })
+        // pull the nested object for easier processing.
+        if (extras && typeof extras === 'object') {
+            const scoped = broker === 'robinhood'
+                ? extras.robinhood
+                : broker === 'ninja_trader'
+                    ? extras.ninjaTrader
+                    : broker === 'tasty_trade'
+                        ? extras.tastyTrade
+                        : undefined;
+            if (scoped) {
+                extras = scoped;
+            }
+        }
         switch (broker) {
             case 'robinhood':
                 return {
-                    extendedHours: extras.extendedHours ?? true,
-                    marketHours: extras.marketHours ?? 'regular_hours',
-                    trailType: extras.trailType ?? 'percentage',
                     ...extras,
+                    extendedHours: extras?.extendedHours ?? extras?.extended_hours ?? true,
+                    marketHours: extras?.marketHours ?? extras?.market_hours ?? 'regular_hours',
+                    trailType: extras?.trailType ?? extras?.trail_type ?? 'percentage',
                 };
             case 'ninja_trader':
                 return {
-                    accountSpec: extras.accountSpec ?? '',
-                    isAutomated: extras.isAutomated ?? true,
                     ...extras,
+                    accountSpec: extras?.accountSpec ?? extras?.account_spec ?? '',
+                    isAutomated: extras?.isAutomated ?? extras?.is_automated ?? true,
                 };
             case 'tasty_trade':
                 return {
-                    automatedSource: extras.automatedSource ?? true,
                     ...extras,
+                    automatedSource: extras?.automatedSource ?? extras?.automated_source ?? true,
                 };
             default:
                 return extras;
         }
     }
-    async revokeToken(accessToken) {
-        return this.request('/auth/token/revoke', {
+    async revokeToken() {
+        const accessToken = await this.getValidAccessToken();
+        await this.request('/auth/token/revoke', {
             method: 'POST',
             headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${accessToken}`,
+                'Authorization': `Bearer ${accessToken}`,
             },
         });
+        this.clearTokens();
     }
     async getUserToken(userId) {
-        return this.request('/auth/token', {
-            method: 'POST',
+        const accessToken = await this.getValidAccessToken();
+        return this.request(`/auth/token/user/${userId}`, {
+            method: 'GET',
             headers: {
-                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${accessToken}`,
             },
-            body: { userId },
         });
     }
+    /**
+     * Get the current session state
+     */
     getCurrentSessionState() {
         return this.currentSessionState;
     }
+    /**
+     * Refresh the current session to extend its lifetime
+     */
+    async refreshSession() {
+        if (!this.currentSessionId || !this.companyId) {
+            throw new SessionError('No active session to refresh');
+        }
+        return this.request('/auth/session/refresh', {
+            method: 'POST',
+            headers: {
+                'Session-ID': this.currentSessionId,
+                'X-Company-ID': this.companyId,
+            },
+        });
+    }
     // Broker Data Management
-    async getBrokerList(accessToken) {
-        return this.request('/brokers/', {
+    async getBrokerList() {
+        const accessToken = await this.getValidAccessToken();
+        return this.request('/brokers/list', {
             method: 'GET',
             headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${accessToken}`,
-                'Session-ID': this.currentSessionId || '',
-                'X-Session-ID': this.currentSessionId || '',
-                'X-Device-Info': JSON.stringify({
-                    ip_address: this.deviceInfo?.ip_address || '',
-                    user_agent: this.deviceInfo?.user_agent || '',
-                    fingerprint: this.deviceInfo?.fingerprint || '',
-                }),
+                'Authorization': `Bearer ${accessToken}`,
             },
         });
     }
-    async getBrokerAccounts(accessToken, options) {
+    async getBrokerAccounts(options) {
+        const accessToken = await this.getValidAccessToken();
         const params = {};
-        if (options?.broker_name)
-            params.broker_name = options.broker_name;
-        if (options?.account_id)
+        if (options?.broker_name) {
+            params.broker_id = options.broker_name;
+        }
+        if (options?.account_id) {
             params.account_id = options.account_id;
+        }
+        if (options?.symbol) {
+            params.symbol = options.symbol;
+        }
         return this.request('/brokers/data/accounts', {
             method: 'GET',
             headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${accessToken}`,
-                'Session-ID': this.currentSessionId || '',
-                'X-Session-ID': this.currentSessionId || '',
-                'X-Device-Info': JSON.stringify({
-                    ip_address: this.deviceInfo?.ip_address || '',
-                    user_agent: this.deviceInfo?.user_agent || '',
-                    fingerprint: this.deviceInfo?.fingerprint || '',
-                }),
+                'Authorization': `Bearer ${accessToken}`,
             },
             params,
         });
     }
-    async getBrokerOrders(accessToken, options) {
+    async getBrokerOrders(options) {
+        const accessToken = await this.getValidAccessToken();
         const params = {};
-        if (options?.broker_name)
-            params.broker_name = options.broker_name;
-        if (options?.account_id)
+        if (options?.broker_name) {
+            params.broker_id = options.broker_name;
+        }
+        if (options?.account_id) {
             params.account_id = options.account_id;
-        if (options?.symbol)
+        }
+        if (options?.symbol) {
             params.symbol = options.symbol;
+        }
         return this.request('/brokers/data/orders', {
             method: 'GET',
             headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${accessToken}`,
-                'Session-ID': this.currentSessionId || '',
-                'X-Session-ID': this.currentSessionId || '',
-                'X-Device-Info': JSON.stringify({
-                    ip_address: this.deviceInfo?.ip_address || '',
-                    user_agent: this.deviceInfo?.user_agent || '',
-                    fingerprint: this.deviceInfo?.fingerprint || '',
-                }),
+                'Authorization': `Bearer ${accessToken}`,
             },
             params,
         });
     }
-    async getBrokerPositions(accessToken, options) {
-        const queryParams = {};
-        if (options?.broker_name)
-            queryParams.broker_name = options.broker_name;
-        if (options?.account_id)
-            queryParams.account_id = options.account_id;
-        if (options?.symbol)
-            queryParams.symbol = options.symbol;
+    async getBrokerPositions(options) {
+        const accessToken = await this.getValidAccessToken();
+        const params = {};
+        if (options?.broker_name) {
+            params.broker_id = options.broker_name;
+        }
+        if (options?.account_id) {
+            params.account_id = options.account_id;
+        }
+        if (options?.symbol) {
+            params.symbol = options.symbol;
+        }
         return this.request('/brokers/data/positions', {
             method: 'GET',
             headers: {
-                Authorization: `Bearer ${accessToken}`,
-                'Content-Type': 'application/json',
-                'Session-ID': this.currentSessionId || '',
-                'X-Session-ID': this.currentSessionId || '',
-                'X-Device-Info': JSON.stringify({
-                    ip_address: this.deviceInfo?.ip_address || '',
-                    user_agent: this.deviceInfo?.user_agent || '',
-                    fingerprint: this.deviceInfo?.fingerprint || '',
-                }),
+                'Authorization': `Bearer ${accessToken}`,
             },
-            params: queryParams,
+            params,
         });
     }
-    async getBrokerConnections(accessToken) {
+    async getBrokerConnections() {
+        const accessToken = await this.getValidAccessToken();
         return this.request('/brokers/connections', {
             method: 'GET',
             headers: {
-                Authorization: `Bearer ${accessToken}`,
-                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${accessToken}`,
             },
         });
     }
-    // Automatic token management versions of broker methods
-    async getBrokerListAuto() {
-        const accessToken = await this.getValidAccessToken();
-        return this.getBrokerList(accessToken);
-    }
-    async getBrokerAccountsAuto(options) {
-        const accessToken = await this.getValidAccessToken();
-        return this.getBrokerAccounts(accessToken, options);
-    }
-    async getBrokerOrdersAuto(options) {
-        const accessToken = await this.getValidAccessToken();
-        return this.getBrokerOrders(accessToken, options);
-    }
-    async getBrokerPositionsAuto(options) {
-        const accessToken = await this.getValidAccessToken();
-        return this.getBrokerPositions(accessToken, options);
-    }
-    async getBrokerConnectionsAuto() {
-        const accessToken = await this.getValidAccessToken();
-        return this.getBrokerConnections(accessToken);
-    }
-    // Automatic token management versions of trading methods
-    async placeBrokerOrderAuto(params, extras = {}) {
-        const accessToken = await this.getValidAccessToken();
-        return this.placeBrokerOrder(accessToken, params, extras);
-    }
-    async placeStockMarketOrderAuto(symbol, orderQty, action, broker, accountNumber, extras = {}) {
-        const accessToken = await this.getValidAccessToken();
-        return this.placeStockMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras);
-    }
-    async placeStockLimitOrderAuto(symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
-        const accessToken = await this.getValidAccessToken();
-        return this.placeStockLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce, broker, accountNumber, extras);
-    }
-    async placeStockStopOrderAuto(symbol, orderQty, action, stopPrice, timeInForce = 'day', broker, accountNumber, extras = {}) {
-        const accessToken = await this.getValidAccessToken();
-        return this.placeStockStopOrder(accessToken, symbol, orderQty, action, stopPrice, timeInForce, broker, accountNumber, extras);
-    }
     // Page-based pagination methods
     async getBrokerOrdersPage(page = 1, perPage = 100, filters) {
         const accessToken = await this.getValidAccessToken();
@@ -1184,25 +1203,57 @@ class ApiClient {
         const response = await this.request('/brokers/data/orders', {
             method: 'GET',
             headers: {
-                'Content-Type': 'application/json',
                 Authorization: `Bearer ${accessToken}`,
-                'X-Company-ID': this.companyId || '',
-                'X-Session-ID': this.currentSessionId || '',
-                'X-CSRF-Token': this.csrfToken || '',
-                'X-Device-Info': JSON.stringify({
-                    ip_address: this.deviceInfo?.ip_address || '',
-                    user_agent: this.deviceInfo?.user_agent || '',
-                    fingerprint: this.deviceInfo?.fingerprint || '',
-                }),
             },
             params,
         });
+        // Create navigation callback for pagination
+        const navigationCallback = async (newOffset, newLimit) => {
+            const newParams = {
+                limit: newLimit.toString(),
+                offset: newOffset.toString(),
+            };
+            // Add filter parameters
+            if (filters) {
+                if (filters.broker_id)
+                    newParams.broker_id = filters.broker_id;
+                if (filters.connection_id)
+                    newParams.connection_id = filters.connection_id;
+                if (filters.account_id)
+                    newParams.account_id = filters.account_id;
+                if (filters.symbol)
+                    newParams.symbol = filters.symbol;
+                if (filters.status)
+                    newParams.status = filters.status;
+                if (filters.side)
+                    newParams.side = filters.side;
+                if (filters.asset_type)
+                    newParams.asset_type = filters.asset_type;
+                if (filters.created_after)
+                    newParams.created_after = filters.created_after;
+                if (filters.created_before)
+                    newParams.created_before = filters.created_before;
+            }
+            const newResponse = await this.request('/brokers/data/orders', {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+                params: newParams,
+            });
+            return new PaginatedResult(newResponse.response_data, newResponse.pagination || {
+                has_more: false,
+                next_offset: newOffset,
+                current_offset: newOffset,
+                limit: newLimit,
+            }, navigationCallback);
+        };
         return new PaginatedResult(response.response_data, response.pagination || {
             has_more: false,
             next_offset: offset,
             current_offset: offset,
             limit: perPage,
-        });
+        }, navigationCallback);
     }
     async getBrokerAccountsPage(page = 1, perPage = 100, filters) {
         const accessToken = await this.getValidAccessToken();
@@ -1227,25 +1278,49 @@ class ApiClient {
         const response = await this.request('/brokers/data/accounts', {
             method: 'GET',
             headers: {
-                'Content-Type': 'application/json',
                 Authorization: `Bearer ${accessToken}`,
-                'X-Company-ID': this.companyId || '',
-                'X-Session-ID': this.currentSessionId || '',
-                'X-CSRF-Token': this.csrfToken || '',
-                'X-Device-Info': JSON.stringify({
-                    ip_address: this.deviceInfo?.ip_address || '',
-                    user_agent: this.deviceInfo?.user_agent || '',
-                    fingerprint: this.deviceInfo?.fingerprint || '',
-                }),
             },
             params,
         });
+        // Create navigation callback for pagination
+        const navigationCallback = async (newOffset, newLimit) => {
+            const newParams = {
+                limit: newLimit.toString(),
+                offset: newOffset.toString(),
+            };
+            // Add filter parameters
+            if (filters) {
+                if (filters.broker_id)
+                    newParams.broker_id = filters.broker_id;
+                if (filters.connection_id)
+                    newParams.connection_id = filters.connection_id;
+                if (filters.account_type)
+                    newParams.account_type = filters.account_type;
+                if (filters.status)
+                    newParams.status = filters.status;
+                if (filters.currency)
+                    newParams.currency = filters.currency;
+            }
+            const newResponse = await this.request('/brokers/data/accounts', {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+                params: newParams,
+            });
+            return new PaginatedResult(newResponse.response_data, newResponse.pagination || {
+                has_more: false,
+                next_offset: newOffset,
+                current_offset: newOffset,
+                limit: newLimit,
+            }, navigationCallback);
+        };
         return new PaginatedResult(response.response_data, response.pagination || {
             has_more: false,
             next_offset: offset,
             current_offset: offset,
             limit: perPage,
-        });
+        }, navigationCallback);
     }
     async getBrokerPositionsPage(page = 1, perPage = 100, filters) {
         const accessToken = await this.getValidAccessToken();
@@ -1270,25 +1345,49 @@ class ApiClient {
         const response = await this.request('/brokers/data/positions', {
             method: 'GET',
             headers: {
-                'Content-Type': 'application/json',
                 Authorization: `Bearer ${accessToken}`,
-                'X-Company-ID': this.companyId || '',
-                'X-Session-ID': this.currentSessionId || '',
-                'X-CSRF-Token': this.csrfToken || '',
-                'X-Device-Info': JSON.stringify({
-                    ip_address: this.deviceInfo?.ip_address || '',
-                    user_agent: this.deviceInfo?.user_agent || '',
-                    fingerprint: this.deviceInfo?.fingerprint || '',
-                }),
             },
             params,
         });
+        // Create navigation callback for pagination
+        const navigationCallback = async (newOffset, newLimit) => {
+            const newParams = {
+                limit: newLimit.toString(),
+                offset: newOffset.toString(),
+            };
+            // Add filter parameters
+            if (filters) {
+                if (filters.broker_id)
+                    newParams.broker_id = filters.broker_id;
+                if (filters.account_id)
+                    newParams.account_id = filters.account_id;
+                if (filters.symbol)
+                    newParams.symbol = filters.symbol;
+                if (filters.position_status)
+                    newParams.position_status = filters.position_status;
+                if (filters.side)
+                    newParams.side = filters.side;
+            }
+            const newResponse = await this.request('/brokers/data/positions', {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+                params: newParams,
+            });
+            return new PaginatedResult(newResponse.response_data, newResponse.pagination || {
+                has_more: false,
+                next_offset: newOffset,
+                current_offset: newOffset,
+                limit: newLimit,
+            }, navigationCallback);
+        };
         return new PaginatedResult(response.response_data, response.pagination || {
             has_more: false,
             next_offset: offset,
             current_offset: offset,
             limit: perPage,
-        });
+        }, navigationCallback);
     }
     // Navigation methods
     async getNextPage(previousResult, fetchFunction) {
@@ -1304,6 +1403,20 @@ class ApiClient {
     isMockClient() {
         return false;
     }
+    /**
+     * Disconnect a company from a broker connection
+     * @param connectionId - The connection ID to disconnect
+     * @returns Promise with disconnect response
+     */
+    async disconnectCompany(connectionId) {
+        const accessToken = await this.getValidAccessToken();
+        return this.request(`/brokers/disconnect-company/${connectionId}`, {
+            method: 'DELETE',
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+            },
+        });
+    }
 }
 
 class EventEmitter {
@@ -1809,6 +1922,17 @@ class MockDataProvider {
     async mockGetBrokerList() {
         await this.simulateDelay();
         const brokers = [
+            {
+                id: 'alpaca',
+                name: 'alpaca',
+                display_name: 'Alpaca',
+                description: 'Commission-free stock trading and crypto',
+                website: 'https://alpaca.markets',
+                features: ['stocks', 'crypto', 'fractional_shares', 'api_trading'],
+                auth_type: 'api_key',
+                logo_path: '/logos/alpaca.png',
+                is_active: true,
+            },
             {
                 id: 'robinhood',
                 name: 'robinhood',
@@ -2122,14 +2246,25 @@ class MockDataProvider {
         };
     }
     async mockPlaceOrder(order) {
-        await this.simulateDelay();
+        // Simulate API delay
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Generate a mock order ID
+        const orderId = `mock_order_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         return {
             success: true,
             response_data: {
-                orderId: uuid.v4(),
-                status: 'submitted',
-                broker: 'robinhood',
-                accountNumber: '123456789',
+                orderId: orderId,
+                status: 'pending',
+                broker: order.broker,
+                accountNumber: order.accountNumber,
+                symbol: order.symbol,
+                orderType: order.orderType,
+                assetType: order.assetType,
+                action: order.action,
+                quantity: order.orderQty,
+                price: order.price,
+                stopPrice: order.stopPrice,
+                timeInForce: order.timeInForce,
             },
             message: 'Order placed successfully',
             status_code: 200,
@@ -2225,9 +2360,9 @@ class MockDataProvider {
     }
     applyBrokerAccountFilters(accounts, filter) {
         return accounts.filter(account => {
-            if (filter.broker_id && account.broker_id !== filter.broker_id)
+            if (filter.broker_id && account.user_broker_connection_id !== filter.connection_id)
                 return false;
-            if (filter.connection_id && account.connection_id !== filter.connection_id)
+            if (filter.connection_id && account.user_broker_connection_id !== filter.connection_id)
                 return false;
             if (filter.account_type && account.account_type !== filter.account_type)
                 return false;
@@ -2367,7 +2502,6 @@ class MockDataProvider {
      */
     generateMockAccounts(count) {
         const accounts = [];
-        const brokers = ['robinhood', 'alpaca', 'tasty_trade', 'ninja_trader'];
         const accountTypes = ['margin', 'cash', 'crypto_wallet', 'live', 'sim'];
         const statuses = ['active', 'inactive'];
         const currencies = ['USD', 'EUR', 'GBP', 'CAD'];
@@ -2382,26 +2516,22 @@ class MockDataProvider {
             'Investment Account',
         ];
         for (let i = 0; i < count; i++) {
-            const broker = brokers[Math.floor(Math.random() * brokers.length)];
             const accountType = accountTypes[Math.floor(Math.random() * accountTypes.length)];
             const status = statuses[Math.floor(Math.random() * statuses.length)];
             const currency = currencies[Math.floor(Math.random() * currencies.length)];
             const accountName = accountNames[Math.floor(Math.random() * accountNames.length)];
             const cashBalance = Math.random() * 100000 + 1000;
             const buyingPower = cashBalance * (1 + Math.random() * 2); // 1-3x cash balance
-            const equity = buyingPower * (0.8 + Math.random() * 0.4); // ±20% variation
             accounts.push({
                 id: uuid.v4(),
-                broker_id: broker,
-                connection_id: uuid.v4(),
-                account_id: `account_${Math.floor(Math.random() * 1000000)}`,
+                user_broker_connection_id: uuid.v4(),
+                broker_provided_account_id: `account_${Math.floor(Math.random() * 1000000)}`,
                 account_name: `${accountName} ${i + 1}`,
                 account_type: accountType,
-                status,
                 currency,
                 cash_balance: cashBalance,
                 buying_power: buyingPower,
-                equity,
+                status,
                 created_at: new Date(Date.now() - Math.random() * 365 * 24 * 60 * 60 * 1000).toISOString(), // Random date within last year
                 updated_at: new Date().toISOString(),
                 last_synced_at: new Date().toISOString(),
@@ -2409,6 +2539,42 @@ class MockDataProvider {
         }
         return accounts;
     }
+    /**
+     * Mock disconnect company method
+     * @param connectionId - The connection ID to disconnect
+     * @returns Promise with mock disconnect response
+     */
+    async mockDisconnectCompany(connectionId) {
+        // Simulate API delay
+        await new Promise(resolve => setTimeout(resolve, 200));
+        // Randomly decide if this will delete the connection or just remove company access
+        const willDeleteConnection = Math.random() > 0.5;
+        if (willDeleteConnection) {
+            return {
+                success: true,
+                response_data: {
+                    connection_id: connectionId,
+                    action: 'connection_deleted',
+                    message: 'Company access removed and connection deleted (no companies remaining)',
+                },
+                message: 'Company access removed and connection deleted (no companies remaining)',
+                status_code: 200,
+            };
+        }
+        else {
+            return {
+                success: true,
+                response_data: {
+                    connection_id: connectionId,
+                    action: 'company_access_removed',
+                    remaining_companies: Math.floor(Math.random() * 5) + 1, // 1-5 remaining companies
+                    message: 'Company access removed from connection',
+                },
+                message: 'Company access removed from connection',
+                status_code: 200,
+            };
+        }
+    }
 }
 
 /**
@@ -2618,38 +2784,34 @@ class MockApiClient {
         return this.mockDataProvider.mockCompletePortalSession(sessionId);
     }
     // Portfolio Management
-    async getHoldings(accessToken) {
+    async getHoldings(filter) {
+        await this.getValidAccessToken();
         return this.mockDataProvider.mockGetHoldings();
     }
-    async getOrders(accessToken, filter) {
+    async getOrders(filter) {
+        await this.getValidAccessToken();
         return this.mockDataProvider.mockGetOrders(filter);
     }
-    async getPortfolio(accessToken) {
+    async getPortfolio() {
+        await this.getValidAccessToken();
         return this.mockDataProvider.mockGetPortfolio();
     }
-    async placeOrder(accessToken, order) {
+    async placeOrder(order) {
+        await this.getValidAccessToken();
         await this.mockDataProvider.mockPlaceOrder(order);
     }
-    // New methods with automatic token management
-    async getHoldingsAuto() {
-        const accessToken = await this.getValidAccessToken();
-        return this.getHoldings(accessToken);
-    }
-    async getOrdersAuto() {
-        const accessToken = await this.getValidAccessToken();
-        return this.getOrders(accessToken);
-    }
-    async getPortfolioAuto() {
-        const accessToken = await this.getValidAccessToken();
-        return this.getPortfolio(accessToken);
-    }
-    async placeOrderAuto(order) {
-        const accessToken = await this.getValidAccessToken();
-        return this.placeOrder(accessToken, order);
-    }
     // Enhanced Trading Methods with Session Management
-    async placeBrokerOrder(accessToken, params, extras = {}) {
-        // Merge context with provided parameters
+    async placeBrokerOrder(params, extras = {}, connection_id) {
+        await this.getValidAccessToken();
+        // Debug logging
+        console.log('MockApiClient.placeBrokerOrder Debug:', {
+            params,
+            tradingContext: this.tradingContext,
+            paramsBroker: params.broker,
+            contextBroker: this.tradingContext.broker,
+            paramsAccountNumber: params.accountNumber,
+            contextAccountNumber: this.tradingContext.accountNumber
+        });
         const fullParams = {
             broker: (params.broker || this.tradingContext.broker) ||
                 (() => {
@@ -2668,40 +2830,33 @@ class MockApiClient {
             timeInForce: params.timeInForce || 'day',
             price: params.price,
             stopPrice: params.stopPrice,
+            order_id: params.order_id,
         };
-        // Convert timeInForce to the Order interface format
-        const timeInForce = fullParams.timeInForce === 'gtd' ? 'gtc' : fullParams.timeInForce;
-        return this.mockDataProvider.mockPlaceOrder({
-            symbol: fullParams.symbol,
-            side: fullParams.action.toLowerCase(),
-            quantity: fullParams.orderQty,
-            type_: fullParams.orderType.toLowerCase(),
-            timeInForce: timeInForce,
-            price: fullParams.price,
-            stopPrice: fullParams.stopPrice,
-        });
+        console.log('MockApiClient.placeBrokerOrder Debug - Final params:', fullParams);
+        return this.mockDataProvider.mockPlaceOrder(fullParams);
     }
-    async cancelBrokerOrder(orderId, broker, extras = {}) {
+    async cancelBrokerOrder(orderId, broker, extras = {}, connection_id) {
+        // Mock successful cancellation
         return {
             success: true,
             response_data: {
-                orderId,
+                orderId: orderId,
                 status: 'cancelled',
-                broker: broker || this.tradingContext.broker || 'robinhood',
-                accountNumber: this.tradingContext.accountNumber || '123456789',
+                broker: broker || this.tradingContext.broker,
             },
             message: 'Order cancelled successfully',
             status_code: 200,
         };
     }
-    async modifyBrokerOrder(orderId, params, broker, extras = {}) {
+    async modifyBrokerOrder(orderId, params, broker, extras = {}, connection_id) {
+        // Mock successful modification
         return {
             success: true,
             response_data: {
-                orderId,
+                orderId: orderId,
                 status: 'modified',
-                broker: broker || this.tradingContext.broker || 'robinhood',
-                accountNumber: this.tradingContext.accountNumber || '123456789',
+                broker: broker || this.tradingContext.broker,
+                ...params,
             },
             message: 'Order modified successfully',
             status_code: 200,
@@ -2715,8 +2870,14 @@ class MockApiClient {
         this.tradingContext.accountId = undefined;
     }
     setAccount(accountNumber, accountId) {
+        console.log('MockApiClient.setAccount Debug:', {
+            accountNumber,
+            accountId,
+            previousContext: { ...this.tradingContext }
+        });
         this.tradingContext.accountNumber = accountNumber;
         this.tradingContext.accountId = accountId;
+        console.log('MockApiClient.setAccount Debug - Updated context:', this.tradingContext);
     }
     getTradingContext() {
         return { ...this.tradingContext };
@@ -2725,8 +2886,8 @@ class MockApiClient {
         this.tradingContext = {};
     }
     // Stock convenience methods
-    async placeStockMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras = {}) {
-        return this.placeBrokerOrder(accessToken, {
+    async placeStockMarketOrder(symbol, orderQty, action, broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             broker,
             accountNumber,
             symbol,
@@ -2737,8 +2898,8 @@ class MockApiClient {
             timeInForce: 'day',
         }, extras);
     }
-    async placeStockLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
-        return this.placeBrokerOrder(accessToken, {
+    async placeStockLimitOrder(symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             broker,
             accountNumber,
             symbol,
@@ -2750,8 +2911,8 @@ class MockApiClient {
             price,
         }, extras);
     }
-    async placeStockStopOrder(accessToken, symbol, orderQty, action, stopPrice, timeInForce = 'day', broker, accountNumber, extras = {}) {
-        return this.placeBrokerOrder(accessToken, {
+    async placeStockStopOrder(symbol, orderQty, action, stopPrice, timeInForce = 'day', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             broker,
             accountNumber,
             symbol,
@@ -2764,7 +2925,7 @@ class MockApiClient {
         }, extras);
     }
     // Crypto convenience methods
-    async placeCryptoMarketOrder(accessToken, symbol, orderQty, action, options = {}, broker, accountNumber, extras = {}) {
+    async placeCryptoMarketOrder(symbol, orderQty, action, options = {}, broker, accountNumber, extras = {}) {
         const orderParams = {
             broker,
             accountNumber,
@@ -2775,9 +2936,9 @@ class MockApiClient {
             assetType: 'Crypto',
             timeInForce: 'gtc', // Crypto typically uses GTC
         };
-        return this.placeBrokerOrder(accessToken, orderParams, extras);
+        return this.placeBrokerOrder(orderParams, extras);
     }
-    async placeCryptoLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', options = {}, broker, accountNumber, extras = {}) {
+    async placeCryptoLimitOrder(symbol, orderQty, action, price, timeInForce = 'gtc', options = {}, broker, accountNumber, extras = {}) {
         const orderParams = {
             broker,
             accountNumber,
@@ -2789,10 +2950,10 @@ class MockApiClient {
             timeInForce,
             price,
         };
-        return this.placeBrokerOrder(accessToken, orderParams, extras);
+        return this.placeBrokerOrder(orderParams, extras);
     }
     // Options convenience methods
-    async placeOptionsMarketOrder(accessToken, symbol, orderQty, action, options, broker, accountNumber, extras = {}) {
+    async placeOptionsMarketOrder(symbol, orderQty, action, options, broker, accountNumber, extras = {}) {
         const orderParams = {
             broker,
             accountNumber,
@@ -2803,9 +2964,9 @@ class MockApiClient {
             assetType: 'Option',
             timeInForce: 'day',
         };
-        return this.placeBrokerOrder(accessToken, orderParams, extras);
+        return this.placeBrokerOrder(orderParams, extras);
     }
-    async placeOptionsLimitOrder(accessToken, symbol, orderQty, action, price, options, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+    async placeOptionsLimitOrder(symbol, orderQty, action, price, options, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
         const orderParams = {
             broker,
             accountNumber,
@@ -2817,30 +2978,30 @@ class MockApiClient {
             timeInForce,
             price,
         };
-        return this.placeBrokerOrder(accessToken, orderParams, extras);
+        return this.placeBrokerOrder(orderParams, extras);
     }
     // Futures convenience methods
-    async placeFuturesMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras = {}) {
-        return this.placeBrokerOrder(accessToken, {
+    async placeFuturesMarketOrder(symbol, orderQty, action, broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             broker,
             accountNumber,
             symbol,
             orderQty,
             action,
             orderType: 'Market',
-            assetType: 'Futures',
+            assetType: 'Future',
             timeInForce: 'day',
         }, extras);
     }
-    async placeFuturesLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
-        return this.placeBrokerOrder(accessToken, {
+    async placeFuturesLimitOrder(symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder({
             broker,
             accountNumber,
             symbol,
             orderQty,
             action,
             orderType: 'Limit',
-            assetType: 'Futures',
+            assetType: 'Future',
             timeInForce,
             price,
         }, extras);
@@ -2860,13 +3021,16 @@ class MockApiClient {
         return this.currentSessionState;
     }
     // Broker Data Management
-    async getBrokerList(accessToken) {
+    async getBrokerList() {
+        await this.getValidAccessToken();
         return this.mockDataProvider.mockGetBrokerList();
     }
-    async getBrokerAccounts(accessToken, options) {
+    async getBrokerAccounts(options) {
+        await this.getValidAccessToken();
         return this.mockDataProvider.mockGetBrokerAccounts();
     }
-    async getBrokerOrders(accessToken, options) {
+    async getBrokerOrders(options) {
+        await this.getValidAccessToken();
         // Return empty orders for now - keeping original interface
         return {
             _id: uuid.v4(),
@@ -2877,7 +3041,8 @@ class MockApiClient {
             errors: null,
         };
     }
-    async getBrokerPositions(accessToken, options) {
+    async getBrokerPositions(options) {
+        await this.getValidAccessToken();
         // Return empty positions for now - keeping original interface
         return {
             _id: uuid.v4(),
@@ -2989,46 +3154,18 @@ class MockApiClient {
             limit: perPage,
         }, navigationCallback);
     }
-    async getBrokerConnections(accessToken) {
+    async getBrokerConnections() {
+        await this.getValidAccessToken();
         return this.mockDataProvider.mockGetBrokerConnections();
     }
-    // Automatic token management versions of broker methods
-    async getBrokerListAuto() {
-        const accessToken = await this.getValidAccessToken();
-        return this.getBrokerList(accessToken);
-    }
-    async getBrokerAccountsAuto(options) {
-        const accessToken = await this.getValidAccessToken();
-        return this.getBrokerAccounts(accessToken, options);
-    }
-    async getBrokerOrdersAuto(options) {
-        const accessToken = await this.getValidAccessToken();
-        return this.getBrokerOrders(accessToken, options);
-    }
-    async getBrokerPositionsAuto(options) {
-        const accessToken = await this.getValidAccessToken();
-        return this.getBrokerPositions(accessToken, options);
-    }
-    async getBrokerConnectionsAuto() {
-        const accessToken = await this.getValidAccessToken();
-        return this.getBrokerConnections(accessToken);
-    }
-    // Automatic token management versions of trading methods
-    async placeBrokerOrderAuto(params, extras = {}) {
-        const accessToken = await this.getValidAccessToken();
-        return this.placeBrokerOrder(accessToken, params, extras);
-    }
-    async placeStockMarketOrderAuto(symbol, orderQty, action, broker, accountNumber, extras = {}) {
-        const accessToken = await this.getValidAccessToken();
-        return this.placeStockMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras);
-    }
-    async placeStockLimitOrderAuto(symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
-        const accessToken = await this.getValidAccessToken();
-        return this.placeStockLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce, broker, accountNumber, extras);
-    }
-    async placeStockStopOrderAuto(symbol, orderQty, action, stopPrice, timeInForce = 'day', broker, accountNumber, extras = {}) {
-        const accessToken = await this.getValidAccessToken();
-        return this.placeStockStopOrder(accessToken, symbol, orderQty, action, stopPrice, timeInForce, broker, accountNumber, extras);
+    /**
+     * Mock disconnect company method
+     * @param connectionId - The connection ID to disconnect
+     * @returns Promise with mock disconnect response
+     */
+    async disconnectCompany(connectionId) {
+        await this.getValidAccessToken();
+        return this.mockDataProvider.mockDisconnectCompany(connectionId);
     }
     // Utility methods for mock system
     getMockDataProvider() {
@@ -3676,6 +3813,63 @@ function createCustomThemeFromPreset(preset, modifications) {
     };
 }
 
+/**
+ * Broker filtering utility functions
+ */
+// Supported broker names and their corresponding IDs
+const SUPPORTED_BROKERS = {
+    'alpaca': 'alpaca',
+    'robinhood': 'robinhood',
+    'tasty_trade': 'tasty_trade',
+    'ninja_trader': 'ninja_trader'
+};
+/**
+ * Convert broker names to broker IDs, filtering out unsupported ones
+ * @param brokerNames Array of broker names to convert
+ * @returns Object containing valid broker IDs and any warnings about unsupported names
+ */
+function convertBrokerNamesToIds(brokerNames) {
+    const brokerIds = [];
+    const warnings = [];
+    for (const brokerName of brokerNames) {
+        const brokerId = SUPPORTED_BROKERS[brokerName.toLowerCase()];
+        if (brokerId) {
+            brokerIds.push(brokerId);
+        }
+        else {
+            warnings.push(`Broker name '${brokerName}' is not supported. Supported brokers: ${Object.keys(SUPPORTED_BROKERS).join(', ')}`);
+        }
+    }
+    return { brokerIds, warnings };
+}
+/**
+ * Append broker filter parameters to a portal URL
+ * @param baseUrl The base portal URL (may already have query parameters)
+ * @param brokerNames Array of broker names to filter by
+ * @returns The portal URL with broker filter parameters appended
+ */
+function appendBrokerFilterToURL(baseUrl, brokerNames) {
+    if (!brokerNames || brokerNames.length === 0) {
+        return baseUrl;
+    }
+    try {
+        const url = new URL(baseUrl);
+        const { brokerIds, warnings } = convertBrokerNamesToIds(brokerNames);
+        // Log warnings for unsupported broker names
+        warnings.forEach(warning => console.warn(`[FinaticConnect] ${warning}`));
+        // Only add broker filter if we have valid broker IDs
+        if (brokerIds.length > 0) {
+            const encodedBrokers = btoa(JSON.stringify(brokerIds));
+            url.searchParams.set('brokers', encodedBrokers);
+        }
+        return url.toString();
+    }
+    catch (error) {
+        console.error('Failed to append broker filter to URL:', error);
+        return baseUrl;
+    }
+}
+
 class FinaticConnect extends EventEmitter {
     constructor(options, deviceInfo) {
         super();
@@ -3685,6 +3879,12 @@ class FinaticConnect extends EventEmitter {
         this.BROKER_LIST_CACHE_VERSION = '1.0';
         this.BROKER_LIST_CACHE_DURATION = 1000 * 60 * 60 * 24; // 24 hours in milliseconds
         this.currentSessionState = null;
+        // Session keep-alive mechanism
+        this.sessionKeepAliveInterval = null;
+        this.SESSION_KEEP_ALIVE_INTERVAL = 1000 * 60 * 5; // 5 minutes
+        this.SESSION_VALIDATION_TIMEOUT = 1000 * 30; // 30 seconds
+        this.SESSION_REFRESH_BUFFER_HOURS = 16; // Refresh session at 16 hours
+        this.sessionStartTime = null;
         this.options = options;
         this.baseUrl = options.baseUrl || 'https://api.finatic.dev';
         this.apiClient = MockFactory.createApiClient(this.baseUrl, deviceInfo);
@@ -3827,6 +4027,12 @@ class FinaticConnect extends EventEmitter {
      * @returns FinaticConnect instance
      */
     static async init(token, userId, options) {
+        // Safari-specific fix: Clear instance if it exists but has no valid session
+        // This prevents stale instances from interfering with new requests
+        if (FinaticConnect.instance && !FinaticConnect.instance.sessionId) {
+            console.log('[FinaticConnect] Clearing stale instance for Safari compatibility');
+            FinaticConnect.instance = null;
+        }
         if (!FinaticConnect.instance) {
             const connectOptions = {
                 token,
@@ -3856,6 +4062,8 @@ class FinaticConnect extends EventEmitter {
             const startResponse = await FinaticConnect.instance.apiClient.startSession(token, normalizedUserId);
             FinaticConnect.instance.sessionId = startResponse.data.session_id;
             FinaticConnect.instance.companyId = startResponse.data.company_id || '';
+            // Record session start time for automatic refresh
+            FinaticConnect.instance.sessionStartTime = Date.now();
             // Set session context in API client
             if (FinaticConnect.instance.apiClient &&
                 typeof FinaticConnect.instance.apiClient.setSessionContext === 'function') {
@@ -3965,7 +4173,9 @@ class FinaticConnect extends EventEmitter {
                 throw new Error('Failed to get portal URL');
             }
             // Apply theme to portal URL if provided
-            const themedPortalUrl = appendThemeToURL(portalResponse.data.portal_url, options?.theme);
+            let themedPortalUrl = appendThemeToURL(portalResponse.data.portal_url, options?.theme);
+            // Apply broker filter to portal URL if provided
+            themedPortalUrl = appendBrokerFilterToURL(themedPortalUrl, options?.brokers);
             // Create portal UI if not exists
             if (!this.portalUI) {
                 this.portalUI = new PortalUI(this.baseUrl);
@@ -4105,15 +4315,16 @@ class FinaticConnect extends EventEmitter {
                         ? 'Limit'
                         : order.orderType === 'stop'
                             ? 'Stop'
-                            : 'TrailingStop',
+                            : 'StopLimit',
                 assetType: order.assetType || 'Stock',
                 timeInForce: order.timeInForce,
                 price: order.price,
                 stopPrice: order.stopPrice,
                 broker: order.broker,
                 accountNumber: order.accountNumber,
+                order_id: order.order_id,
             };
-            return await this.apiClient.placeBrokerOrder(this.userToken.accessToken, brokerOrder);
+            return await this.apiClient.placeBrokerOrder(this.userToken.accessToken, brokerOrder, {}, order.connection_id);
         }
         catch (error) {
             this.emit('error', error);
@@ -4124,13 +4335,14 @@ class FinaticConnect extends EventEmitter {
      * Cancel a broker order
      * @param orderId - The order ID to cancel
      * @param broker - Optional broker override
+     * @param connection_id - Optional connection ID for testing bypass
      */
-    async cancelOrder(orderId, broker) {
+    async cancelOrder(orderId, broker, connection_id) {
         if (!this.userToken) {
             throw new Error('Not initialized with user');
         }
         try {
-            return await this.apiClient.cancelBrokerOrder(orderId, broker);
+            return await this.apiClient.cancelBrokerOrder(orderId, broker, {}, connection_id);
         }
         catch (error) {
             this.emit('error', error);
@@ -4142,8 +4354,9 @@ class FinaticConnect extends EventEmitter {
      * @param orderId - The order ID to modify
      * @param modifications - The modifications to apply
      * @param broker - Optional broker override
+     * @param connection_id - Optional connection ID for testing bypass
      */
-    async modifyOrder(orderId, modifications, broker) {
+    async modifyOrder(orderId, modifications, broker, connection_id) {
         if (!this.userToken) {
             throw new Error('Not initialized with user');
         }
@@ -4160,7 +4373,13 @@ class FinaticConnect extends EventEmitter {
                 brokerModifications.stopPrice = modifications.stopPrice;
             if (modifications.timeInForce)
                 brokerModifications.timeInForce = modifications.timeInForce;
-            return await this.apiClient.modifyBrokerOrder(orderId, brokerModifications, broker);
+            if (modifications.orderType)
+                brokerModifications.orderType = modifications.orderType;
+            if (modifications.side)
+                brokerModifications.action = modifications.side;
+            if (modifications.order_id)
+                brokerModifications.order_id = modifications.order_id;
+            return await this.apiClient.modifyBrokerOrder(orderId, brokerModifications, broker, {}, connection_id);
         }
         catch (error) {
             this.emit('error', error);
@@ -4202,7 +4421,7 @@ class FinaticConnect extends EventEmitter {
             throw new Error('Not initialized with user');
         }
         try {
-            return await this.apiClient.placeStockMarketOrder(this.userToken.accessToken, symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', broker, accountNumber);
+            return await this.apiClient.placeStockMarketOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', broker, accountNumber);
         }
         catch (error) {
             this.emit('error', error);
@@ -4217,7 +4436,7 @@ class FinaticConnect extends EventEmitter {
             throw new Error('Not initialized with user');
         }
         try {
-            return await this.apiClient.placeStockLimitOrder(this.userToken.accessToken, symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', price, timeInForce, broker, accountNumber);
+            return await this.apiClient.placeStockLimitOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', price, timeInForce, broker, accountNumber);
         }
         catch (error) {
             this.emit('error', error);
@@ -4246,7 +4465,7 @@ class FinaticConnect extends EventEmitter {
         if (!this.isAuthed()) {
             throw new AuthenticationError('Not authenticated');
         }
-        const response = await this.apiClient.getBrokerListAuto();
+        const response = await this.apiClient.getBrokerList();
         const baseUrl = this.baseUrl.replace('/api/v1', ''); // Remove /api/v1 to get the base URL
         // Transform the broker list to include full logo URLs
         return response.response_data.map((broker) => ({
@@ -4266,7 +4485,7 @@ class FinaticConnect extends EventEmitter {
         if (!this.userToken?.user_id) {
             throw new AuthenticationError('No user ID available. Please connect a broker first.');
         }
-        const response = await this.apiClient.getBrokerConnectionsAuto();
+        const response = await this.apiClient.getBrokerConnections();
         if (response.status_code !== 200) {
             throw new Error(response.message || 'Failed to retrieve broker connections');
         }
@@ -4482,28 +4701,144 @@ class FinaticConnect extends EventEmitter {
         return allData;
     }
     /**
-     * Register automatic session cleanup on page unload/visibility change
+     * Register session management (but don't auto-cleanup for 24-hour sessions)
      */
     registerSessionCleanup() {
-        // Cleanup on page unload (refresh, close tab, navigate away)
+        // Only cleanup on actual page unload (not visibility changes)
+        // This prevents sessions from being closed when users switch tabs or apps
         window.addEventListener('beforeunload', this.handleSessionCleanup.bind(this));
-        // Cleanup on page visibility change (mobile browsers, app switching)
+        // Handle visibility changes for keep-alive management (but don't complete sessions)
         document.addEventListener('visibilitychange', this.handleVisibilityChange.bind(this));
+        // Start session keep-alive mechanism
+        this.startSessionKeepAlive();
+    }
+    /**
+     * Start the session keep-alive mechanism
+     */
+    startSessionKeepAlive() {
+        if (this.sessionKeepAliveInterval) {
+            clearInterval(this.sessionKeepAliveInterval);
+        }
+        this.sessionKeepAliveInterval = setInterval(() => {
+            this.validateSessionKeepAlive();
+        }, this.SESSION_KEEP_ALIVE_INTERVAL);
+        console.log('[FinaticConnect] Session keep-alive started (5-minute intervals)');
+    }
+    /**
+     * Stop the session keep-alive mechanism
+     */
+    stopSessionKeepAlive() {
+        if (this.sessionKeepAliveInterval) {
+            clearInterval(this.sessionKeepAliveInterval);
+            this.sessionKeepAliveInterval = null;
+            console.log('[FinaticConnect] Session keep-alive stopped');
+        }
+    }
+    /**
+     * Validate session for keep-alive purposes and handle automatic refresh
+     */
+    async validateSessionKeepAlive() {
+        if (!this.sessionId || !this.isAuthed()) {
+            console.log('[FinaticConnect] Session keep-alive skipped - no active session');
+            return;
+        }
+        try {
+            console.log('[FinaticConnect] Validating session for keep-alive...');
+            // Check if we need to refresh the session (at 16 hours)
+            if (this.shouldRefreshSession()) {
+                await this.refreshSessionAutomatically();
+                return;
+            }
+            // Use a timeout to prevent hanging requests
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('Session validation timeout')), this.SESSION_VALIDATION_TIMEOUT);
+            });
+            const validationPromise = this.apiClient.validatePortalSession(this.sessionId, '');
+            const response = await Promise.race([validationPromise, timeoutPromise]);
+            if (response && response.status === 'active') {
+                console.log('[FinaticConnect] Session keep-alive successful');
+                this.currentSessionState = 'active';
+            }
+            else {
+                console.warn('[FinaticConnect] Session keep-alive failed - session not active');
+                this.currentSessionState = response?.status || 'unknown';
+            }
+        }
+        catch (error) {
+            console.warn('[FinaticConnect] Session keep-alive error:', error);
+            // Don't throw errors during keep-alive - just log them
+        }
+    }
+    /**
+     * Check if the session should be refreshed (after 16 hours)
+     */
+    shouldRefreshSession() {
+        if (!this.sessionStartTime) {
+            return false;
+        }
+        const sessionAgeHours = (Date.now() - this.sessionStartTime) / (1000 * 60 * 60);
+        const hoursUntilRefresh = this.SESSION_REFRESH_BUFFER_HOURS - sessionAgeHours;
+        if (hoursUntilRefresh <= 0) {
+            console.log(`[FinaticConnect] Session is ${sessionAgeHours.toFixed(1)} hours old - triggering refresh`);
+            return true;
+        }
+        // Log when refresh will occur (every 5 minutes during keep-alive)
+        if (hoursUntilRefresh <= 1) {
+            console.log(`[FinaticConnect] Session will refresh in ${hoursUntilRefresh.toFixed(1)} hours`);
+        }
+        return false;
+    }
+    /**
+     * Automatically refresh the session to extend its lifetime
+     */
+    async refreshSessionAutomatically() {
+        if (!this.sessionId) {
+            console.warn('[FinaticConnect] Cannot refresh session - no session ID');
+            return;
+        }
+        try {
+            console.log('[FinaticConnect] Automatically refreshing session (16+ hours old)...');
+            const response = await this.apiClient.refreshSession();
+            if (response.success) {
+                console.log('[FinaticConnect] Session automatically refreshed successfully');
+                console.log('[FinaticConnect] New session expires at:', response.response_data.expires_at);
+                this.currentSessionState = response.response_data.status;
+                // Update session start time to prevent immediate re-refresh
+                this.sessionStartTime = Date.now();
+            }
+            else {
+                console.warn('[FinaticConnect] Automatic session refresh failed');
+            }
+        }
+        catch (error) {
+            console.warn('[FinaticConnect] Automatic session refresh error:', error);
+            // Don't throw errors during automatic refresh - just log them
+        }
     }
     /**
      * Handle session cleanup when page is unloading
      */
     async handleSessionCleanup() {
+        this.stopSessionKeepAlive();
         if (this.sessionId) {
             await this.completeSession(this.sessionId);
         }
     }
     /**
      * Handle visibility change (mobile browsers)
+     * Note: We don't complete sessions on visibility change for 24-hour sessions
      */
     async handleVisibilityChange() {
-        if (document.visibilityState === 'hidden' && this.sessionId) {
-            await this.completeSession(this.sessionId);
+        // For 24-hour sessions, we don't want to complete sessions on visibility changes
+        // This prevents sessions from being closed when users switch tabs or apps
+        console.log('[FinaticConnect] Page visibility changed to:', document.visibilityState);
+        // Only pause keep-alive when hidden, but don't complete the session
+        if (document.visibilityState === 'hidden') {
+            this.stopSessionKeepAlive();
+        }
+        else if (document.visibilityState === 'visible') {
+            // Restart keep-alive when page becomes visible again
+            this.startSessionKeepAlive();
         }
     }
     /**
@@ -4541,242 +4876,23 @@ class FinaticConnect extends EventEmitter {
             console.warn('[FinaticConnect] Session cleanup failed:', error);
         }
     }
-}
-FinaticConnect.instance = null;
-
-class CoreTradingService {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    async getAccounts(filter) {
-        return this.getAllAccounts(filter);
-    }
-    async getOrders(filter) {
-        return this.getAllOrders(filter);
-    }
-    async getPositions(filter) {
-        return this.getAllPositions(filter);
-    }
-    async placeOrder(order) {
-        const response = await this.apiClient.placeOrder(order);
-        return response.data.orderId;
-    }
-    async cancelOrder(orderId) {
-        const response = await this.apiClient.cancelOrder(orderId);
-        return response.data.success;
-    }
-    async placeOptionsOrder(order) {
-        const response = await this.apiClient.placeOptionsOrder(order);
-        return response.data.orderId;
-    }
-    // Pagination methods
-    async getAccountsPage(page = 1, perPage = 100, filter) {
-        return this.apiClient.getBrokerAccountsPage(page, perPage, filter);
-    }
-    async getOrdersPage(page = 1, perPage = 100, filter) {
-        return this.apiClient.getBrokerOrdersPage(page, perPage, filter);
-    }
-    async getPositionsPage(page = 1, perPage = 100, filter) {
-        return this.apiClient.getBrokerPositionsPage(page, perPage, filter);
-    }
-    // Navigation methods
-    async getNextAccountsPage(previousResult) {
-        return this.apiClient.getNextPage(previousResult, (offset, limit) => this.apiClient.getBrokerAccountsPage(1, limit, { offset }));
-    }
-    async getNextOrdersPage(previousResult) {
-        return this.apiClient.getNextPage(previousResult, (offset, limit) => this.apiClient.getBrokerOrdersPage(1, limit, { offset }));
-    }
-    async getNextPositionsPage(previousResult) {
-        return this.apiClient.getNextPage(previousResult, (offset, limit) => this.apiClient.getBrokerPositionsPage(1, limit, { offset }));
-    }
-    // Get all pages convenience methods
-    async getAllAccounts(filter) {
-        const allData = [];
-        let currentResult = await this.getAccountsPage(1, 100, filter);
-        while (currentResult) {
-            allData.push(...currentResult.data);
-            if (!currentResult.hasNext)
-                break;
-            const nextResult = await this.getNextAccountsPage(currentResult);
-            if (!nextResult)
-                break;
-            currentResult = nextResult;
-        }
-        return allData;
-    }
-    async getAllOrders(filter) {
-        const allData = [];
-        let currentResult = await this.getOrdersPage(1, 100, filter);
-        while (currentResult) {
-            allData.push(...currentResult.data);
-            if (!currentResult.hasNext)
-                break;
-            const nextResult = await this.getNextOrdersPage(currentResult);
-            if (!nextResult)
-                break;
-            currentResult = nextResult;
-        }
-        return allData;
-    }
-    async getAllPositions(filter) {
-        const allData = [];
-        let currentResult = await this.getPositionsPage(1, 100, filter);
-        while (currentResult) {
-            allData.push(...currentResult.data);
-            if (!currentResult.hasNext)
-                break;
-            const nextResult = await this.getNextPositionsPage(currentResult);
-            if (!nextResult)
-                break;
-            currentResult = nextResult;
-        }
-        return allData;
-    }
-    // Abstract convenience methods
-    async getOpenPositions() {
-        return this.getPositions({ position_status: 'open' });
-    }
-    async getFilledOrders() {
-        return this.getOrders({ status: 'filled' });
-    }
-    async getPendingOrders() {
-        return this.getOrders({ status: 'pending' });
-    }
-    async getActiveAccounts() {
-        return this.getAccounts({ status: 'active' });
-    }
-    async getOrdersBySymbol(symbol) {
-        return this.getOrders({ symbol });
-    }
-    async getPositionsBySymbol(symbol) {
-        return this.getPositions({ symbol });
-    }
-    async getOrdersByBroker(brokerId) {
-        return this.getOrders({ broker_id: brokerId });
-    }
-    async getPositionsByBroker(brokerId) {
-        return this.getPositions({ broker_id: brokerId });
-    }
-}
-
-class CoreAnalyticsService {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    async getPerformance() {
-        const response = await this.apiClient.getPerformance();
-        return response.data.performance;
-    }
-    async getDailyHistory() {
-        const response = await this.apiClient.getDailyHistory();
-        return response.data.history;
-    }
-    async getWeeklySnapshots() {
-        const response = await this.apiClient.getWeeklySnapshots();
-        return response.data.snapshots;
-    }
-    async getPortfolioDeltas() {
-        const response = await this.apiClient.getPortfolioDeltas();
-        return response.data.deltas;
-    }
-    async getUserLogs(userId) {
-        const response = await this.apiClient.getUserLogs(userId);
-        return response.data.logs;
-    }
-}
-
-class CorePortalService {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.iframe = null;
-    }
-    async createPortal(config) {
-        // Create iframe
-        this.iframe = document.createElement('iframe');
-        this.iframe.style.display = 'none';
-        document.body.appendChild(this.iframe);
-        // Get portal content from API
-        const response = await this.apiClient.getPortalContent();
-        const content = response.data.content;
-        // Set iframe content
-        if (this.iframe.contentWindow) {
-            this.iframe.contentWindow.document.open();
-            this.iframe.contentWindow.document.write(content);
-            this.iframe.contentWindow.document.close();
-        }
-        // Position and style iframe
-        this.positionIframe(config);
-        this.styleIframe(config);
-        // Show iframe
-        this.iframe.style.display = 'block';
-    }
-    async closePortal() {
-        if (this.iframe) {
-            this.iframe.remove();
-            this.iframe = null;
-        }
-    }
-    async updateTheme(theme) {
-        if (this.iframe?.contentWindow) {
-            this.iframe.contentWindow.postMessage({ type: 'update_theme', theme }, '*');
-        }
-    }
-    async getBrokerAccounts() {
-        const response = await this.apiClient.getBrokerAccounts();
-        return response.data.accounts;
-    }
-    async linkBrokerAccount(brokerId) {
-        await this.apiClient.connectBroker(brokerId);
-    }
-    async unlinkBrokerAccount(brokerId) {
-        await this.apiClient.disconnectBroker(brokerId);
-    }
-    positionIframe(config) {
-        if (!this.iframe)
-            return;
-        const position = config.position || 'center';
-        const width = config.width || '600px';
-        const height = config.height || '800px';
-        this.iframe.style.width = width;
-        this.iframe.style.height = height;
-        switch (position) {
-            case 'center':
-                this.iframe.style.position = 'fixed';
-                this.iframe.style.top = '50%';
-                this.iframe.style.left = '50%';
-                this.iframe.style.transform = 'translate(-50%, -50%)';
-                break;
-            case 'top':
-                this.iframe.style.position = 'fixed';
-                this.iframe.style.top = '0';
-                this.iframe.style.left = '50%';
-                this.iframe.style.transform = 'translateX(-50%)';
-                break;
-            case 'bottom':
-                this.iframe.style.position = 'fixed';
-                this.iframe.style.bottom = '0';
-                this.iframe.style.left = '50%';
-                this.iframe.style.transform = 'translateX(-50%)';
-                break;
-            // Note: 'left' and 'right' positions removed from PortalConfig interface
-            // Default to center if invalid position is provided
-            default:
-                this.iframe.style.position = 'fixed';
-                this.iframe.style.top = '50%';
-                this.iframe.style.left = '50%';
-                this.iframe.style.transform = 'translate(-50%, -50%)';
-                break;
+    /**
+     * Disconnect a company from a broker connection
+     * @param connectionId - The connection ID to disconnect
+     * @returns Promise with disconnect response
+     * @throws AuthenticationError if user is not authenticated
+     */
+    async disconnectCompany(connectionId) {
+        if (!this.isAuthed()) {
+            throw new AuthenticationError('User is not authenticated. Please connect a broker first.');
         }
-    }
-    styleIframe(config) {
-        if (!this.iframe)
-            return;
-        // Apply z-index if specified
-        if (config.zIndex) {
-            this.iframe.style.zIndex = config.zIndex.toString();
+        if (!this.userToken?.user_id) {
+            throw new AuthenticationError('No user ID available. Please connect a broker first.');
         }
+        return this.apiClient.disconnectCompany(connectionId);
     }
 }
+FinaticConnect.instance = null;
 
 exports.ApiClient = ApiClient;
 exports.ApiError = ApiError;
@@ -4784,9 +4900,6 @@ exports.AuthenticationError = AuthenticationError;
 exports.AuthorizationError = AuthorizationError;
 exports.BaseError = BaseError;
 exports.CompanyAccessError = CompanyAccessError;
-exports.CoreAnalyticsService = CoreAnalyticsService;
-exports.CorePortalService = CorePortalService;
-exports.CoreTradingService = CoreTradingService;
 exports.EventEmitter = EventEmitter;
 exports.FinaticConnect = FinaticConnect;
 exports.MockFactory = MockFactory;