@discomedia/utils 1.0.55 → 1.0.57

package/dist/test.js

@@ -11,7 +11,6 @@ import require$$0$1 from 'buffer';
 import require$$0$4 from 'fs';
 import require$$1$1 from 'path';
 import require$$2$1 from 'os';
-import { log as log$2 } from 'console';
 
 /**
  * Logs a message to the console.
@@ -366,6 +365,21 @@ function getLastFullTradingDateImpl(currentDate = new Date()) {
 function getLastFullTradingDate(currentDate = new Date()) {
     return getLastFullTradingDateImpl(currentDate);
 }
+/**
+ * Returns the trading date for a given time. Note: Just trims the date string; does not validate if the date is a market day.
+ * @param time - a string, number (unix timestamp), or Date object representing the time
+ * @returns the trading date as a string in YYYY-MM-DD format
+ */
+/**
+ * Returns the trading date for a given time in YYYY-MM-DD format (NY time).
+ * @param time - string, number, or Date
+ * @returns trading date string
+ */
+function getTradingDate(time) {
+    const date = typeof time === 'number' ? new Date(time) : typeof time === 'string' ? new Date(time) : time;
+    const nyDate = toNYTime(date);
+    return `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
+}
 
 /*
 How it works:
@@ -453,8 +467,18 @@ class Queue {
 }
 
 function pLimit(concurrency) {
+	let rejectOnClear = false;
+
+	if (typeof concurrency === 'object') {
+		({concurrency, rejectOnClear = false} = concurrency);
+	}
+
 	validateConcurrency(concurrency);
 
+	if (typeof rejectOnClear !== 'boolean') {
+		throw new TypeError('Expected `rejectOnClear` to be a boolean');
+	}
+
 	const queue = new Queue();
 	let activeCount = 0;
 
@@ -462,7 +486,7 @@ function pLimit(concurrency) {
 		// Process the next queued function if we're under the concurrency limit
 		if (activeCount < concurrency && queue.size > 0) {
 			activeCount++;
-			queue.dequeue()();
+			queue.dequeue().run();
 		}
 	};
 
@@ -489,11 +513,14 @@ function pLimit(concurrency) {
 		next();
 	};
 
-	const enqueue = (function_, resolve, arguments_) => {
+	const enqueue = (function_, resolve, reject, arguments_) => {
+		const queueItem = {reject};
+
 		// Queue the internal resolve function instead of the run function
 		// to preserve the asynchronous execution context.
 		new Promise(internalResolve => { // eslint-disable-line promise/param-names
-			queue.enqueue(internalResolve);
+			queueItem.run = internalResolve;
+			queue.enqueue(queueItem);
 		}).then(run.bind(undefined, function_, resolve, arguments_)); // eslint-disable-line promise/prefer-await-to-then
 
 		// Start processing immediately if we haven't reached the concurrency limit
@@ -502,8 +529,8 @@ function pLimit(concurrency) {
 		}
 	};
 
-	const generator = (function_, ...arguments_) => new Promise(resolve => {
-		enqueue(function_, resolve, arguments_);
+	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+		enqueue(function_, resolve, reject, arguments_);
 	});
 
 	Object.defineProperties(generator, {
@@ -515,7 +542,16 @@ function pLimit(concurrency) {
 		},
 		clearQueue: {
 			value() {
-				queue.clear();
+				if (!rejectOnClear) {
+					queue.clear();
+					return;
+				}
+
+				const abortError = AbortSignal.abort().reason;
+
+				while (queue.size > 0) {
+					queue.dequeue().reject(abortError);
+				}
 			},
 		},
 		concurrency: {
@@ -801,7 +837,7 @@ const safeJSON = (text) => {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const VERSION = '6.16.0'; // x-release-please-version
+const VERSION = '6.17.0'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -4094,12 +4130,7 @@ class Assistants extends APIResource {
     /**
      * Create an assistant with a model and instructions.
      *
-     * @example
-     * ```ts
-     * const assistant = await client.beta.assistants.create({
-     *   model: 'gpt-4o',
-     * });
-     * ```
+     * @deprecated
      */
     create(body, options) {
         return this._client.post('/assistants', {
@@ -4111,12 +4142,7 @@ class Assistants extends APIResource {
     /**
      * Retrieves an assistant.
      *
-     * @example
-     * ```ts
-     * const assistant = await client.beta.assistants.retrieve(
-     *   'assistant_id',
-     * );
-     * ```
+     * @deprecated
      */
     retrieve(assistantID, options) {
         return this._client.get(path `/assistants/${assistantID}`, {
@@ -4127,12 +4153,7 @@ class Assistants extends APIResource {
     /**
      * Modifies an assistant.
      *
-     * @example
-     * ```ts
-     * const assistant = await client.beta.assistants.update(
-     *   'assistant_id',
-     * );
-     * ```
+     * @deprecated
      */
     update(assistantID, body, options) {
         return this._client.post(path `/assistants/${assistantID}`, {
@@ -4144,13 +4165,7 @@ class Assistants extends APIResource {
     /**
      * Returns a list of assistants.
      *
-     * @example
-     * ```ts
-     * // Automatically fetches more pages as needed.
-     * for await (const assistant of client.beta.assistants.list()) {
-     *   // ...
-     * }
-     * ```
+     * @deprecated
      */
     list(query = {}, options) {
         return this._client.getAPIList('/assistants', (CursorPage), {
@@ -4162,11 +4177,7 @@ class Assistants extends APIResource {
     /**
      * Delete an assistant.
      *
-     * @example
-     * ```ts
-     * const assistantDeleted =
-     *   await client.beta.assistants.delete('assistant_id');
-     * ```
+     * @deprecated
      */
     delete(assistantID, options) {
         return this._client.delete(path `/assistants/${assistantID}`, {
@@ -5640,8 +5651,8 @@ Evals.Runs = Runs;
 let Files$1 = class Files extends APIResource {
     /**
      * Upload a file that can be used across various endpoints. Individual files can be
-     * up to 512 MB, and the size of all files uploaded by one organization can be up
-     * to 1 TB.
+     * up to 512 MB, and each project can store up to 2.5 TB of files in total. There
+     * is no organization-wide storage limit.
      *
      * - The Assistants API supports files up to 2 million tokens and of specific file
      *   types. See the
@@ -14504,82 +14515,1774 @@ class AlpacaMarketDataAPI extends EventEmitter {
     }
 }
 // Export the singleton instance
-AlpacaMarketDataAPI.getInstance();
+const marketDataAPI = AlpacaMarketDataAPI.getInstance();
 
-// Test file for context functionality
-// testGetTradingDate();
-// testGetTradingStartAndEndDates();
-// testGetLastFullTradingDate();
-// testGetMarketOpenClose();
-// testGetNYTimeZone();
-// testGetNextMarketDay();
-// testCountTradingDays();
-// testGetPreviousMarketDay();
-// testOpenRouter();
-// testGetMarketStatus();
-// testCryptoMarketData();
+const limitPriceSlippagePercent100 = 0.1; // 0.1%
 /**
- * Test market data subscription for long-running monitoring
- * This test subscribes to minute bars and logs incoming data to verify continuous stream
- * @param symbol Symbol to test (use 'FAKEPACA' for test mode)
- */
-function testMarketDataSubscription(symbol) {
-    log$2(`Starting market data subscription test for ${symbol}`);
-    const marketDataAPI = AlpacaMarketDataAPI.getInstance();
-    // If symbol is FAKEPACA, use test mode
-    {
-        log$2('Using test mode for FAKEPACA');
-        marketDataAPI.setMode('test');
-    }
-    let barCount = 0;
-    let lastBarTime = null;
-    const startTime = new Date();
-    // Subscribe to minute bars
-    marketDataAPI.on('stock-b', (data) => {
-        barCount++;
-        const now = new Date();
-        const barTime = new Date(data.t);
-        lastBarTime = barTime;
-        const timeSinceStart = Math.floor((now.getTime() - startTime.getTime()) / 1000);
-        const minutesSinceStart = Math.floor(timeSinceStart / 60);
-        const secondsSinceStart = timeSinceStart % 60;
-        log$2(`[${minutesSinceStart}m ${secondsSinceStart}s] Bar #${barCount} for ${data.S}: ` +
-            `O=$${data.o.toFixed(2)}, H=$${data.h.toFixed(2)}, L=$${data.l.toFixed(2)}, C=$${data.c.toFixed(2)}, ` +
-            `V=${data.v.toLocaleString()}, Time=${barTime.toLocaleString('en-US', { timeZone: 'America/New_York' })}`);
-    });
-    // Connect and subscribe
-    log$2('Connecting to stock stream...');
-    marketDataAPI.connectStockStream();
-    // Give it a moment to connect, then subscribe
-    setTimeout(() => {
-        log$2(`Subscribing to minute bars for ${symbol}...`);
-        marketDataAPI.subscribe('stock', { bars: [symbol] });
-    }, 2000);
-    // Log status every 5 minutes
-    setInterval(() => {
-        const now = new Date();
-        const timeSinceStart = Math.floor((now.getTime() - startTime.getTime()) / 1000);
-        const minutesSinceStart = Math.floor(timeSinceStart / 60);
-        const hoursSinceStart = Math.floor(minutesSinceStart / 60);
-        const remainingMinutes = minutesSinceStart % 60;
-        const lastBarInfo = lastBarTime
-            ? `Last bar: ${lastBarTime.toLocaleString('en-US', { timeZone: 'America/New_York' })}`
-            : 'No bars received yet';
-        log$2(`Status check - Runtime: ${hoursSinceStart}h ${remainingMinutes}m, ` +
-            `Total bars: ${barCount}, ${lastBarInfo}`, { type: 'info' });
-    }, 5 * 60 * 1000); // Every 5 minutes
-    log$2('Market data subscription test running... (press Ctrl+C to stop)');
-}
-// testGetPortfolioDailyHistory();
-// testWebSocketConnectAndDisconnect();
-// testGetAssetsShortableFilter();
-// testLLM();
-// testImageModelDefaults();
-// testGetTradingDaysBack();
-// testMOOAndMOCOrders();
-// testMarketDataAPI();
-// Test market data subscription with a real symbol or FAKEPACA
-// Uncomment one of the following to test:
-// testMarketDataSubscription('SPY');
-testMarketDataSubscription('FAKEPACA');
+Websocket example
+  const alpacaAPI = createAlpacaTradingAPI(credentials); // type AlpacaCredentials
+  alpacaAPI.onTradeUpdate((update: TradeUpdate) => {
+   this.log(`Received trade update: event ${update.event} for an order to ${update.order.side} ${update.order.qty} of ${update.order.symbol}`);
+  });
+  alpacaAPI.connectWebsocket(); // necessary to connect to the WebSocket
+
+Portfolio History examples
+  // Get standard portfolio history
+  const portfolioHistory = await alpacaAPI.getPortfolioHistory({
+    timeframe: '1D',
+    period: '1M'
+  });
+
+  // Get daily portfolio history with current day included (if available from hourly data)
+  const dailyHistory = await alpacaAPI.getPortfolioDailyHistory({
+    period: '1M'
+  });
+*/
+class AlpacaTradingAPI {
+    static new(credentials) {
+        return new AlpacaTradingAPI(credentials);
+    }
+    static getInstance(credentials) {
+        return new AlpacaTradingAPI(credentials);
+    }
+    ws = null;
+    headers;
+    tradeUpdateCallback = null;
+    credentials;
+    apiBaseUrl;
+    wsUrl;
+    authenticated = false;
+    connecting = false;
+    reconnectDelay = 10000; // 10 seconds between reconnection attempts
+    reconnectTimeout = null;
+    messageHandlers = new Map();
+    debugLogging = false;
+    manualDisconnect = false;
+    /**
+     * Constructor for AlpacaTradingAPI
+     * @param credentials - Alpaca credentials,
+     *   accountName: string; // The account identifier used inthis.logs and tracking
+     *   apiKey: string; // Alpaca API key
+     *   apiSecret: string; // Alpaca API secret
+     *   type: AlpacaAccountType;
+     *   orderType: AlpacaOrderType;
+     * @param options - Optional options
+     *   debugLogging: boolean; // Whether to log messages of type 'debug'
+     */
+    constructor(credentials, options) {
+        this.credentials = credentials;
+        // Set URLs based on account type
+        this.apiBaseUrl =
+            credentials.type === 'PAPER' ? 'https://paper-api.alpaca.markets/v2' : 'https://api.alpaca.markets/v2';
+        this.wsUrl =
+            credentials.type === 'PAPER' ? 'wss://paper-api.alpaca.markets/stream' : 'wss://api.alpaca.markets/stream';
+        this.headers = {
+            'APCA-API-KEY-ID': credentials.apiKey,
+            'APCA-API-SECRET-KEY': credentials.apiSecret,
+            'Content-Type': 'application/json',
+        };
+        // Initialize message handlers
+        this.messageHandlers.set('authorization', this.handleAuthMessage.bind(this));
+        this.messageHandlers.set('listening', this.handleListenMessage.bind(this));
+        this.messageHandlers.set('trade_updates', this.handleTradeUpdate.bind(this));
+        this.debugLogging = options?.debugLogging || false;
+    }
+    log(message, options = { type: 'info' }) {
+        if (this.debugLogging && options.type === 'debug') {
+            return;
+        }
+        log$1(message, { ...options, source: 'AlpacaTradingAPI', account: this.credentials.accountName });
+    }
+    /**
+     * Round a price to the nearest 2 decimal places for Alpaca, or 4 decimal places for prices less than $1
+     * @param price - The price to round
+     * @returns The rounded price
+     */
+    roundPriceForAlpaca = (price) => {
+        return price >= 1 ? Math.round(price * 100) / 100 : Math.round(price * 10000) / 10000;
+    };
+    handleAuthMessage(data) {
+        if (data.status === 'authorized') {
+            this.authenticated = true;
+            this.log('WebSocket authenticated');
+        }
+        else {
+            this.log(`Authentication failed: ${data.message || 'Unknown error'}`, {
+                type: 'error',
+            });
+        }
+    }
+    handleListenMessage(data) {
+        if (data.streams?.includes('trade_updates')) {
+            this.log('Successfully subscribed to trade updates');
+        }
+    }
+    handleTradeUpdate(data) {
+        if (this.tradeUpdateCallback) {
+            this.log(`Trade update: ${data.event} to ${data.order.side} ${data.order.qty} shares${data.event === 'partial_fill' ? ` (filled shares: ${data.order.filled_qty})` : ''}, type ${data.order.type}`, {
+                symbol: data.order.symbol,
+                type: 'debug',
+            });
+            this.tradeUpdateCallback(data);
+        }
+    }
+    handleMessage(message) {
+        try {
+            const data = JSON.parse(message);
+            const handler = this.messageHandlers.get(data.stream);
+            if (handler) {
+                handler(data.data);
+            }
+            else {
+                this.log(`Received message for unknown stream: ${data.stream}`, {
+                    type: 'warn',
+                });
+            }
+        }
+        catch (error) {
+            this.log('Failed to parse WebSocket message', {
+                type: 'error',
+                metadata: { error: error instanceof Error ? error.message : 'Unknown error' },
+            });
+        }
+    }
+    connectWebsocket() {
+        // Reset manual disconnect flag to allow reconnection logic
+        this.manualDisconnect = false;
+        if (this.connecting) {
+            this.log('Connection attempt skipped - already connecting');
+            return;
+        }
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.log('Connection attempt skipped - already connected');
+            return;
+        }
+        this.connecting = true;
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            this.ws.terminate();
+            this.ws = null;
+        }
+        this.log(`Connecting to WebSocket at ${this.wsUrl}...`);
+        this.ws = new WebSocket(this.wsUrl);
+        this.ws.on('open', async () => {
+            try {
+                this.log('WebSocket connected');
+                await this.authenticate();
+                await this.subscribeToTradeUpdates();
+                this.connecting = false;
+            }
+            catch (error) {
+                this.log('Failed to setup WebSocket connection', {
+                    type: 'error',
+                    metadata: { error: error instanceof Error ? error.message : 'Unknown error' },
+                });
+                this.ws?.close();
+            }
+        });
+        this.ws.on('message', (data) => {
+            this.handleMessage(data.toString());
+        });
+        this.ws.on('error', (error) => {
+            this.log('WebSocket error', {
+                type: 'error',
+                metadata: { error: error instanceof Error ? error.message : 'Unknown error' },
+            });
+            this.connecting = false;
+        });
+        this.ws.on('close', () => {
+            this.log('WebSocket connection closed');
+            this.authenticated = false;
+            this.connecting = false;
+            // Clear any existing reconnect timeout
+            if (this.reconnectTimeout) {
+                clearTimeout(this.reconnectTimeout);
+                this.reconnectTimeout = null;
+            }
+            // Schedule reconnection unless this was a manual disconnect
+            if (!this.manualDisconnect) {
+                this.reconnectTimeout = setTimeout(() => {
+                    this.log('Attempting to reconnect...');
+                    this.connectWebsocket();
+                }, this.reconnectDelay);
+            }
+        });
+    }
+    /**
+     * Cleanly disconnect from the WebSocket and stop auto-reconnects
+     */
+    disconnect() {
+        // Prevent auto-reconnect scheduling
+        this.manualDisconnect = true;
+        // Clear any scheduled reconnect
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        if (this.ws) {
+            this.log('Disconnecting WebSocket...');
+            // Remove listeners first to avoid duplicate handlers after reconnects
+            this.ws.removeAllListeners();
+            try {
+                // Attempt graceful close
+                if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+                    this.ws.close(1000, 'Client disconnect');
+                }
+                else {
+                    this.ws.terminate();
+                }
+            }
+            catch {
+                // Fallback terminate on any error
+                try {
+                    this.ws.terminate();
+                }
+                catch {
+                    /* no-op */
+                }
+            }
+            this.ws = null;
+        }
+        this.authenticated = false;
+        this.connecting = false;
+        this.log('WebSocket disconnected');
+    }
+    async authenticate() {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket not ready for authentication');
+        }
+        const authMessage = {
+            action: 'auth',
+            key: this.credentials.apiKey,
+            secret: this.credentials.apiSecret,
+        };
+        this.ws.send(JSON.stringify(authMessage));
+        return new Promise((resolve, reject) => {
+            const authTimeout = setTimeout(() => {
+                this.log('Authentication timeout', { type: 'error' });
+                reject(new Error('Authentication timed out'));
+            }, 10000);
+            const handleAuthResponse = (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    if (message.stream === 'authorization') {
+                        this.ws?.removeListener('message', handleAuthResponse);
+                        clearTimeout(authTimeout);
+                        if (message.data?.status === 'authorized') {
+                            this.authenticated = true;
+                            resolve();
+                        }
+                        else {
+                            const error = `Authentication failed: ${message.data?.message || 'Unknown error'}`;
+                            this.log(error, { type: 'error' });
+                            reject(new Error(error));
+                        }
+                    }
+                }
+                catch (error) {
+                    this.log('Failed to parse auth response', {
+                        type: 'error',
+                        metadata: { error: error instanceof Error ? error.message : 'Unknown error' },
+                    });
+                }
+            };
+            this.ws?.on('message', handleAuthResponse);
+        });
+    }
+    async subscribeToTradeUpdates() {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.authenticated) {
+            throw new Error('WebSocket not ready for subscription');
+        }
+        const listenMessage = {
+            action: 'listen',
+            data: {
+                streams: ['trade_updates'],
+            },
+        };
+        this.ws.send(JSON.stringify(listenMessage));
+        return new Promise((resolve, reject) => {
+            const listenTimeout = setTimeout(() => {
+                reject(new Error('Subscribe timeout'));
+            }, 10000);
+            const handleListenResponse = (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    if (message.stream === 'listening') {
+                        this.ws?.removeListener('message', handleListenResponse);
+                        clearTimeout(listenTimeout);
+                        if (message.data?.streams?.includes('trade_updates')) {
+                            resolve();
+                        }
+                        else {
+                            reject(new Error('Failed to subscribe to trade updates'));
+                        }
+                    }
+                }
+                catch (error) {
+                    this.log('Failed to parse listen response', {
+                        type: 'error',
+                        metadata: { error: error instanceof Error ? error.message : 'Unknown error' },
+                    });
+                }
+            };
+            this.ws?.on('message', handleListenResponse);
+        });
+    }
+    async makeRequest(endpoint, method = 'GET', body, queryString = '') {
+        const url = `${this.apiBaseUrl}${endpoint}${queryString}`;
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: this.headers,
+                body: body ? JSON.stringify(body) : undefined,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.log(`Alpaca API error (${response.status}): ${errorText}`, { type: 'error' });
+                throw new Error(`Alpaca API error (${response.status}): ${errorText}`);
+            }
+            // Handle responses with no content (e.g., 204 No Content)
+            if (response.status === 204 || response.headers.get('content-length') === '0') {
+                return null;
+            }
+            const contentType = response.headers.get('content-type');
+            if (contentType && contentType.includes('application/json')) {
+                return await response.json();
+            }
+            // For non-JSON responses, return the text content
+            const textContent = await response.text();
+            return textContent || null;
+        }
+        catch (err) {
+            const error = err;
+            this.log(`Error in makeRequest: ${error.message}. Url: ${url}`, {
+                source: 'AlpacaAPI',
+                type: 'error',
+            });
+            throw error;
+        }
+    }
+    async getPositions(assetClass) {
+        const positions = (await this.makeRequest('/positions'));
+        if (assetClass) {
+            return positions.filter((position) => position.asset_class === assetClass);
+        }
+        return positions;
+    }
+    /**
+     * Get all orders
+     * @param params (GetOrdersParams) - optional parameters to filter the orders
+     * - status: 'open' | 'closed' | 'all'
+     * - limit: number
+     * - after: string
+     * - until: string
+     * - direction: 'asc' | 'desc'
+     * - nested: boolean
+     * - symbols: string[], an array of all the symbols
+     * - side: 'buy' | 'sell'
+     * @returns all orders
+     */
+    async getOrders(params = {}) {
+        const queryParams = new URLSearchParams();
+        if (params.status)
+            queryParams.append('status', params.status);
+        if (params.limit)
+            queryParams.append('limit', params.limit.toString());
+        if (params.after)
+            queryParams.append('after', params.after);
+        if (params.until)
+            queryParams.append('until', params.until);
+        if (params.direction)
+            queryParams.append('direction', params.direction);
+        if (params.nested)
+            queryParams.append('nested', params.nested.toString());
+        if (params.symbols)
+            queryParams.append('symbols', params.symbols.join(','));
+        if (params.side)
+            queryParams.append('side', params.side);
+        const endpoint = `/orders${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        try {
+            return await this.makeRequest(endpoint);
+        }
+        catch (error) {
+            this.log(`Error getting orders: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    async getAccountDetails() {
+        try {
+            return await this.makeRequest('/account');
+        }
+        catch (error) {
+            this.log(`Error getting account details: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Create a trailing stop order
+     * @param symbol (string) - the symbol of the order
+     * @param qty (number) - the quantity of the order
+     * @param side (string) - the side of the order
+     * @param trailPercent100 (number) - the trail percent of the order (scale 100, i.e. 0.5 = 0.5%)
+     * @param position_intent (string) - the position intent of the order
+     * @param client_order_id (string) - optional client order id
+     * @returns The created trailing stop order
+     */
+    async createTrailingStop(symbol, qty, side, trailPercent100, position_intent, client_order_id) {
+        this.log(`Creating trailing stop ${side.toUpperCase()} ${qty} shares for ${symbol} with trail percent ${trailPercent100}%`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty),
+            side,
+            position_intent,
+            order_class: 'simple',
+            type: 'trailing_stop',
+            trail_percent: trailPercent100, // Already in decimal form (e.g., 4 for 4%)
+            time_in_force: 'gtc',
+        };
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest(`/orders`, 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating trailing stop: ${error}`, {
+                symbol,
+                type: 'error',
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create a stop order (stop or stop-limit)
+     * @param symbol (string) - the symbol of the order
+     * @param qty (number) - the quantity of the order
+     * @param side (string) - the side of the order
+     * @param stopPrice (number) - the stop price that triggers the order
+     * @param position_intent (string) - the position intent of the order
+     * @param limitPrice (number) - optional limit price (if provided, creates a stop-limit order)
+     * @param client_order_id (string) - optional client order id
+     * @returns The created stop order
+     */
+    async createStopOrder(symbol, qty, side, stopPrice, position_intent, limitPrice, client_order_id) {
+        const isStopLimit = limitPrice !== undefined;
+        const orderType = isStopLimit ? 'stop-limit' : 'stop';
+        this.log(`Creating ${orderType} ${side.toUpperCase()} ${qty} shares for ${symbol} with stop price ${stopPrice}${isStopLimit ? ` and limit price ${limitPrice}` : ''}`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            order_class: 'simple',
+            type: isStopLimit ? 'stop_limit' : 'stop',
+            stop_price: this.roundPriceForAlpaca(stopPrice),
+            time_in_force: 'gtc',
+        };
+        if (isStopLimit) {
+            body.limit_price = this.roundPriceForAlpaca(limitPrice);
+        }
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest(`/orders`, 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating ${orderType} order: ${error}`, {
+                symbol,
+                type: 'error',
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create a market order
+     * @param symbol (string) - the symbol of the order
+     * @param qty (number) - the quantity of the order
+     * @param side (string) - the side of the order
+     * @param position_intent (string) - the position intent of the order. Important for knowing if a position needs a trailing stop.
+     * @param client_order_id (string) - optional client order id
+     */
+    async createMarketOrder(symbol, qty, side, position_intent, client_order_id) {
+        this.log(`Creating market order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            type: 'market',
+            time_in_force: 'day',
+            order_class: 'simple',
+        };
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest('/orders', 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating market order: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Create a Market on Open (MOO) order - executes in the opening auction
+     *
+     * IMPORTANT TIMING CONSTRAINTS:
+     * - Valid submission window: After 7:00pm ET and before 9:28am ET
+     * - Orders submitted between 9:28am and 7:00pm ET will be REJECTED
+     * - Orders submitted after 7:00pm ET are queued for the next trading day's opening auction
+     * - Example: An order at 8:00pm Monday will execute at Tuesday's market open (9:30am)
+     *
+     * @param symbol - The symbol of the order
+     * @param qty - The quantity of shares
+     * @param side - Buy or sell
+     * @param position_intent - The position intent (buy_to_open, sell_to_close, etc.)
+     * @param client_order_id - Optional client order id
+     * @returns The created order
+     */
+    async createMOOOrder(symbol, qty, side, position_intent, client_order_id) {
+        this.log(`Creating Market on Open order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            type: 'market',
+            time_in_force: 'opg',
+            order_class: 'simple',
+        };
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest('/orders', 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating MOO order: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Create a Market on Close (MOC) order - executes in the closing auction
+     *
+     * IMPORTANT TIMING CONSTRAINTS:
+     * - Valid submission window: After 7:00pm ET (previous day) and before 3:50pm ET (same day)
+     * - Orders submitted between 3:50pm and 7:00pm ET will be REJECTED
+     * - Orders submitted after 7:00pm ET are queued for the next trading day's closing auction
+     * - Example: An order at 8:00pm Monday will execute at Tuesday's market close (4:00pm)
+     *
+     * @param symbol - The symbol of the order
+     * @param qty - The quantity of shares
+     * @param side - Buy or sell
+     * @param position_intent - The position intent (buy_to_open, sell_to_close, etc.)
+     * @param client_order_id - Optional client order id
+     * @returns The created order
+     */
+    async createMOCOrder(symbol, qty, side, position_intent, client_order_id) {
+        this.log(`Creating Market on Close order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            type: 'market',
+            time_in_force: 'cls',
+            order_class: 'simple',
+        };
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest('/orders', 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating MOC order: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Create an OCO (One-Cancels-Other) order with take profit and stop loss
+     * @param symbol (string) - the symbol of the order
+     * @param qty (number) - the quantity of the order
+     * @param side (string) - the side of the order (buy or sell)
+     * @param position_intent (string) - the position intent of the order
+     * @param limitPrice (number) - the limit price for the entry order (OCO orders must be limit orders)
+     * @param takeProfitPrice (number) - the take profit price
+     * @param stopLossPrice (number) - the stop loss price
+     * @param stopLossLimitPrice (number) - optional limit price for stop loss (creates stop-limit instead of stop)
+     * @param client_order_id (string) - optional client order id
+     * @returns The created OCO order
+     */
+    async createOCOOrder(symbol, qty, side, position_intent, limitPrice, takeProfitPrice, stopLossPrice, stopLossLimitPrice, client_order_id) {
+        this.log(`Creating OCO order ${side.toUpperCase()} ${qty} shares for ${symbol} at limit ${limitPrice} with take profit ${takeProfitPrice} and stop loss ${stopLossPrice}`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            order_class: 'oco',
+            type: 'limit',
+            limit_price: this.roundPriceForAlpaca(limitPrice),
+            time_in_force: 'gtc',
+            take_profit: {
+                limit_price: this.roundPriceForAlpaca(takeProfitPrice),
+            },
+            stop_loss: {
+                stop_price: this.roundPriceForAlpaca(stopLossPrice),
+            },
+        };
+        // If stop loss limit price is provided, create stop-limit order
+        if (stopLossLimitPrice !== undefined) {
+            body.stop_loss.limit_price = this.roundPriceForAlpaca(stopLossLimitPrice);
+        }
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest(`/orders`, 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating OCO order: ${error}`, {
+                symbol,
+                type: 'error',
+            });
+            throw error;
+        }
+    }
+    /**
+     * Get the current trail percent for a symbol, assuming that it has an open position and a trailing stop order to close it. Because this relies on an orders request for one symbol, you can't do it too often.
+     * @param symbol (string) - the symbol of the order
+     * @returns the current trail percent
+     */
+    async getCurrentTrailPercent(symbol) {
+        try {
+            const orders = await this.getOrders({
+                status: 'open',
+                symbols: [symbol],
+            });
+            const trailingStopOrder = orders.find((order) => order.type === 'trailing_stop' &&
+                (order.position_intent === 'sell_to_close' || order.position_intent === 'buy_to_close'));
+            if (!trailingStopOrder) {
+                this.log(`No closing trailing stop order found for ${symbol}`, {
+                    symbol,
+                });
+                return null;
+            }
+            if (!trailingStopOrder.trail_percent) {
+                this.log(`Trailing stop order found for ${symbol} but no trail_percent value`, {
+                    symbol,
+                });
+                return null;
+            }
+            const trailPercent = parseFloat(trailingStopOrder.trail_percent);
+            return trailPercent;
+        }
+        catch (error) {
+            this.log(`Error getting current trail percent: ${error}`, {
+                symbol,
+                type: 'error',
+            });
+            throw error;
+        }
+    }
+    /**
+     * Update the trail percent for a trailing stop order
+     * @param symbol (string) - the symbol of the order
+     * @param trailPercent100 (number) - the trail percent of the order (scale 100, i.e. 0.5 = 0.5%)
+     */
+    async updateTrailingStop(symbol, trailPercent100) {
+        // First get all open orders for this symbol
+        const orders = await this.getOrders({
+            status: 'open',
+            symbols: [symbol],
+        });
+        // Find the trailing stop order
+        const trailingStopOrder = orders.find((order) => order.type === 'trailing_stop');
+        if (!trailingStopOrder) {
+            this.log(`No open trailing stop order found for ${symbol}`, { type: 'error', symbol });
+            return;
+        }
+        // Check if the trail_percent is already set to the desired value
+        const currentTrailPercent = trailingStopOrder.trail_percent ? parseFloat(trailingStopOrder.trail_percent) : null;
+        // Compare with a small epsilon to handle floating point precision
+        const epsilon = 0.0001;
+        if (currentTrailPercent !== null && Math.abs(currentTrailPercent - trailPercent100) < epsilon) {
+            this.log(`Trailing stop for ${symbol} already set to ${trailPercent100}% (current: ${currentTrailPercent}%), skipping update`, {
+                symbol,
+            });
+            return;
+        }
+        this.log(`Updating trailing stop for ${symbol} from ${currentTrailPercent}% to ${trailPercent100}%`, {
+            symbol,
+        });
+        try {
+            await this.makeRequest(`/orders/${trailingStopOrder.id}`, 'PATCH', {
+                trail: trailPercent100.toString(), // Changed from trail_percent to trail
+            });
+        }
+        catch (error) {
+            this.log(`Error updating trailing stop: ${error}`, {
+                symbol,
+                type: 'error',
+            });
+            throw error;
+        }
+    }
+    /**
+     * Cancel all open orders
+     */
+    async cancelAllOrders() {
+        this.log(`Canceling all open orders`);
+        try {
+            await this.makeRequest('/orders', 'DELETE');
+        }
+        catch (error) {
+            this.log(`Error canceling all orders: ${error}`, { type: 'error' });
+        }
+    }
+    /**
+     * Cancel a specific order by its ID
+     * @param orderId The id of the order to cancel
+     * @throws Error if the order is not cancelable (status 422) or if the order doesn't exist
+     * @returns Promise that resolves when the order is successfully canceled
+     */
+    async cancelOrder(orderId) {
+        this.log(`Attempting to cancel order ${orderId}`);
+        try {
+            await this.makeRequest(`/orders/${orderId}`, 'DELETE');
+            this.log(`Successfully canceled order ${orderId}`);
+        }
+        catch (error) {
+            // If the error is a 422, it means the order is not cancelable
+            if (error instanceof Error && error.message.includes('422')) {
+                this.log(`Order ${orderId} is not cancelable`, {
+                    type: 'error',
+                });
+                throw new Error(`Order ${orderId} is not cancelable`);
+            }
+            // Re-throw other errors
+            throw error;
+        }
+    }
+    /**
+     * Create a limit order
+     * @param symbol (string) - the symbol of the order
+     * @param qty (number) - the quantity of the order
+     * @param side (string) - the side of the order
+     * @param limitPrice (number) - the limit price of the order
+     * @param position_intent (string) - the position intent of the order
+     * @param extended_hours (boolean) - whether the order is in extended hours
+     * @param client_order_id (string) - the client order id of the order
+     */
+    async createLimitOrder(symbol, qty, side, limitPrice, position_intent, extended_hours = false, client_order_id) {
+        this.log(`Creating limit order for ${symbol}: ${side} ${qty} shares at $${limitPrice.toFixed(2)} (${position_intent})`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            type: 'limit',
+            limit_price: this.roundPriceForAlpaca(limitPrice).toString(),
+            time_in_force: 'day',
+            order_class: 'simple',
+            extended_hours,
+        };
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest('/orders', 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating limit order: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Close all equities positions
+     * @param options (object) - the options for closing the positions
+     * - cancel_orders (boolean) - whether to cancel related orders
+     * - useLimitOrders (boolean) - whether to use limit orders to close the positions
+     */
+    async closeAllPositions(options = { cancel_orders: true, useLimitOrders: false }) {
+        this.log(`Closing all positions${options.useLimitOrders ? ' using limit orders' : ''}${options.cancel_orders ? ' and canceling open orders' : ''}`);
+        if (options.useLimitOrders) {
+            // Get all positions
+            const positions = await this.getPositions('us_equity');
+            if (positions.length === 0) {
+                this.log('No positions to close');
+                return;
+            }
+            this.log(`Found ${positions.length} positions to close`);
+            // Get latest quotes for all positions
+            const symbols = positions.map((position) => position.symbol);
+            const quotesResponse = await marketDataAPI.getLatestQuotes(symbols);
+            const lengthOfQuotes = Object.keys(quotesResponse.quotes).length;
+            if (lengthOfQuotes === 0) {
+                this.log('No quotes available for positions, received 0 quotes', {
+                    type: 'error',
+                });
+                return;
+            }
+            if (lengthOfQuotes !== positions.length) {
+                this.log(`Received ${lengthOfQuotes} quotes for ${positions.length} positions, expected ${positions.length} quotes`, { type: 'warn' });
+                return;
+            }
+            // Create limit orders to close each position
+            for (const position of positions) {
+                const quote = quotesResponse.quotes[position.symbol];
+                if (!quote) {
+                    this.log(`No quote available for ${position.symbol}, skipping limit order`, {
+                        symbol: position.symbol,
+                        type: 'warn',
+                    });
+                    continue;
+                }
+                const qty = Math.abs(parseFloat(position.qty));
+                const side = position.side === 'long' ? 'sell' : 'buy';
+                const positionIntent = side === 'sell' ? 'sell_to_close' : 'buy_to_close';
+                // Get the current price from the quote
+                const currentPrice = side === 'sell' ? quote.bp : quote.ap; // Use bid for sells, ask for buys
+                if (!currentPrice) {
+                    this.log(`No valid price available for ${position.symbol}, skipping limit order`, {
+                        symbol: position.symbol,
+                        type: 'warn',
+                    });
+                    continue;
+                }
+                // Apply slippage from config
+                const limitSlippagePercent1 = limitPriceSlippagePercent100 / 100;
+                const limitPrice = side === 'sell'
+                    ? this.roundPriceForAlpaca(currentPrice * (1 - limitSlippagePercent1)) // Sell slightly lower
+                    : this.roundPriceForAlpaca(currentPrice * (1 + limitSlippagePercent1)); // Buy slightly higher
+                this.log(`Creating limit order to close ${position.symbol} position: ${side} ${qty} shares at $${limitPrice.toFixed(2)}`, {
+                    symbol: position.symbol,
+                });
+                await this.createLimitOrder(position.symbol, qty, side, limitPrice, positionIntent);
+            }
+        }
+        else {
+            await this.makeRequest('/positions', 'DELETE', undefined, options.cancel_orders ? '?cancel_orders=true' : '');
+        }
+    }
+    /**
+     * Close all equities positions using limit orders during extended hours trading
+     * @param cancelOrders Whether to cancel related orders (default: true)
+     * @returns Promise that resolves when all positions are closed
+     */
+    async closeAllPositionsAfterHours() {
+        this.log('Closing all positions using limit orders during extended hours trading');
+        // Get all positions
+        const positions = await this.getPositions();
+        this.log(`Found ${positions.length} positions to close`);
+        if (positions.length === 0) {
+            this.log('No positions to close');
+            return;
+        }
+        await this.cancelAllOrders();
+        this.log(`Cancelled all open orders`);
+        // Get latest quotes for all positions
+        const symbols = positions.map((position) => position.symbol);
+        const quotesResponse = await marketDataAPI.getLatestQuotes(symbols);
+        // Create limit orders to close each position
+        for (const position of positions) {
+            const quote = quotesResponse.quotes[position.symbol];
+            if (!quote) {
+                this.log(`No quote available for ${position.symbol}, skipping limit order`, {
+                    symbol: position.symbol,
+                    type: 'warn',
+                });
+                continue;
+            }
+            const qty = Math.abs(parseFloat(position.qty));
+            const side = position.side === 'long' ? 'sell' : 'buy';
+            const positionIntent = side === 'sell' ? 'sell_to_close' : 'buy_to_close';
+            // Get the current price from the quote
+            const currentPrice = side === 'sell' ? quote.bp : quote.ap; // Use bid for sells, ask for buys
+            if (!currentPrice) {
+                this.log(`No valid price available for ${position.symbol}, skipping limit order`, {
+                    symbol: position.symbol,
+                    type: 'warn',
+                });
+                continue;
+            }
+            // Apply slippage from config
+            const limitSlippagePercent1 = limitPriceSlippagePercent100 / 100;
+            const limitPrice = side === 'sell'
+                ? this.roundPriceForAlpaca(currentPrice * (1 - limitSlippagePercent1)) // Sell slightly lower
+                : this.roundPriceForAlpaca(currentPrice * (1 + limitSlippagePercent1)); // Buy slightly higher
+            this.log(`Creating extended hours limit order to close ${position.symbol} position: ${side} ${qty} shares at $${limitPrice.toFixed(2)}`, {
+                symbol: position.symbol,
+            });
+            await this.createLimitOrder(position.symbol, qty, side, limitPrice, positionIntent, true // Enable extended hours trading
+            );
+        }
+        this.log(`All positions closed: ${positions.map((p) => p.symbol).join(', ')}`);
+    }
+    onTradeUpdate(callback) {
+        this.tradeUpdateCallback = callback;
+    }
+    /**
+     * Get portfolio history for the account
+     * @param params Parameters for the portfolio history request
+     * @returns Portfolio history data
+     */
+    async getPortfolioHistory(params) {
+        const queryParams = new URLSearchParams();
+        if (params.timeframe)
+            queryParams.append('timeframe', params.timeframe);
+        if (params.period)
+            queryParams.append('period', params.period);
+        if (params.extended_hours !== undefined)
+            queryParams.append('extended_hours', params.extended_hours.toString());
+        if (params.start)
+            queryParams.append('start', params.start);
+        if (params.end)
+            queryParams.append('end', params.end);
+        if (params.date_end)
+            queryParams.append('date_end', params.date_end);
+        const response = await this.makeRequest(`/account/portfolio/history?${queryParams.toString()}`);
+        return response;
+    }
+    /**
+     * Get portfolio daily history for the account, ensuring the most recent day is included
+     * by combining daily and hourly history if needed.
+     *
+     * This function performs two API calls:
+     * 1. Retrieves daily portfolio history
+     * 2. Retrieves hourly portfolio history to check for more recent data
+     *
+     * If hourly history has timestamps more recent than the last timestamp in daily history,
+     * it appends one additional day to the daily history using the most recent hourly values.
+     *
+     * @param params Parameters for the portfolio history request (same as getPortfolioHistory except timeframe is forced to '1D')
+     * @returns Portfolio history data with daily timeframe, including the most recent day if available from hourly data
+     */
+    async getPortfolioDailyHistory(params) {
+        // Get daily and hourly history in parallel
+        const dailyParams = { ...params, timeframe: '1D' };
+        const hourlyParams = { timeframe: '1Min', period: '1D' };
+        const [dailyHistory, hourlyHistory] = await Promise.all([
+            this.getPortfolioHistory(dailyParams),
+            this.getPortfolioHistory(hourlyParams),
+        ]);
+        // If no hourly history, return daily as-is
+        if (!hourlyHistory.timestamp || hourlyHistory.timestamp.length === 0) {
+            return dailyHistory;
+        }
+        // Get the last timestamp from daily history
+        const lastDailyTimestamp = dailyHistory.timestamp[dailyHistory.timestamp.length - 1];
+        // Check if hourly history has more recent data
+        const recentHourlyData = hourlyHistory.timestamp
+            .map((timestamp, index) => ({ timestamp, index }))
+            .filter(({ timestamp }) => timestamp > lastDailyTimestamp);
+        // If no more recent hourly data, return daily history as-is
+        if (recentHourlyData.length === 0) {
+            return dailyHistory;
+        }
+        // Get the most recent hourly data point
+        const mostRecentHourly = recentHourlyData[recentHourlyData.length - 1];
+        const mostRecentIndex = mostRecentHourly.index;
+        // Calculate the timestamp for the new daily entry.
+        // Alpaca's daily history timestamps are at 00:00:00Z for the calendar day
+        // following the NY trading date. Derive the trading date in NY time from the
+        // most recent intraday timestamp, then set the new daily timestamp to
+        // midnight UTC of the next calendar day.
+        const mostRecentMs = mostRecentHourly.timestamp * 1000; // hourly timestamps are seconds
+        const tradingDateStr = getTradingDate(new Date(mostRecentMs)); // e.g., '2025-09-05' (NY trading date)
+        const [yearStr, monthStr, dayStr] = tradingDateStr.split('-');
+        const year = Number(yearStr);
+        const month = Number(monthStr); // 1-based
+        const day = Number(dayStr);
+        const newDailyTimestamp = Math.floor(Date.UTC(year, month - 1, day + 1, 0, 0, 0, 0) / 1000);
+        // Create a new daily history entry with the most recent hourly values
+        const updatedDailyHistory = {
+            ...dailyHistory,
+            timestamp: [...dailyHistory.timestamp, newDailyTimestamp],
+            equity: [...dailyHistory.equity, hourlyHistory.equity[mostRecentIndex]],
+            profit_loss: [...dailyHistory.profit_loss, hourlyHistory.profit_loss[mostRecentIndex]],
+            profit_loss_pct: [...dailyHistory.profit_loss_pct, hourlyHistory.profit_loss_pct[mostRecentIndex]],
+        };
+        return updatedDailyHistory;
+    }
+    /**
+     * Get option contracts based on specified parameters
+     * @param params Parameters to filter option contracts
+     * @returns Option contracts matching the criteria
+     */
+    async getOptionContracts(params) {
+        const queryParams = new URLSearchParams();
+        queryParams.append('underlying_symbols', params.underlying_symbols.join(','));
+        if (params.expiration_date_gte)
+            queryParams.append('expiration_date_gte', params.expiration_date_gte);
+        if (params.expiration_date_lte)
+            queryParams.append('expiration_date_lte', params.expiration_date_lte);
+        if (params.strike_price_gte)
+            queryParams.append('strike_price_gte', params.strike_price_gte);
+        if (params.strike_price_lte)
+            queryParams.append('strike_price_lte', params.strike_price_lte);
+        if (params.type)
+            queryParams.append('type', params.type);
+        if (params.status)
+            queryParams.append('status', params.status);
+        if (params.limit)
+            queryParams.append('limit', params.limit.toString());
+        if (params.page_token)
+            queryParams.append('page_token', params.page_token);
+        this.log(`Fetching option contracts for ${params.underlying_symbols.join(', ')}`, {
+            symbol: params.underlying_symbols.join(', '),
+        });
+        const response = (await this.makeRequest(`/options/contracts?${queryParams.toString()}`));
+        this.log(`Found ${response.option_contracts.length} option contracts`, {
+            symbol: params.underlying_symbols.join(', '),
+        });
+        return response;
+    }
+    /**
+     * Get a specific option contract by symbol or ID
+     * @param symbolOrId The symbol or ID of the option contract
+     * @returns The option contract details
+     */
+    async getOptionContract(symbolOrId) {
+        this.log(`Fetching option contract details for ${symbolOrId}`, {
+            symbol: symbolOrId,
+        });
+        const response = (await this.makeRequest(`/options/contracts/${symbolOrId}`));
+        this.log(`Found option contract details for ${symbolOrId}: ${response.name}`, {
+            symbol: symbolOrId,
+        });
+        return response;
+    }
+    /**
+     * Create a simple option order (market or limit)
+     * @param symbol Option contract symbol
+     * @param qty Quantity of contracts (must be a whole number)
+     * @param side Buy or sell
+     * @param position_intent Position intent (buy_to_open, buy_to_close, sell_to_open, sell_to_close)
+     * @param type Order type (market or limit)
+     * @param limitPrice Limit price (required for limit orders)
+     * @returns The created order
+     */
+    async createOptionOrder(symbol, qty, side, position_intent, type, limitPrice) {
+        if (!Number.isInteger(qty) || qty <= 0) {
+            this.log('Quantity must be a positive whole number for option orders', { type: 'error' });
+        }
+        if (type === 'limit' && limitPrice === undefined) {
+            this.log('Limit price is required for limit orders', { type: 'error' });
+        }
+        this.log(`Creating ${type} option order for ${symbol}: ${side} ${qty} contracts (${position_intent})${type === 'limit' ? ` at $${limitPrice?.toFixed(2)}` : ''}`, {
+            symbol,
+        });
+        const orderData = {
+            symbol,
+            qty: qty.toString(),
+            side,
+            position_intent,
+            type,
+            time_in_force: 'day',
+            order_class: 'simple',
+            extended_hours: false,
+        };
+        if (type === 'limit' && limitPrice !== undefined) {
+            orderData.limit_price = this.roundPriceForAlpaca(limitPrice).toString();
+        }
+        return this.makeRequest('/orders', 'POST', orderData);
+    }
+    /**
+     * Create a multi-leg option order
+     * @param legs Array of order legs
+     * @param qty Quantity of the multi-leg order (must be a whole number)
+     * @param type Order type (market or limit)
+     * @param limitPrice Limit price (required for limit orders)
+     * @returns The created multi-leg order
+     */
+    async createMultiLegOptionOrder(legs, qty, type, limitPrice) {
+        if (!Number.isInteger(qty) || qty <= 0) {
+            this.log('Quantity must be a positive whole number for option orders', { type: 'error' });
+        }
+        if (type === 'limit' && limitPrice === undefined) {
+            this.log('Limit price is required for limit orders', { type: 'error' });
+        }
+        if (legs.length < 2) {
+            this.log('Multi-leg orders require at least 2 legs', { type: 'error' });
+        }
+        const legSymbols = legs.map((leg) => leg.symbol).join(', ');
+        this.log(`Creating multi-leg ${type} option order with ${legs.length} legs (${legSymbols})${type === 'limit' ? ` at $${limitPrice?.toFixed(2)}` : ''}`, {
+            symbol: legSymbols,
+        });
+        const orderData = {
+            order_class: 'mleg',
+            qty: qty.toString(),
+            type,
+            time_in_force: 'day',
+            legs,
+        };
+        if (type === 'limit' && limitPrice !== undefined) {
+            orderData.limit_price = this.roundPriceForAlpaca(limitPrice).toString();
+        }
+        return this.makeRequest('/orders', 'POST', orderData);
+    }
+    /**
+     * Exercise an option contract
+     * @param symbolOrContractId The symbol or ID of the option contract to exercise
+     * @returns Response from the exercise request
+     */
+    async exerciseOption(symbolOrContractId) {
+        this.log(`Exercising option contract ${symbolOrContractId}`, {
+            symbol: symbolOrContractId,
+        });
+        return this.makeRequest(`/positions/${symbolOrContractId}/exercise`, 'POST');
+    }
+    /**
+     * Get option positions
+     * @returns Array of option positions
+     */
+    async getOptionPositions() {
+        this.log('Fetching option positions');
+        const positions = await this.getPositions('us_option');
+        return positions;
+    }
+    async getOptionsOpenSpreadTrades() {
+        this.log('Fetching option open trades');
+        // this function will get all open positions, extract the symbol and see when they were created.
+        // figures out when the earliest date was (should be today)
+        // then it pulls all orders after the earliest date that were closed and that were of class 'mleg'
+        // Each of these contains two orders. they look like this:
+    }
+    /**
+     * Get option account activities (exercises, assignments, expirations)
+     * @param activityType Type of option activity to filter by
+     * @param date Date to filter activities (YYYY-MM-DD format)
+     * @returns Array of option account activities
+     */
+    async getOptionActivities(activityType, date) {
+        const queryParams = new URLSearchParams();
+        if (activityType) {
+            queryParams.append('activity_types', activityType);
+        }
+        else {
+            queryParams.append('activity_types', 'OPEXC,OPASN,OPEXP');
+        }
+        if (date) {
+            queryParams.append('date', date);
+        }
+        this.log(`Fetching option activities${activityType ? ` of type ${activityType}` : ''}${date ? ` for date ${date}` : ''}`);
+        return this.makeRequest(`/account/activities?${queryParams.toString()}`);
+    }
+    /**
+     * Create a long call spread (buy lower strike call, sell higher strike call)
+     * @param lowerStrikeCallSymbol Symbol of the lower strike call option
+     * @param higherStrikeCallSymbol Symbol of the higher strike call option
+     * @param qty Quantity of spreads to create (must be a whole number)
+     * @param limitPrice Limit price for the spread
+     * @returns The created multi-leg order
+     */
+    async createLongCallSpread(lowerStrikeCallSymbol, higherStrikeCallSymbol, qty, limitPrice) {
+        this.log(`Creating long call spread: Buy ${lowerStrikeCallSymbol}, Sell ${higherStrikeCallSymbol}, Qty: ${qty}, Price: $${limitPrice.toFixed(2)}`, {
+            symbol: `${lowerStrikeCallSymbol},${higherStrikeCallSymbol}`,
+        });
+        const legs = [
+            {
+                symbol: lowerStrikeCallSymbol,
+                ratio_qty: '1',
+                side: 'buy',
+                position_intent: 'buy_to_open',
+            },
+            {
+                symbol: higherStrikeCallSymbol,
+                ratio_qty: '1',
+                side: 'sell',
+                position_intent: 'sell_to_open',
+            },
+        ];
+        return this.createMultiLegOptionOrder(legs, qty, 'limit', limitPrice);
+    }
+    /**
+     * Create a long put spread (buy higher strike put, sell lower strike put)
+     * @param higherStrikePutSymbol Symbol of the higher strike put option
+     * @param lowerStrikePutSymbol Symbol of the lower strike put option
+     * @param qty Quantity of spreads to create (must be a whole number)
+     * @param limitPrice Limit price for the spread
+     * @returns The created multi-leg order
+     */
+    async createLongPutSpread(higherStrikePutSymbol, lowerStrikePutSymbol, qty, limitPrice) {
+        this.log(`Creating long put spread: Buy ${higherStrikePutSymbol}, Sell ${lowerStrikePutSymbol}, Qty: ${qty}, Price: $${limitPrice.toFixed(2)}`, {
+            symbol: `${higherStrikePutSymbol},${lowerStrikePutSymbol}`,
+        });
+        const legs = [
+            {
+                symbol: higherStrikePutSymbol,
+                ratio_qty: '1',
+                side: 'buy',
+                position_intent: 'buy_to_open',
+            },
+            {
+                symbol: lowerStrikePutSymbol,
+                ratio_qty: '1',
+                side: 'sell',
+                position_intent: 'sell_to_open',
+            },
+        ];
+        return this.createMultiLegOptionOrder(legs, qty, 'limit', limitPrice);
+    }
+    /**
+     * Create an iron condor (sell call spread and put spread)
+     * @param longPutSymbol Symbol of the lower strike put (long)
+     * @param shortPutSymbol Symbol of the higher strike put (short)
+     * @param shortCallSymbol Symbol of the lower strike call (short)
+     * @param longCallSymbol Symbol of the higher strike call (long)
+     * @param qty Quantity of iron condors to create (must be a whole number)
+     * @param limitPrice Limit price for the iron condor (credit)
+     * @returns The created multi-leg order
+     */
+    async createIronCondor(longPutSymbol, shortPutSymbol, shortCallSymbol, longCallSymbol, qty, limitPrice) {
+        this.log(`Creating iron condor with ${qty} contracts at $${limitPrice.toFixed(2)}`, {
+            symbol: `${longPutSymbol},${shortPutSymbol},${shortCallSymbol},${longCallSymbol}`,
+        });
+        const legs = [
+            {
+                symbol: longPutSymbol,
+                ratio_qty: '1',
+                side: 'buy',
+                position_intent: 'buy_to_open',
+            },
+            {
+                symbol: shortPutSymbol,
+                ratio_qty: '1',
+                side: 'sell',
+                position_intent: 'sell_to_open',
+            },
+            {
+                symbol: shortCallSymbol,
+                ratio_qty: '1',
+                side: 'sell',
+                position_intent: 'sell_to_open',
+            },
+            {
+                symbol: longCallSymbol,
+                ratio_qty: '1',
+                side: 'buy',
+                position_intent: 'buy_to_open',
+            },
+        ];
+        try {
+            return await this.createMultiLegOptionOrder(legs, qty, 'limit', limitPrice);
+        }
+        catch (error) {
+            this.log(`Error creating iron condor: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Create a covered call (sell call option against owned stock)
+     * @param stockSymbol Symbol of the underlying stock
+     * @param callOptionSymbol Symbol of the call option to sell
+     * @param qty Quantity of covered calls to create (must be a whole number)
+     * @param limitPrice Limit price for the call option
+     * @returns The created order
+     */
+    async createCoveredCall(stockSymbol, callOptionSymbol, qty, limitPrice) {
+        this.log(`Creating covered call: Sell ${callOptionSymbol} against ${stockSymbol}, Qty: ${qty}, Price: $${limitPrice.toFixed(2)}`, {
+            symbol: `${stockSymbol},${callOptionSymbol}`,
+        });
+        // For covered calls, we don't need to include the stock leg if we already own the shares
+        // We just create a simple sell order for the call option
+        try {
+            return await this.createOptionOrder(callOptionSymbol, qty, 'sell', 'sell_to_open', 'limit', limitPrice);
+        }
+        catch (error) {
+            this.log(`Error creating covered call: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Roll an option position to a new expiration or strike
+     * @param currentOptionSymbol Symbol of the current option position
+     * @param newOptionSymbol Symbol of the new option to roll to
+     * @param qty Quantity of options to roll (must be a whole number)
+     * @param currentPositionSide Side of the current position ('buy' or 'sell')
+     * @param limitPrice Net limit price for the roll
+     * @returns The created multi-leg order
+     */
+    async rollOptionPosition(currentOptionSymbol, newOptionSymbol, qty, currentPositionSide, limitPrice) {
+        this.log(`Rolling ${qty} ${currentOptionSymbol} to ${newOptionSymbol} at net price $${limitPrice.toFixed(2)}`, {
+            symbol: `${currentOptionSymbol},${newOptionSymbol}`,
+        });
+        // If current position is long, we need to sell to close and buy to open
+        // If current position is short, we need to buy to close and sell to open
+        const closePositionSide = currentPositionSide === 'buy' ? 'sell' : 'buy';
+        const openPositionSide = currentPositionSide;
+        const closePositionIntent = closePositionSide === 'buy' ? 'buy_to_close' : 'sell_to_close';
+        const openPositionIntent = openPositionSide === 'buy' ? 'buy_to_open' : 'sell_to_open';
+        const legs = [
+            {
+                symbol: currentOptionSymbol,
+                ratio_qty: '1',
+                side: closePositionSide,
+                position_intent: closePositionIntent,
+            },
+            {
+                symbol: newOptionSymbol,
+                ratio_qty: '1',
+                side: openPositionSide,
+                position_intent: openPositionIntent,
+            },
+        ];
+        try {
+            return await this.createMultiLegOptionOrder(legs, qty, 'limit', limitPrice);
+        }
+        catch (error) {
+            this.log(`Error rolling option position: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Get option chain for a specific underlying symbol and expiration date
+     * @param underlyingSymbol The underlying stock symbol
+     * @param expirationDate The expiration date (YYYY-MM-DD format)
+     * @returns Option contracts for the specified symbol and expiration date
+     */
+    async getOptionChain(underlyingSymbol, expirationDate) {
+        this.log(`Fetching option chain for ${underlyingSymbol} with expiration date ${expirationDate}`, {
+            symbol: underlyingSymbol,
+        });
+        try {
+            const params = {
+                underlying_symbols: [underlyingSymbol],
+                expiration_date_gte: expirationDate,
+                expiration_date_lte: expirationDate,
+                status: 'active',
+                limit: 500, // Get a large number to ensure we get all strikes
+            };
+            const response = await this.getOptionContracts(params);
+            return response.option_contracts || [];
+        }
+        catch (error) {
+            this.log(`Failed to fetch option chain for ${underlyingSymbol}: ${error instanceof Error ? error.message : 'Unknown error'}`, {
+                type: 'error',
+                symbol: underlyingSymbol,
+            });
+            return [];
+        }
+    }
+    /**
+     * Get all available expiration dates for a specific underlying symbol
+     * @param underlyingSymbol The underlying stock symbol
+     * @returns Array of available expiration dates
+     */
+    async getOptionExpirationDates(underlyingSymbol) {
+        this.log(`Fetching available expiration dates for ${underlyingSymbol}`, {
+            symbol: underlyingSymbol,
+        });
+        try {
+            const params = {
+                underlying_symbols: [underlyingSymbol],
+                status: 'active',
+                limit: 1000, // Get a large number to ensure we get contracts with all expiration dates
+            };
+            const response = await this.getOptionContracts(params);
+            // Extract unique expiration dates
+            const expirationDates = new Set();
+            if (response.option_contracts) {
+                response.option_contracts.forEach((contract) => {
+                    expirationDates.add(contract.expiration_date);
+                });
+            }
+            // Convert to array and sort
+            return Array.from(expirationDates).sort();
+        }
+        catch (error) {
+            this.log(`Failed to fetch expiration dates for ${underlyingSymbol}: ${error instanceof Error ? error.message : 'Unknown error'}`, {
+                type: 'error',
+                symbol: underlyingSymbol,
+            });
+            return [];
+        }
+    }
+    /**
+     * Get the current options trading level for the account
+     * @returns The options trading level (0-3)
+     */
+    async getOptionsTradingLevel() {
+        this.log('Fetching options trading level');
+        const accountDetails = await this.getAccountDetails();
+        return accountDetails.options_trading_level || 0;
+    }
+    /**
+     * Check if the account has options trading enabled
+     * @returns Boolean indicating if options trading is enabled
+     */
+    async isOptionsEnabled() {
+        this.log('Checking if options trading is enabled');
+        const accountDetails = await this.getAccountDetails();
+        // Check if options trading level is 2 or higher (Level 2+ allows buying calls/puts)
+        // Level 0: Options disabled
+        // Level 1: Only covered calls and cash-secured puts
+        // Level 2+: Can buy calls and puts (required for executeOptionsOrder)
+        const optionsLevel = accountDetails.options_trading_level || 0;
+        const isEnabled = optionsLevel >= 2;
+        this.log(`Options trading level: ${optionsLevel}, enabled: ${isEnabled}`);
+        return isEnabled;
+    }
+    /**
+     * Close all option positions
+     * @param cancelOrders Whether to cancel related orders (default: true)
+     * @returns Response from the close positions request
+     */
+    async closeAllOptionPositions(cancelOrders = true) {
+        this.log(`Closing all option positions${cancelOrders ? ' and canceling related orders' : ''}`);
+        const optionPositions = await this.getOptionPositions();
+        if (optionPositions.length === 0) {
+            this.log('No option positions to close');
+            return;
+        }
+        // Create market orders to close each position
+        for (const position of optionPositions) {
+            const side = position.side === 'long' ? 'sell' : 'buy';
+            const positionIntent = side === 'sell' ? 'sell_to_close' : 'buy_to_close';
+            this.log(`Closing ${position.side} position of ${position.qty} contracts for ${position.symbol}`, {
+                symbol: position.symbol,
+            });
+            await this.createOptionOrder(position.symbol, parseInt(position.qty), side, positionIntent, 'market');
+        }
+        if (cancelOrders) {
+            // Get all open option orders
+            const orders = await this.getOrders({ status: 'open' });
+            const optionOrders = orders.filter((order) => order.asset_class === 'us_option');
+            // Cancel each open option order
+            for (const order of optionOrders) {
+                this.log(`Canceling open order for ${order.symbol}`, {
+                    symbol: order.symbol,
+                });
+                await this.makeRequest(`/orders/${order.id}`, 'DELETE');
+            }
+        }
+    }
+    /**
+     * Close a specific option position
+     * @param symbol The option contract symbol
+     * @param qty Optional quantity to close (defaults to entire position)
+     * @returns The created order
+     */
+    async closeOptionPosition(symbol, qty) {
+        this.log(`Closing option position for ${symbol}${qty ? ` (${qty} contracts)` : ''}`, {
+            symbol,
+        });
+        // Get the position details
+        const positions = await this.getOptionPositions();
+        const position = positions.find((p) => p.symbol === symbol);
+        if (!position) {
+            throw new Error(`No position found for option contract ${symbol}`);
+        }
+        const quantityToClose = qty || parseInt(position.qty);
+        const side = position.side === 'long' ? 'sell' : 'buy';
+        const positionIntent = side === 'sell' ? 'sell_to_close' : 'buy_to_close';
+        try {
+            return await this.createOptionOrder(symbol, quantityToClose, side, positionIntent, 'market');
+        }
+        catch (error) {
+            this.log(`Error closing option position: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Create a complete equities trade with optional stop loss and take profit
+     * @param params Trade parameters including symbol, qty, side, and optional referencePrice
+     * @param options Trade options including order type, extended hours, stop loss, and take profit settings
+     * @returns The created order
+     */
+    async createEquitiesTrade(params, options) {
+        const { symbol, qty, side, referencePrice } = params;
+        const { type = 'market', limitPrice, extendedHours = false, useStopLoss = false, stopPrice, stopPercent100, useTakeProfit = false, takeProfitPrice, takeProfitPercent100, clientOrderId, } = options || {};
+        // Validation: Extended hours + market order is not allowed
+        if (extendedHours && type === 'market') {
+            this.log('Cannot create market order with extended hours enabled', {
+                symbol,
+                type: 'error',
+            });
+            throw new Error('Cannot create market order with extended hours enabled');
+        }
+        // Validation: Limit orders require limit price
+        if (type === 'limit' && limitPrice === undefined) {
+            this.log('Limit price is required for limit orders', {
+                symbol,
+                type: 'error',
+            });
+            throw new Error('Limit price is required for limit orders');
+        }
+        let calculatedStopPrice;
+        let calculatedTakeProfitPrice;
+        // Handle stop loss validation and calculation
+        if (useStopLoss) {
+            if (stopPrice === undefined && stopPercent100 === undefined) {
+                this.log('Either stopPrice or stopPercent100 must be provided when useStopLoss is true', {
+                    symbol,
+                    type: 'error',
+                });
+                throw new Error('Either stopPrice or stopPercent100 must be provided when useStopLoss is true');
+            }
+            if (stopPercent100 !== undefined) {
+                if (referencePrice === undefined) {
+                    this.log('referencePrice is required when using stopPercent100', {
+                        symbol,
+                        type: 'error',
+                    });
+                    throw new Error('referencePrice is required when using stopPercent100');
+                }
+                // Calculate stop price based on percentage and side
+                const stopPercentDecimal = stopPercent100 / 100;
+                if (side === 'buy') {
+                    // For buy orders, stop loss is below the reference price
+                    calculatedStopPrice = referencePrice * (1 - stopPercentDecimal);
+                }
+                else {
+                    // For sell orders, stop loss is above the reference price
+                    calculatedStopPrice = referencePrice * (1 + stopPercentDecimal);
+                }
+            }
+            else {
+                calculatedStopPrice = stopPrice;
+            }
+        }
+        // Handle take profit validation and calculation
+        if (useTakeProfit) {
+            if (takeProfitPrice === undefined && takeProfitPercent100 === undefined) {
+                this.log('Either takeProfitPrice or takeProfitPercent100 must be provided when useTakeProfit is true', {
+                    symbol,
+                    type: 'error',
+                });
+                throw new Error('Either takeProfitPrice or takeProfitPercent100 must be provided when useTakeProfit is true');
+            }
+            if (takeProfitPercent100 !== undefined) {
+                if (referencePrice === undefined) {
+                    this.log('referencePrice is required when using takeProfitPercent100', {
+                        symbol,
+                        type: 'error',
+                    });
+                    throw new Error('referencePrice is required when using takeProfitPercent100');
+                }
+                // Calculate take profit price based on percentage and side
+                const takeProfitPercentDecimal = takeProfitPercent100 / 100;
+                if (side === 'buy') {
+                    // For buy orders, take profit is above the reference price
+                    calculatedTakeProfitPrice = referencePrice * (1 + takeProfitPercentDecimal);
+                }
+                else {
+                    // For sell orders, take profit is below the reference price
+                    calculatedTakeProfitPrice = referencePrice * (1 - takeProfitPercentDecimal);
+                }
+            }
+            else {
+                calculatedTakeProfitPrice = takeProfitPrice;
+            }
+        }
+        // Determine order class based on what's enabled
+        let orderClass = 'simple';
+        if (useStopLoss && useTakeProfit) {
+            orderClass = 'bracket';
+        }
+        else if (useStopLoss || useTakeProfit) {
+            orderClass = 'oto';
+        }
+        // Build the order request
+        const orderData = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            type,
+            time_in_force: 'day',
+            order_class: orderClass,
+            extended_hours: extendedHours,
+            position_intent: side === 'buy' ? 'buy_to_open' : 'sell_to_open',
+        };
+        if (clientOrderId) {
+            orderData.client_order_id = clientOrderId;
+        }
+        // Add limit price for limit orders
+        if (type === 'limit' && limitPrice !== undefined) {
+            orderData.limit_price = this.roundPriceForAlpaca(limitPrice).toString();
+        }
+        // Add stop loss if enabled
+        if (useStopLoss && calculatedStopPrice !== undefined) {
+            orderData.stop_loss = {
+                stop_price: this.roundPriceForAlpaca(calculatedStopPrice).toString(),
+            };
+        }
+        // Add take profit if enabled
+        if (useTakeProfit && calculatedTakeProfitPrice !== undefined) {
+            orderData.take_profit = {
+                limit_price: this.roundPriceForAlpaca(calculatedTakeProfitPrice).toString(),
+            };
+        }
+        const logMessage = `Creating ${orderClass} ${type} ${side} order for ${symbol}: ${qty} shares${type === 'limit' ? ` at $${limitPrice?.toFixed(2)}` : ''}${useStopLoss ? ` with stop loss at $${calculatedStopPrice?.toFixed(2)}` : ''}${useTakeProfit ? ` with take profit at $${calculatedTakeProfitPrice?.toFixed(2)}` : ''}${extendedHours ? ' (extended hours)' : ''}`;
+        this.log(logMessage, {
+            symbol,
+        });
+        try {
+            return await this.makeRequest('/orders', 'POST', orderData);
+        }
+        catch (error) {
+            this.log(`Error creating equities trade: ${error}`, {
+                symbol,
+                type: 'error',
+            });
+            throw error;
+        }
+    }
+}
+
+// Test file for context functionality
+// testGetPortfolioDailyHistory();
+// testWebSocketConnectAndDisconnect();
+// testGetAssetsShortableFilter();
+// testLLM();
+// testImageModelDefaults();
+// testGetTradingDaysBack();
+// testMOOAndMOCOrders();
+// testMarketDataAPI();
+// Test market data subscription with a real symbol or FAKEPACA
+// Uncomment one of the following to test:
+// testMarketDataSubscription('SPY');
+// testMarketDataSubscription('FAKEPACA');
+// testGetTradingDate();
+// Test new order functions
+testStopAndOCOOrders();
+/**
+ * Test the createStopOrder and createOCOOrder functions
+ */
+async function testStopAndOCOOrders() {
+    const log = (message, options = { type: 'info' }) => {
+        log$1(message, { ...options, source: 'Test' });
+    };
+    log('=== Testing Stop and OCO Orders ===');
+    const credentials = {
+        accountName: 'Paper',
+        apiKey: process.env.ALPACA_TRADING_API_KEY || '',
+        apiSecret: process.env.ALPACA_TRADING_SECRET_KEY || '',
+        type: 'PAPER',
+        orderType: 'market',
+        engine: 'brain',
+    };
+    if (!credentials.apiKey || !credentials.apiSecret) {
+        log('Missing Alpaca credentials in environment variables', { type: 'error' });
+        return;
+    }
+    const tradingAPI = AlpacaTradingAPI.getInstance(credentials);
+    try {
+        const timestamp = Date.now();
+        // Test 1: Create a simple stop order
+        log('Test 1: Creating stop order for AAPL');
+        const stopOrder = await tradingAPI.createStopOrder('AAPL', 1, 'sell', 145.00, 'sell_to_open' // Use sell_to_open since we don't have a position
+        );
+        log(`✓ Stop order created: ${stopOrder.id}, type: ${stopOrder.type}, stop_price: ${stopOrder.stop_price}`);
+        // Test 2: Create a stop-limit order
+        log('Test 2: Creating stop-limit order for TSLA');
+        const stopLimitOrder = await tradingAPI.createStopOrder('TSLA', 1, 'sell', 200.00, 'sell_to_open', // Use sell_to_open since we don't have a position
+        199.50, `test-stop-limit-${timestamp}`);
+        log(`✓ Stop-limit order created: ${stopLimitOrder.id}, type: ${stopLimitOrder.type}, stop_price: ${stopLimitOrder.stop_price}, limit_price: ${stopLimitOrder.limit_price}`);
+        // Test 3: Create an OCO order (must be an exit order, so we first need to buy shares)
+        log('Test 3: Creating position in MSFT and then OCO order to exit');
+        // First check if there's an existing position and close it
+        const existingPositions = await tradingAPI.getPositions();
+        const msftPosition = existingPositions.find(p => p.symbol === 'MSFT');
+        if (msftPosition) {
+            log('  Closing existing MSFT position...');
+            await tradingAPI.closeAllPositions({ cancel_orders: true, useLimitOrders: false });
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        }
+        // Buy shares to create a position
+        log('  3a: Buying 1 share of MSFT to create position...');
+        const msftEntry = await tradingAPI.createMarketOrder('MSFT', 1, 'buy', 'buy_to_open');
+        log(`  ✓ Entry order created: ${msftEntry.id}`);
+        // Wait for order to fill (paper trading should be instant but let's be safe)
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        // Verify position exists
+        const positions = await tradingAPI.getPositions();
+        const newMsftPosition = positions.find(p => p.symbol === 'MSFT');
+        if (!newMsftPosition) {
+            log('  Warning: MSFT position not found, skipping OCO test', { type: 'error' });
+        }
+        else {
+            log(`  ✓ MSFT position confirmed: ${newMsftPosition.qty} shares`);
+            // Now create OCO to exit the position
+            log('  3b: Creating OCO order to exit MSFT position...');
+            const ocoOrder = await tradingAPI.createOCOOrder('MSFT', 1, 'sell', // sell to exit the long position
+            'sell_to_close', // must be sell_to_close since we're exiting
+            420.00, // limit price for exit order
+            425.00, // take profit (sell at or above this)
+            415.00 // stop loss (sell if price drops to this)
+            );
+            log(`✓ OCO order created: ${ocoOrder.id}, order_class: ${ocoOrder.order_class}`);
+            if (ocoOrder.legs && ocoOrder.legs.length > 0) {
+                log(`  - Legs: ${ocoOrder.legs.length} orders`);
+                ocoOrder.legs.forEach((leg, index) => {
+                    log(`    Leg ${index + 1}: type=${leg.type}, limit_price=${leg.limit_price}, stop_price=${leg.stop_price}`);
+                });
+            }
+        }
+        // Test 4: Create another OCO order with stop-limit
+        log('Test 4: Creating position in QQQ and OCO order with stop-limit');
+        // Check existing QQQ position
+        const qqqExistingPosition = existingPositions.find(p => p.symbol === 'QQQ');
+        if (qqqExistingPosition) {
+            log('  Found existing QQQ position, skipping position creation');
+        }
+        else {
+            log('  4a: Buying 1 share of QQQ to create position...');
+            const qqqEntry = await tradingAPI.createMarketOrder('QQQ', 1, 'buy', 'buy_to_open');
+            log(`  ✓ Entry order created: ${qqqEntry.id}`);
+            // Wait for order to fill
+            await new Promise(resolve => setTimeout(resolve, 3000));
+        }
+        // Verify position exists
+        const updatedPositions = await tradingAPI.getPositions();
+        const qqqPosition = updatedPositions.find(p => p.symbol === 'QQQ');
+        if (!qqqPosition) {
+            log('  Warning: QQQ position not found, skipping OCO test', { type: 'error' });
+        }
+        else {
+            log(`  ✓ QQQ position confirmed: ${qqqPosition.qty} shares`);
+            log('  4b: Creating OCO order with stop-limit for QQQ...');
+            const ocoLimitOrder = await tradingAPI.createOCOOrder('QQQ', 1, 'sell', // sell to exit the long position
+            'sell_to_close', // must be sell_to_close since we're exiting
+            480.00, // limit price for exit order
+            490.00, // take profit (sell at or above this)
+            470.00, // stop loss
+            470.50, // stop loss limit
+            `test-oco-limit-${timestamp}`);
+            log(`✓ OCO limit order created: ${ocoLimitOrder.id}, order_class: ${ocoLimitOrder.order_class}`);
+            if (ocoLimitOrder.legs && ocoLimitOrder.legs.length > 0) {
+                log(`  - Legs: ${ocoLimitOrder.legs.length} orders`);
+                ocoLimitOrder.legs.forEach((leg, index) => {
+                    log(`    Leg ${index + 1}: type=${leg.type}, limit_price=${leg.limit_price}, stop_price=${leg.stop_price}`);
+                });
+            }
+        }
+        // Clean up: Cancel all test orders
+        log('Cleaning up: Canceling all test orders...');
+        await tradingAPI.cancelAllOrders();
+        log('✓ All test orders canceled');
+        log('=== All Stop and OCO Order Tests Passed ===');
+    }
+    catch (error) {
+        log(`Error during tests: ${error}`, { type: 'error' });
+        throw error;
+    }
+}
 //# sourceMappingURL=test.js.map