@fullstackcraftllc/floe 0.0.3 → 0.0.5

package/dist/client/brokers/SchwabClient.js

@@ -1,6 +1,1058 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchwabClient = void 0;
+const occ_1 = require("../../utils/occ");
+/**
+ * Schwab streaming field enums for LEVELONE_OPTIONS
+ */
+var LevelOneOptionFields;
+(function (LevelOneOptionFields) {
+    LevelOneOptionFields[LevelOneOptionFields["SYMBOL"] = 0] = "SYMBOL";
+    LevelOneOptionFields[LevelOneOptionFields["DESCRIPTION"] = 1] = "DESCRIPTION";
+    LevelOneOptionFields[LevelOneOptionFields["BID_PRICE"] = 2] = "BID_PRICE";
+    LevelOneOptionFields[LevelOneOptionFields["ASK_PRICE"] = 3] = "ASK_PRICE";
+    LevelOneOptionFields[LevelOneOptionFields["LAST_PRICE"] = 4] = "LAST_PRICE";
+    LevelOneOptionFields[LevelOneOptionFields["HIGH_PRICE"] = 5] = "HIGH_PRICE";
+    LevelOneOptionFields[LevelOneOptionFields["LOW_PRICE"] = 6] = "LOW_PRICE";
+    LevelOneOptionFields[LevelOneOptionFields["CLOSE_PRICE"] = 7] = "CLOSE_PRICE";
+    LevelOneOptionFields[LevelOneOptionFields["TOTAL_VOLUME"] = 8] = "TOTAL_VOLUME";
+    LevelOneOptionFields[LevelOneOptionFields["OPEN_INTEREST"] = 9] = "OPEN_INTEREST";
+    LevelOneOptionFields[LevelOneOptionFields["VOLATILITY"] = 10] = "VOLATILITY";
+    LevelOneOptionFields[LevelOneOptionFields["INTRINSIC_VALUE"] = 11] = "INTRINSIC_VALUE";
+    LevelOneOptionFields[LevelOneOptionFields["EXTRINSIC_VALUE"] = 12] = "EXTRINSIC_VALUE";
+    LevelOneOptionFields[LevelOneOptionFields["OPTION_ROOT"] = 13] = "OPTION_ROOT";
+    LevelOneOptionFields[LevelOneOptionFields["STRIKE_TYPE"] = 14] = "STRIKE_TYPE";
+    LevelOneOptionFields[LevelOneOptionFields["CONTRACT_TYPE"] = 15] = "CONTRACT_TYPE";
+    LevelOneOptionFields[LevelOneOptionFields["UNDERLYING"] = 16] = "UNDERLYING";
+    LevelOneOptionFields[LevelOneOptionFields["EXPIRATION_MONTH"] = 17] = "EXPIRATION_MONTH";
+    LevelOneOptionFields[LevelOneOptionFields["DELIVERABLES"] = 18] = "DELIVERABLES";
+    LevelOneOptionFields[LevelOneOptionFields["TIME_VALUE"] = 19] = "TIME_VALUE";
+    LevelOneOptionFields[LevelOneOptionFields["EXPIRATION_DAY"] = 20] = "EXPIRATION_DAY";
+    LevelOneOptionFields[LevelOneOptionFields["DAYS_TO_EXPIRATION"] = 21] = "DAYS_TO_EXPIRATION";
+    LevelOneOptionFields[LevelOneOptionFields["DELTA"] = 22] = "DELTA";
+    LevelOneOptionFields[LevelOneOptionFields["GAMMA"] = 23] = "GAMMA";
+    LevelOneOptionFields[LevelOneOptionFields["THETA"] = 24] = "THETA";
+    LevelOneOptionFields[LevelOneOptionFields["VEGA"] = 25] = "VEGA";
+    LevelOneOptionFields[LevelOneOptionFields["RHO"] = 26] = "RHO";
+    LevelOneOptionFields[LevelOneOptionFields["SECURITY_STATUS"] = 27] = "SECURITY_STATUS";
+    LevelOneOptionFields[LevelOneOptionFields["THEORETICAL_OPTION_VALUE"] = 28] = "THEORETICAL_OPTION_VALUE";
+    LevelOneOptionFields[LevelOneOptionFields["UNDERLYING_PRICE"] = 29] = "UNDERLYING_PRICE";
+    LevelOneOptionFields[LevelOneOptionFields["UV_EXPIRATION_TYPE"] = 30] = "UV_EXPIRATION_TYPE";
+    LevelOneOptionFields[LevelOneOptionFields["MARK"] = 31] = "MARK";
+    LevelOneOptionFields[LevelOneOptionFields["QUOTE_TIME_MILLIS"] = 32] = "QUOTE_TIME_MILLIS";
+    LevelOneOptionFields[LevelOneOptionFields["TRADE_TIME_MILLIS"] = 33] = "TRADE_TIME_MILLIS";
+    LevelOneOptionFields[LevelOneOptionFields["EXCHANGE_ID"] = 34] = "EXCHANGE_ID";
+    LevelOneOptionFields[LevelOneOptionFields["EXCHANGE_NAME"] = 35] = "EXCHANGE_NAME";
+    LevelOneOptionFields[LevelOneOptionFields["LAST_TRADING_DAY"] = 36] = "LAST_TRADING_DAY";
+    LevelOneOptionFields[LevelOneOptionFields["SETTLEMENT_TYPE"] = 37] = "SETTLEMENT_TYPE";
+    LevelOneOptionFields[LevelOneOptionFields["NET_CHANGE"] = 38] = "NET_CHANGE";
+    LevelOneOptionFields[LevelOneOptionFields["NET_PERCENT_CHANGE"] = 39] = "NET_PERCENT_CHANGE";
+    LevelOneOptionFields[LevelOneOptionFields["MARK_CHANGE"] = 40] = "MARK_CHANGE";
+    LevelOneOptionFields[LevelOneOptionFields["MARK_PERCENT_CHANGE"] = 41] = "MARK_PERCENT_CHANGE";
+    LevelOneOptionFields[LevelOneOptionFields["IMPLIED_YIELD"] = 42] = "IMPLIED_YIELD";
+    LevelOneOptionFields[LevelOneOptionFields["IS_PENNY_PILOT"] = 43] = "IS_PENNY_PILOT";
+    LevelOneOptionFields[LevelOneOptionFields["OPTION_TYPE"] = 44] = "OPTION_TYPE";
+    LevelOneOptionFields[LevelOneOptionFields["STRIKE_PRICE"] = 45] = "STRIKE_PRICE";
+    LevelOneOptionFields[LevelOneOptionFields["BID_SIZE"] = 46] = "BID_SIZE";
+    LevelOneOptionFields[LevelOneOptionFields["ASK_SIZE"] = 47] = "ASK_SIZE";
+    LevelOneOptionFields[LevelOneOptionFields["LAST_SIZE"] = 48] = "LAST_SIZE";
+    LevelOneOptionFields[LevelOneOptionFields["NET_CHANGE_DIR"] = 49] = "NET_CHANGE_DIR";
+    LevelOneOptionFields[LevelOneOptionFields["OPEN_PRICE"] = 50] = "OPEN_PRICE";
+    LevelOneOptionFields[LevelOneOptionFields["TICK"] = 51] = "TICK";
+    LevelOneOptionFields[LevelOneOptionFields["TICK_AMOUNT"] = 52] = "TICK_AMOUNT";
+    LevelOneOptionFields[LevelOneOptionFields["FUTURE_MULTIPLIER"] = 53] = "FUTURE_MULTIPLIER";
+    LevelOneOptionFields[LevelOneOptionFields["FUTURE_SETTLEMENT_PRICE"] = 54] = "FUTURE_SETTLEMENT_PRICE";
+    LevelOneOptionFields[LevelOneOptionFields["EXCHANGE_CHARACTER"] = 55] = "EXCHANGE_CHARACTER";
+})(LevelOneOptionFields || (LevelOneOptionFields = {}));
+/**
+ * Schwab streaming field enums for OPTIONS_BOOK
+ */
+var OptionsBookFields;
+(function (OptionsBookFields) {
+    OptionsBookFields[OptionsBookFields["SYMBOL"] = 0] = "SYMBOL";
+    OptionsBookFields[OptionsBookFields["BOOK_TIME"] = 1] = "BOOK_TIME";
+    OptionsBookFields[OptionsBookFields["BIDS"] = 2] = "BIDS";
+    OptionsBookFields[OptionsBookFields["ASKS"] = 3] = "ASKS";
+})(OptionsBookFields || (OptionsBookFields = {}));
+/**
+ * Regex pattern to identify OCC option symbols
+ * Schwab uses space-padded format: "AAPL  240517C00170000"
+ */
+const OCC_OPTION_PATTERN = /^.{1,6}\s*\d{6}[CP]\d{8}$/;
+/**
+ * SchwabClient handles real-time streaming connections to the Charles Schwab API
+ * via WebSockets.
+ *
+ * @remarks
+ * This client manages WebSocket connections to Schwab's streaming API,
+ * normalizes incoming quote and book data, and emits events for upstream
+ * consumption by the FloeClient.
+ *
+ * Authentication flow:
+ * 1. Use OAuth access token to call get_user_preferences endpoint
+ * 2. Extract streaming credentials (customerId, correlId, channel, functionId, socketUrl)
+ * 3. Connect to WebSocket and send ADMIN/LOGIN request with access token
+ * 4. Subscribe to LEVELONE_OPTIONS for quotes and OPTIONS_BOOK for order book
+ *
+ * @example
+ * ```typescript
+ * const client = new SchwabClient({
+ *   accessToken: 'your-oauth-access-token'
+ * });
+ *
+ * client.on('tickerUpdate', (ticker) => {
+ *   console.log(`${ticker.symbol}: ${ticker.spot}`);
+ * });
+ *
+ * await client.connect();
+ * client.subscribe(['SPY', 'SPY   240517C00500000']); // Equity and option
+ * ```
+ */
 class SchwabClient {
+    /**
+     * Creates a new SchwabClient instance.
+     *
+     * @param options - Client configuration options
+     * @param options.accessToken - Schwab OAuth access token (required)
+     * @param options.verbose - Whether to log verbose debug information (default: false)
+     */
+    constructor(options) {
+        /** WebSocket connection */
+        this.ws = null;
+        /** Connection state */
+        this.connected = false;
+        /** Logged in state */
+        this.loggedIn = false;
+        /** Streaming credentials */
+        this.streamCustomerId = null;
+        this.streamCorrelId = null;
+        this.streamChannel = null;
+        this.streamFunctionId = null;
+        this.streamSocketUrl = null;
+        /** Request ID counter */
+        this.requestId = 0;
+        /** Currently subscribed symbols */
+        this.subscribedSymbols = new Set();
+        /** Map from Schwab symbol to OCC symbol */
+        this.schwabToOccMap = new Map();
+        /** Map from OCC symbol to Schwab symbol */
+        this.occToSchwabMap = new Map();
+        /** Cached ticker data */
+        this.tickerCache = new Map();
+        /** Cached option data */
+        this.optionCache = new Map();
+        /** Base open interest from REST API */
+        this.baseOpenInterest = new Map();
+        /** Cumulative estimated OI change from intraday trades */
+        this.cumulativeOIChange = new Map();
+        /** History of intraday trades */
+        this.intradayTrades = new Map();
+        /** Event listeners */
+        this.eventListeners = new Map();
+        /** Reconnection attempt counter */
+        this.reconnectAttempts = 0;
+        /** Maximum reconnection attempts */
+        this.maxReconnectAttempts = 5;
+        /** Reconnection delay in ms */
+        this.baseReconnectDelay = 1000;
+        /** Keepalive interval handle */
+        this.keepaliveInterval = null;
+        /** Schwab API base URL */
+        this.apiBaseUrl = 'https://api.schwabapi.com';
+        this.accessToken = options.accessToken;
+        this.verbose = options.verbose ?? false;
+        // Initialize event listener maps
+        this.eventListeners.set('tickerUpdate', new Set());
+        this.eventListeners.set('optionUpdate', new Set());
+        this.eventListeners.set('optionTrade', new Set());
+        this.eventListeners.set('connected', new Set());
+        this.eventListeners.set('disconnected', new Set());
+        this.eventListeners.set('error', new Set());
+    }
+    // ==================== Public API ====================
+    /**
+     * Establishes a streaming connection to Schwab.
+     *
+     * @returns Promise that resolves when connected and logged in
+     * @throws {Error} If credentials retrieval or WebSocket connection fails
+     */
+    async connect() {
+        // Get streaming credentials from user preferences
+        const preferences = await this.getUserPreferences();
+        if (!preferences || !preferences.streamerInfo?.[0]) {
+            throw new Error('Failed to get Schwab streaming credentials');
+        }
+        const streamInfo = preferences.streamerInfo[0];
+        this.streamCustomerId = streamInfo.schwabClientCustomerId;
+        this.streamCorrelId = streamInfo.schwabClientCorrelId;
+        this.streamChannel = streamInfo.schwabClientChannel;
+        this.streamFunctionId = streamInfo.schwabClientFunctionId;
+        this.streamSocketUrl = streamInfo.streamerSocketUrl;
+        // Connect to WebSocket
+        await this.connectWebSocket();
+    }
+    /**
+     * Disconnects from the Schwab streaming API.
+     */
+    disconnect() {
+        if (this.keepaliveInterval) {
+            clearInterval(this.keepaliveInterval);
+            this.keepaliveInterval = null;
+        }
+        if (this.ws && this.loggedIn) {
+            // Send logout request
+            this.sendLogout();
+        }
+        if (this.ws) {
+            this.ws.close(1000, 'Client disconnect');
+            this.ws = null;
+        }
+        this.connected = false;
+        this.loggedIn = false;
+        this.subscribedSymbols.clear();
+        this.schwabToOccMap.clear();
+        this.occToSchwabMap.clear();
+    }
+    /**
+     * Subscribes to real-time updates for the specified symbols.
+     *
+     * @param symbols - Array of ticker symbols and/or OCC option symbols
+     *
+     * @remarks
+     * For options, you can pass OCC format symbols (e.g., 'SPY240119C00500000')
+     * or Schwab format with spaces (e.g., 'SPY   240119C00500000').
+     * The client will handle conversion automatically.
+     */
+    subscribe(symbols) {
+        // Add to tracked symbols
+        symbols.forEach(s => this.subscribedSymbols.add(s));
+        if (!this.connected || !this.loggedIn) {
+            // Will subscribe when logged in
+            return;
+        }
+        const tickers = [];
+        const options = [];
+        for (const symbol of symbols) {
+            if (this.isOptionSymbol(symbol)) {
+                options.push(this.toSchwabOptionSymbol(symbol));
+            }
+            else {
+                tickers.push(symbol);
+            }
+        }
+        if (tickers.length > 0) {
+            this.subscribeLevelOneEquity(tickers);
+        }
+        if (options.length > 0) {
+            this.subscribeLevelOneOptions(options);
+            this.subscribeOptionsBook(options);
+        }
+    }
+    /**
+     * Unsubscribes from real-time updates for the specified symbols.
+     *
+     * @param symbols - Array of symbols to unsubscribe from
+     */
+    unsubscribe(symbols) {
+        symbols.forEach(s => this.subscribedSymbols.delete(s));
+        if (!this.connected || !this.loggedIn) {
+            return;
+        }
+        const tickers = [];
+        const options = [];
+        for (const symbol of symbols) {
+            if (this.isOptionSymbol(symbol)) {
+                options.push(this.toSchwabOptionSymbol(symbol));
+            }
+            else {
+                tickers.push(symbol);
+            }
+        }
+        if (tickers.length > 0) {
+            this.unsubscribeLevelOneEquity(tickers);
+        }
+        if (options.length > 0) {
+            this.unsubscribeLevelOneOptions(options);
+            this.unsubscribeOptionsBook(options);
+        }
+    }
+    /**
+     * Returns whether the client is currently connected.
+     */
+    isConnected() {
+        return this.connected && this.loggedIn;
+    }
+    /**
+     * Fetches option chain from Schwab REST API.
+     * This provides the base open interest data.
+     *
+     * @param symbol - Underlying symbol (e.g., 'SPY')
+     * @param options - Optional parameters for filtering the chain
+     * @returns Promise resolving to the option chain response
+     */
+    async fetchOptionChain(symbol, options) {
+        try {
+            const params = new URLSearchParams({ symbol });
+            if (options?.contractType) {
+                params.append('contractType', options.contractType);
+            }
+            if (options?.strikeCount) {
+                params.append('strikeCount', options.strikeCount.toString());
+            }
+            if (options?.includeUnderlyingQuote) {
+                params.append('includeUnderlyingQuote', 'true');
+            }
+            if (options?.fromDate) {
+                params.append('fromDate', options.fromDate);
+            }
+            if (options?.toDate) {
+                params.append('toDate', options.toDate);
+            }
+            const response = await fetch(`${this.apiBaseUrl}/marketdata/v1/chains?${params.toString()}`, {
+                method: 'GET',
+                headers: this.getAuthHeaders(),
+            });
+            if (!response.ok) {
+                this.emit('error', new Error(`Failed to fetch option chain: ${response.statusText}`));
+                return null;
+            }
+            return await response.json();
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            return null;
+        }
+    }
+    /**
+     * Fetches open interest and other static data for subscribed options.
+     *
+     * @param occSymbols - Array of OCC option symbols to fetch data for
+     */
+    async fetchOpenInterest(occSymbols) {
+        // Group by underlying
+        const groups = new Map();
+        for (const occSymbol of occSymbols) {
+            try {
+                const parsed = (0, occ_1.parseOCCSymbol)(this.normalizeOccSymbol(occSymbol));
+                if (!groups.has(parsed.symbol)) {
+                    groups.set(parsed.symbol, new Set());
+                }
+                groups.get(parsed.symbol).add(this.normalizeOccSymbol(occSymbol));
+            }
+            catch {
+                continue;
+            }
+        }
+        // Fetch chains for each underlying
+        const fetchPromises = Array.from(groups.entries()).map(async ([underlying, targetSymbols]) => {
+            const chain = await this.fetchOptionChain(underlying, {
+                contractType: 'ALL',
+                includeUnderlyingQuote: true,
+            });
+            if (!chain)
+                return;
+            // Process calls
+            for (const [_expDate, strikes] of Object.entries(chain.callExpDateMap || {})) {
+                for (const [_strike, contracts] of Object.entries(strikes)) {
+                    for (const contract of contracts) {
+                        this.processChainContract(contract, targetSymbols);
+                    }
+                }
+            }
+            // Process puts
+            for (const [_expDate, strikes] of Object.entries(chain.putExpDateMap || {})) {
+                for (const [_strike, contracts] of Object.entries(strikes)) {
+                    for (const contract of contracts) {
+                        this.processChainContract(contract, targetSymbols);
+                    }
+                }
+            }
+        });
+        await Promise.all(fetchPromises);
+    }
+    /**
+     * Returns cached option data for a symbol.
+     */
+    getOption(occSymbol) {
+        return this.optionCache.get(this.normalizeOccSymbol(occSymbol));
+    }
+    /**
+     * Returns all cached options.
+     */
+    getAllOptions() {
+        return new Map(this.optionCache);
+    }
+    /**
+     * Registers an event listener.
+     */
+    on(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.add(listener);
+        }
+        return this;
+    }
+    /**
+     * Removes an event listener.
+     */
+    off(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.delete(listener);
+        }
+        return this;
+    }
+    /**
+     * Returns intraday trades for an option.
+     */
+    getIntradayTrades(occSymbol) {
+        return this.intradayTrades.get(this.normalizeOccSymbol(occSymbol)) ?? [];
+    }
+    /**
+     * Returns flow summary for an option.
+     */
+    getFlowSummary(occSymbol) {
+        const normalizedSymbol = this.normalizeOccSymbol(occSymbol);
+        const trades = this.intradayTrades.get(normalizedSymbol) ?? [];
+        let buyVolume = 0;
+        let sellVolume = 0;
+        let unknownVolume = 0;
+        for (const trade of trades) {
+            switch (trade.aggressorSide) {
+                case 'buy':
+                    buyVolume += trade.size;
+                    break;
+                case 'sell':
+                    sellVolume += trade.size;
+                    break;
+                case 'unknown':
+                    unknownVolume += trade.size;
+                    break;
+            }
+        }
+        return {
+            buyVolume,
+            sellVolume,
+            unknownVolume,
+            netOIChange: this.cumulativeOIChange.get(normalizedSymbol) ?? 0,
+            tradeCount: trades.length,
+        };
+    }
+    /**
+     * Resets intraday tracking data.
+     */
+    resetIntradayData(occSymbols) {
+        const symbolsToReset = occSymbols?.map(s => this.normalizeOccSymbol(s))
+            ?? Array.from(this.intradayTrades.keys());
+        for (const symbol of symbolsToReset) {
+            this.intradayTrades.delete(symbol);
+            this.cumulativeOIChange.set(symbol, 0);
+        }
+    }
+    // ==================== Private Methods ====================
+    /**
+     * Gets user preferences containing streaming info from Schwab.
+     */
+    async getUserPreferences() {
+        try {
+            const response = await fetch(`${this.apiBaseUrl}/trader/v1/userPreference`, {
+                method: 'GET',
+                headers: this.getAuthHeaders(),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.emit('error', new Error(`Failed to get user preferences: ${response.statusText} - ${errorText}`));
+                return null;
+            }
+            return await response.json();
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            return null;
+        }
+    }
+    /**
+     * Returns authorization headers for API calls.
+     */
+    getAuthHeaders() {
+        return {
+            'Authorization': `Bearer ${this.accessToken}`,
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        };
+    }
+    /**
+     * Connects to Schwab WebSocket.
+     */
+    connectWebSocket() {
+        return new Promise((resolve, reject) => {
+            if (!this.streamSocketUrl) {
+                reject(new Error('Stream socket URL not available'));
+                return;
+            }
+            this.ws = new WebSocket(this.streamSocketUrl);
+            this.ws.onopen = () => {
+                this.connected = true;
+                this.reconnectAttempts = 0;
+                // Send login request
+                this.sendLogin();
+            };
+            this.ws.onmessage = (event) => {
+                this.handleMessage(event.data, resolve);
+            };
+            this.ws.onclose = (event) => {
+                this.connected = false;
+                this.loggedIn = false;
+                this.emit('disconnected', { reason: event.reason });
+                if (event.code !== 1000) {
+                    this.attemptReconnect();
+                }
+            };
+            this.ws.onerror = () => {
+                this.emit('error', new Error('Schwab WebSocket error'));
+                reject(new Error('WebSocket connection failed'));
+            };
+        });
+    }
+    /**
+     * Sends login request to Schwab streaming.
+     */
+    sendLogin() {
+        const request = this.makeRequest('ADMIN', 'LOGIN', {
+            'Authorization': this.accessToken,
+            'SchwabClientChannel': this.streamChannel,
+            'SchwabClientFunctionId': this.streamFunctionId,
+        });
+        this.sendMessage({ requests: [request] });
+    }
+    /**
+     * Sends logout request to Schwab streaming.
+     */
+    sendLogout() {
+        const request = this.makeRequest('ADMIN', 'LOGOUT', {});
+        this.sendMessage({ requests: [request] });
+    }
+    /**
+     * Subscribes to LEVELONE_EQUITIES service.
+     */
+    subscribeLevelOneEquity(symbols) {
+        const fields = '0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,' +
+            '20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49';
+        const request = this.makeRequest('LEVELONE_EQUITIES', 'SUBS', {
+            keys: symbols.join(','),
+            fields,
+        });
+        this.sendMessage({ requests: [request] });
+    }
+    /**
+     * Unsubscribes from LEVELONE_EQUITIES service.
+     */
+    unsubscribeLevelOneEquity(symbols) {
+        const request = this.makeRequest('LEVELONE_EQUITIES', 'UNSUBS', {
+            keys: symbols.join(','),
+        });
+        this.sendMessage({ requests: [request] });
+    }
+    /**
+     * Subscribes to LEVELONE_OPTIONS service for level 1 option quotes.
+     */
+    subscribeLevelOneOptions(schwabSymbols) {
+        // Request all available fields (0-55)
+        const fields = Array.from({ length: 56 }, (_, i) => i).join(',');
+        const request = this.makeRequest('LEVELONE_OPTIONS', 'SUBS', {
+            keys: schwabSymbols.join(','),
+            fields,
+        });
+        this.sendMessage({ requests: [request] });
+    }
+    /**
+     * Unsubscribes from LEVELONE_OPTIONS service.
+     */
+    unsubscribeLevelOneOptions(schwabSymbols) {
+        const request = this.makeRequest('LEVELONE_OPTIONS', 'UNSUBS', {
+            keys: schwabSymbols.join(','),
+        });
+        this.sendMessage({ requests: [request] });
+    }
+    /**
+     * Subscribes to OPTIONS_BOOK service for level 2 order book.
+     * This provides "live" open interest intraday.
+     */
+    subscribeOptionsBook(schwabSymbols) {
+        const request = this.makeRequest('OPTIONS_BOOK', 'SUBS', {
+            keys: schwabSymbols.join(','),
+            fields: '0,1,2,3',
+        });
+        this.sendMessage({ requests: [request] });
+    }
+    /**
+     * Unsubscribes from OPTIONS_BOOK service.
+     */
+    unsubscribeOptionsBook(schwabSymbols) {
+        const request = this.makeRequest('OPTIONS_BOOK', 'UNSUBS', {
+            keys: schwabSymbols.join(','),
+        });
+        this.sendMessage({ requests: [request] });
+    }
+    /**
+     * Makes a streaming request object.
+     */
+    makeRequest(service, command, parameters) {
+        const requestId = this.requestId++;
+        return {
+            service,
+            requestid: requestId.toString(),
+            command,
+            SchwabClientCustomerId: this.streamCustomerId || '',
+            SchwabClientCorrelId: this.streamCorrelId || '',
+            parameters,
+        };
+    }
+    /**
+     * Handles incoming WebSocket messages.
+     */
+    handleMessage(data, connectResolve) {
+        try {
+            const message = JSON.parse(data);
+            // Handle response messages (to commands)
+            if (message.response) {
+                for (const response of message.response) {
+                    this.handleResponse(response, connectResolve);
+                }
+            }
+            // Handle data messages (streaming data)
+            if (message.data) {
+                for (const dataItem of message.data) {
+                    this.handleDataMessage(dataItem);
+                }
+            }
+            // Handle heartbeat/notify messages
+            if (message.notify) {
+                // Heartbeat received, connection is alive
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    /**
+     * Handles a response message (command acknowledgment).
+     */
+    handleResponse(response, connectResolve) {
+        if (response.service === 'ADMIN' && response.command === 'LOGIN') {
+            if (response.content.code === 0) {
+                this.loggedIn = true;
+                this.startKeepalive();
+                if (this.verbose) {
+                    console.log('[Schwab:WS] Logged in and connected to streaming API');
+                }
+                this.emit('connected', undefined);
+                connectResolve?.();
+                // Subscribe to queued symbols
+                if (this.subscribedSymbols.size > 0) {
+                    this.subscribe(Array.from(this.subscribedSymbols));
+                }
+            }
+            else {
+                this.emit('error', new Error(`Schwab login failed: ${response.content.msg}`));
+            }
+        }
+        else if (response.content.code !== 0) {
+            this.emit('error', new Error(`Schwab ${response.service}/${response.command} failed: ${response.content.msg}`));
+        }
+    }
+    /**
+     * Handles streaming data messages.
+     */
+    handleDataMessage(dataItem) {
+        const { service, content, timestamp } = dataItem;
+        for (const item of content) {
+            switch (service) {
+                case 'LEVELONE_EQUITIES':
+                    this.handleLevelOneEquity(item, timestamp);
+                    break;
+                case 'LEVELONE_OPTIONS':
+                    this.handleLevelOneOption(item, timestamp);
+                    break;
+                case 'OPTIONS_BOOK':
+                    this.handleOptionsBook(item, timestamp);
+                    break;
+            }
+        }
+    }
+    /**
+     * Handles LEVELONE_EQUITIES data.
+     */
+    handleLevelOneEquity(data, timestamp) {
+        const symbol = data.key;
+        if (!symbol)
+            return;
+        const existing = this.tickerCache.get(symbol);
+        const ticker = {
+            symbol,
+            spot: this.toNumber(data['3']) || this.toNumber(data['2']) || existing?.spot || 0, // Last or Bid
+            bid: this.toNumber(data['2']) || existing?.bid || 0,
+            bidSize: this.toNumber(data['46']) || existing?.bidSize || 0,
+            ask: this.toNumber(data['4']) || existing?.ask || 0,
+            askSize: this.toNumber(data['47']) || existing?.askSize || 0,
+            last: this.toNumber(data['3']) || existing?.last || 0,
+            volume: this.toNumber(data['8']) || existing?.volume || 0,
+            timestamp,
+        };
+        this.tickerCache.set(symbol, ticker);
+        this.emit('tickerUpdate', ticker);
+    }
+    /**
+     * Handles LEVELONE_OPTIONS data.
+     */
+    handleLevelOneOption(data, timestamp) {
+        const schwabSymbol = data.key;
+        if (!schwabSymbol)
+            return;
+        const occSymbol = this.schwabToOcc(schwabSymbol);
+        const existing = this.optionCache.get(occSymbol);
+        // Parse symbol for underlying info if not cached
+        let parsed;
+        try {
+            parsed = (0, occ_1.parseOCCSymbol)(occSymbol);
+        }
+        catch {
+            if (!existing)
+                return;
+            parsed = {
+                symbol: existing.underlying,
+                expiration: new Date(existing.expirationTimestamp),
+                optionType: existing.optionType,
+                strike: existing.strike,
+            };
+        }
+        const bidPrice = this.toNumber(data[LevelOneOptionFields.BID_PRICE.toString()]) || existing?.bid || 0;
+        const askPrice = this.toNumber(data[LevelOneOptionFields.ASK_PRICE.toString()]) || existing?.ask || 0;
+        const lastPrice = this.toNumber(data[LevelOneOptionFields.LAST_PRICE.toString()]) || existing?.last || 0;
+        const volume = this.toNumber(data[LevelOneOptionFields.TOTAL_VOLUME.toString()]) || existing?.volume || 0;
+        const openInterest = this.toNumber(data[LevelOneOptionFields.OPEN_INTEREST.toString()]) || existing?.openInterest || 0;
+        const volatility = this.toNumber(data[LevelOneOptionFields.VOLATILITY.toString()]) || existing?.impliedVolatility || 0;
+        const mark = this.toNumber(data[LevelOneOptionFields.MARK.toString()]) ||
+            (bidPrice > 0 && askPrice > 0 ? (bidPrice + askPrice) / 2 : existing?.mark || 0);
+        // Update base OI if not set
+        if (openInterest > 0 && !this.baseOpenInterest.has(occSymbol)) {
+            this.baseOpenInterest.set(occSymbol, openInterest);
+            this.cumulativeOIChange.set(occSymbol, 0);
+            if (this.verbose) {
+                console.log(`[Schwab:OI] Base OI set from stream for ${occSymbol}: ${openInterest}`);
+            }
+        }
+        // Detect trade by comparing last price and volume changes
+        if (existing && lastPrice > 0 && lastPrice !== existing.last) {
+            const volumeChange = volume - (existing.volume || 0);
+            if (volumeChange > 0) {
+                this.recordTrade(occSymbol, lastPrice, volumeChange, existing.bid, existing.ask, timestamp);
+            }
+        }
+        const option = {
+            occSymbol,
+            underlying: parsed.symbol,
+            strike: this.toNumber(data[LevelOneOptionFields.STRIKE_PRICE.toString()]) || parsed.strike,
+            expiration: parsed.expiration.toISOString().split('T')[0],
+            expirationTimestamp: parsed.expiration.getTime(),
+            optionType: parsed.optionType,
+            bid: bidPrice,
+            bidSize: this.toNumber(data[LevelOneOptionFields.BID_SIZE.toString()]) || existing?.bidSize || 0,
+            ask: askPrice,
+            askSize: this.toNumber(data[LevelOneOptionFields.ASK_SIZE.toString()]) || existing?.askSize || 0,
+            mark,
+            last: lastPrice,
+            volume,
+            openInterest,
+            liveOpenInterest: this.calculateLiveOpenInterest(occSymbol),
+            impliedVolatility: volatility,
+            timestamp,
+        };
+        this.optionCache.set(occSymbol, option);
+        this.emit('optionUpdate', option);
+    }
+    /**
+     * Handles OPTIONS_BOOK data (level 2 order book).
+     * This provides depth of market which can indicate intraday activity.
+     */
+    handleOptionsBook(data, _timestamp) {
+        const schwabSymbol = data.key;
+        if (!schwabSymbol)
+            return;
+        // OPTIONS_BOOK provides bid/ask book depth
+        // We can use changes in the book to infer trade activity
+        // For now, we'll update the best bid/ask from the book
+        const occSymbol = this.schwabToOcc(schwabSymbol);
+        const existing = this.optionCache.get(occSymbol);
+        if (!existing)
+            return;
+        const bids = data[OptionsBookFields.BIDS.toString()];
+        const asks = data[OptionsBookFields.ASKS.toString()];
+        if (bids && bids.length > 0) {
+            const bestBid = bids[0];
+            existing.bid = bestBid['0'] || existing.bid;
+            existing.bidSize = bestBid['1'] || existing.bidSize;
+        }
+        if (asks && asks.length > 0) {
+            const bestAsk = asks[0];
+            existing.ask = bestAsk['0'] || existing.ask;
+            existing.askSize = bestAsk['1'] || existing.askSize;
+        }
+        existing.mark = (existing.bid + existing.ask) / 2;
+        existing.timestamp = Date.now();
+        this.optionCache.set(occSymbol, existing);
+        this.emit('optionUpdate', existing);
+    }
+    /**
+     * Records a trade and updates OI tracking.
+     */
+    recordTrade(occSymbol, price, size, bid, ask, timestamp) {
+        const aggressorSide = this.determineAggressorSide(price, bid, ask);
+        // Get option type for OI calculation
+        let optionType = 'call';
+        try {
+            const parsed = (0, occ_1.parseOCCSymbol)(occSymbol);
+            optionType = parsed.optionType;
+        }
+        catch {
+            const existing = this.optionCache.get(occSymbol);
+            if (existing)
+                optionType = existing.optionType;
+        }
+        const estimatedOIChange = this.calculateOIChangeFromTrade(aggressorSide, size, optionType);
+        const currentChange = this.cumulativeOIChange.get(occSymbol) ?? 0;
+        this.cumulativeOIChange.set(occSymbol, currentChange + estimatedOIChange);
+        if (this.verbose && estimatedOIChange !== 0) {
+            const baseOI = this.baseOpenInterest.get(occSymbol) ?? 0;
+            const newLiveOI = Math.max(0, baseOI + currentChange + estimatedOIChange);
+            console.log(`[Schwab:OI] ${occSymbol} trade: price=${price.toFixed(2)}, size=${size}, aggressor=${aggressorSide}, OI change=${estimatedOIChange > 0 ? '+' : ''}${estimatedOIChange}, liveOI=${newLiveOI} (base=${baseOI}, cumulative=${currentChange + estimatedOIChange})`);
+        }
+        const trade = {
+            occSymbol,
+            price,
+            size,
+            bid,
+            ask,
+            aggressorSide,
+            timestamp,
+            estimatedOIChange,
+        };
+        if (!this.intradayTrades.has(occSymbol)) {
+            this.intradayTrades.set(occSymbol, []);
+        }
+        this.intradayTrades.get(occSymbol).push(trade);
+        this.emit('optionTrade', trade);
+    }
+    /**
+     * Processes a contract from the option chain response.
+     */
+    processChainContract(contract, targetSymbols) {
+        const occSymbol = this.schwabToOcc(contract.symbol);
+        if (!targetSymbols.has(occSymbol))
+            return;
+        // Store mapping
+        this.schwabToOccMap.set(contract.symbol, occSymbol);
+        this.occToSchwabMap.set(occSymbol, contract.symbol);
+        // Store base OI
+        if (contract.openInterest > 0) {
+            this.baseOpenInterest.set(occSymbol, contract.openInterest);
+            if (this.verbose) {
+                console.log(`[Schwab:OI] Base OI set from chain for ${occSymbol}: ${contract.openInterest}`);
+            }
+        }
+        if (!this.cumulativeOIChange.has(occSymbol)) {
+            this.cumulativeOIChange.set(occSymbol, 0);
+        }
+        // Create option in cache
+        const option = {
+            occSymbol,
+            underlying: contract.optionRoot,
+            strike: contract.strikePrice,
+            expiration: contract.expirationDate.split('T')[0],
+            expirationTimestamp: new Date(contract.expirationDate).getTime(),
+            optionType: contract.putCall === 'CALL' ? 'call' : 'put',
+            bid: contract.bid,
+            bidSize: contract.bidSize,
+            ask: contract.ask,
+            askSize: contract.askSize,
+            mark: contract.mark,
+            last: contract.last,
+            volume: contract.totalVolume,
+            openInterest: contract.openInterest,
+            liveOpenInterest: this.calculateLiveOpenInterest(occSymbol),
+            impliedVolatility: contract.volatility,
+            timestamp: Date.now(),
+        };
+        this.optionCache.set(occSymbol, option);
+        this.emit('optionUpdate', option);
+    }
+    /**
+     * Starts keepalive interval.
+     */
+    startKeepalive() {
+        if (this.keepaliveInterval) {
+            clearInterval(this.keepaliveInterval);
+        }
+        // Schwab streaming uses implicit keepalive via activity
+        // Send a QOS request periodically to keep connection alive
+        this.keepaliveInterval = setInterval(() => {
+            if (this.connected && this.loggedIn && this.ws) {
+                // QOS request to keep connection alive
+                const request = this.makeRequest('ADMIN', 'QOS', {
+                    qoslevel: '0', // Express (fastest)
+                });
+                this.sendMessage({ requests: [request] });
+            }
+        }, 60000); // Every 60 seconds
+    }
+    /**
+     * Determines aggressor side from trade price vs NBBO.
+     */
+    determineAggressorSide(tradePrice, bid, ask) {
+        if (bid <= 0 || ask <= 0)
+            return 'unknown';
+        const spread = ask - bid;
+        const tolerance = spread > 0 ? spread * 0.001 : 0.001;
+        if (tradePrice >= ask - tolerance) {
+            return 'buy';
+        }
+        else if (tradePrice <= bid + tolerance) {
+            return 'sell';
+        }
+        return 'unknown';
+    }
+    /**
+     * Calculates estimated OI change from trade.
+     */
+    calculateOIChangeFromTrade(aggressorSide, size, _optionType) {
+        if (aggressorSide === 'unknown')
+            return 0;
+        return aggressorSide === 'buy' ? size : -size;
+    }
+    /**
+     * Calculates live open interest.
+     */
+    calculateLiveOpenInterest(occSymbol) {
+        const baseOI = this.baseOpenInterest.get(occSymbol) ?? 0;
+        const cumulativeChange = this.cumulativeOIChange.get(occSymbol) ?? 0;
+        return Math.max(0, baseOI + cumulativeChange);
+    }
+    /**
+     * Converts Schwab option symbol to OCC format.
+     * Schwab format: "AAPL  240517C00170000" (6-char padded underlying)
+     */
+    schwabToOcc(schwabSymbol) {
+        // Check cache
+        const cached = this.schwabToOccMap.get(schwabSymbol);
+        if (cached)
+            return cached;
+        // Schwab symbols are already close to OCC format
+        // Just normalize by removing extra spaces and ensuring proper padding
+        return this.normalizeOccSymbol(schwabSymbol);
+    }
+    /**
+     * Normalizes an OCC symbol to consistent format.
+     * Removes extra spaces, ensures proper formatting.
+     */
+    normalizeOccSymbol(symbol) {
+        // Remove all spaces and reformat
+        const stripped = symbol.replace(/\s+/g, '');
+        // Match the parts: ROOT + YYMMDD + C/P + 8-digit strike
+        const match = stripped.match(/^([A-Z]+)(\d{6})([CP])(\d{8})$/);
+        if (match) {
+            return `${match[1]}${match[2]}${match[3]}${match[4]}`;
+        }
+        return stripped;
+    }
+    /**
+     * Converts OCC symbol to Schwab format (space-padded).
+     */
+    toSchwabOptionSymbol(occSymbol) {
+        // Check cache
+        const cached = this.occToSchwabMap.get(occSymbol);
+        if (cached)
+            return cached;
+        const normalized = this.normalizeOccSymbol(occSymbol);
+        // Parse and rebuild with space padding
+        const match = normalized.match(/^([A-Z]+)(\d{6})([CP])(\d{8})$/);
+        if (match) {
+            const [, root, date, type, strike] = match;
+            // Schwab uses 6-character padded root
+            const paddedRoot = root.padEnd(6, ' ');
+            return `${paddedRoot}${date}${type}${strike}`;
+        }
+        return occSymbol;
+    }
+    /**
+     * Checks if symbol is an option symbol.
+     */
+    isOptionSymbol(symbol) {
+        return OCC_OPTION_PATTERN.test(symbol) || /\d{6}[CP]\d{8}/.test(symbol.replace(/\s+/g, ''));
+    }
+    /**
+     * Attempts to reconnect with exponential backoff.
+     */
+    async attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.emit('error', new Error('Max reconnection attempts reached'));
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        if (this.verbose) {
+            console.log(`[Schwab:WS] Reconnection attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts} in ${delay}ms`);
+        }
+        await this.sleep(delay);
+        try {
+            await this.connect();
+        }
+        catch {
+            // Will try again via onclose
+        }
+    }
+    /**
+     * Sends a message to the WebSocket.
+     */
+    sendMessage(message) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Emits an event to all listeners.
+     */
+    emit(event, data) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.forEach(listener => {
+                try {
+                    listener(data);
+                }
+                catch (error) {
+                    console.error('Event listener error:', error);
+                }
+            });
+        }
+    }
+    /**
+     * Converts value to number, handling NaN and null.
+     */
+    toNumber(value) {
+        if (value === null || value === undefined)
+            return 0;
+        if (typeof value === 'number')
+            return isNaN(value) ? 0 : value;
+        if (typeof value === 'string') {
+            const num = parseFloat(value);
+            return isNaN(num) ? 0 : num;
+        }
+        return 0;
+    }
+    /**
+     * Sleep utility.
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
 }
 exports.SchwabClient = SchwabClient;