@discomedia/utils 1.0.59 → 1.0.61

package/dist/index.mjs

@@ -1380,933 +1380,6 @@ async function fetchWithRetry(url, options = {}, retries = 3, initialBackoff = 1
     }
     throw new Error('Failed to fetch after multiple attempts');
 }
-/**
- * Validates a Polygon.io API key by making a test request.
- * @param apiKey - The API key to validate.
- * @returns Promise that resolves to true if valid, false otherwise.
- */
-async function validatePolygonApiKey(apiKey) {
-    try {
-        const response = await fetch(`https://api.polygon.io/v1/meta/symbols?apikey=${apiKey}&limit=1`);
-        if (response.status === 401) {
-            throw new Error('Invalid or expired Polygon.io API key');
-        }
-        if (response.status === 403) {
-            throw new Error('Polygon.io API key lacks required permissions');
-        }
-        return response.ok;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-        console.error('Polygon.io API key validation failed:', errorMessage);
-        return false;
-    }
-}
-
-/*
-How it works:
-`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
-*/
-
-class Node {
-	value;
-	next;
-
-	constructor(value) {
-		this.value = value;
-	}
-}
-
-class Queue {
-	#head;
-	#tail;
-	#size;
-
-	constructor() {
-		this.clear();
-	}
-
-	enqueue(value) {
-		const node = new Node(value);
-
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-
-		this.#size++;
-	}
-
-	dequeue() {
-		const current = this.#head;
-		if (!current) {
-			return;
-		}
-
-		this.#head = this.#head.next;
-		this.#size--;
-		return current.value;
-	}
-
-	peek() {
-		if (!this.#head) {
-			return;
-		}
-
-		return this.#head.value;
-
-		// TODO: Node.js 18.
-		// return this.#head?.value;
-	}
-
-	clear() {
-		this.#head = undefined;
-		this.#tail = undefined;
-		this.#size = 0;
-	}
-
-	get size() {
-		return this.#size;
-	}
-
-	* [Symbol.iterator]() {
-		let current = this.#head;
-
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-
-	* drain() {
-		while (this.#head) {
-			yield this.dequeue();
-		}
-	}
-}
-
-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;
-
-	const resumeNext = () => {
-		// Process the next queued function if we're under the concurrency limit
-		if (activeCount < concurrency && queue.size > 0) {
-			activeCount++;
-			queue.dequeue().run();
-		}
-	};
-
-	const next = () => {
-		activeCount--;
-		resumeNext();
-	};
-
-	const run = async (function_, resolve, arguments_) => {
-		// Execute the function and capture the result promise
-		const result = (async () => function_(...arguments_))();
-
-		// Resolve immediately with the promise (don't wait for completion)
-		resolve(result);
-
-		// Wait for the function to complete (success or failure)
-		// We catch errors here to prevent unhandled rejections,
-		// but the original promise rejection is preserved for the caller
-		try {
-			await result;
-		} catch {}
-
-		// Decrement active count and process next queued function
-		next();
-	};
-
-	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
-			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
-		if (activeCount < concurrency) {
-			resumeNext();
-		}
-	};
-
-	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
-		enqueue(function_, resolve, reject, arguments_);
-	});
-
-	Object.defineProperties(generator, {
-		activeCount: {
-			get: () => activeCount,
-		},
-		pendingCount: {
-			get: () => queue.size,
-		},
-		clearQueue: {
-			value() {
-				if (!rejectOnClear) {
-					queue.clear();
-					return;
-				}
-
-				const abortError = AbortSignal.abort().reason;
-
-				while (queue.size > 0) {
-					queue.dequeue().reject(abortError);
-				}
-			},
-		},
-		concurrency: {
-			get: () => concurrency,
-
-			set(newConcurrency) {
-				validateConcurrency(newConcurrency);
-				concurrency = newConcurrency;
-
-				queueMicrotask(() => {
-					// eslint-disable-next-line no-unmodified-loop-condition
-					while (activeCount < concurrency && queue.size > 0) {
-						resumeNext();
-					}
-				});
-			},
-		},
-		map: {
-			async value(iterable, function_) {
-				const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-				return Promise.all(promises);
-			},
-		},
-	});
-
-	return generator;
-}
-
-function validateConcurrency(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
-	}
-}
-
-/**********************************************************************************
- * Polygon.io calls
- **********************************************************************************/
-// Constants from environment variables
-const POLYGON_API_KEY = process.env.POLYGON_API_KEY;
-// Define concurrency limits per API
-const POLYGON_CONCURRENCY_LIMIT = 100;
-const polygonLimit = pLimit(POLYGON_CONCURRENCY_LIMIT);
-// Use to update general information about stocks
-/**
- * Fetches general information about a stock ticker.
- * @param {string} symbol - The stock ticker symbol to fetch information for.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @returns {Promise<PolygonTickerInfo | null>} The ticker information or null if not found.
- */
-const fetchTickerInfo = async (symbol, options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const baseUrl = `https://api.polygon.io/v3/reference/tickers/${encodeURIComponent(symbol)}`;
-    const params = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-    });
-    return polygonLimit(async () => {
-        try {
-            const response = await fetchWithRetry(`${baseUrl}?${params.toString()}`, {}, 3, 1000);
-            const data = await response.json();
-            // Check for "NOT_FOUND" status and return null
-            if (data.status === 'NOT_FOUND') {
-                console.warn(`Ticker not found: ${symbol}`);
-                return null;
-            }
-            // Map the results to the required structure
-            const results = data.results;
-            if (!results) {
-                throw new Error('No results in Polygon API response');
-            }
-            // Validate required fields
-            const requiredFields = [
-                'active',
-                'currency_name',
-                'locale',
-                'market',
-                'name',
-                'primary_exchange',
-                'ticker',
-                'type',
-            ];
-            for (const field of requiredFields) {
-                if (results[field] === undefined) {
-                    throw new Error(`Missing required field in Polygon API response: ${field}`);
-                }
-            }
-            // Handle optional share_class_shares_outstanding field
-            if (results.share_class_shares_outstanding === undefined) {
-                results.share_class_shares_outstanding = null;
-            }
-            return {
-                ticker: results.ticker,
-                type: results.type,
-                active: results.active,
-                currency_name: results.currency_name,
-                description: results.description ?? 'No description available',
-                locale: results.locale,
-                market: results.market,
-                market_cap: results.market_cap ?? 0,
-                name: results.name,
-                primary_exchange: results.primary_exchange,
-                share_class_shares_outstanding: results.share_class_shares_outstanding,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            const contextualMessage = `Error fetching ticker info for ${symbol}`;
-            console.error(`${contextualMessage}: ${errorMessage}`, {
-                symbol,
-                errorType: error instanceof Error && error.message.includes('AUTH_ERROR')
-                    ? 'AUTH_ERROR'
-                    : error instanceof Error && error.message.includes('RATE_LIMIT')
-                        ? 'RATE_LIMIT'
-                        : error instanceof Error && error.message.includes('NETWORK_ERROR')
-                            ? 'NETWORK_ERROR'
-                            : 'UNKNOWN',
-                url: hideApiKeyFromurl(`${baseUrl}?${params.toString()}`),
-                source: 'PolygonAPI.fetchTickerInfo',
-                timestamp: new Date().toISOString(),
-            });
-            throw new Error(`${contextualMessage}: ${errorMessage}`);
-        }
-    });
-};
-// Fetch last trade using Polygon.io
-/**
- * Fetches the last trade for a given stock ticker.
- * @param {string} symbol - The stock ticker symbol to fetch the last trade for.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @returns {Promise<PolygonQuote>} The last trade information.
- */
-const fetchLastTrade = async (symbol, options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const baseUrl = `https://api.polygon.io/v2/last/trade/${encodeURIComponent(symbol)}`;
-    const params = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-    });
-    return polygonLimit(async () => {
-        try {
-            const response = await fetchWithRetry(`${baseUrl}?${params.toString()}`, {}, 3, 1000);
-            const data = await response.json();
-            if (data.status !== 'OK' || !data.results) {
-                throw new Error(`Polygon.io API error: ${data.status || 'No results'} ${data.error || ''}`);
-            }
-            const { p: price, s: vol, t: timestamp } = data.results;
-            if (typeof price !== 'number' || typeof vol !== 'number' || typeof timestamp !== 'number') {
-                throw new Error('Invalid trade data received from Polygon.io API');
-            }
-            return {
-                price,
-                vol,
-                time: new Date(Math.floor(timestamp / 1000000)), // Convert nanoseconds to milliseconds
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            const contextualMessage = `Error fetching last trade for ${symbol}`;
-            console.error(`${contextualMessage}: ${errorMessage}`, {
-                symbol,
-                errorType: error instanceof Error && error.message.includes('AUTH_ERROR')
-                    ? 'AUTH_ERROR'
-                    : error instanceof Error && error.message.includes('RATE_LIMIT')
-                        ? 'RATE_LIMIT'
-                        : error instanceof Error && error.message.includes('NETWORK_ERROR')
-                            ? 'NETWORK_ERROR'
-                            : 'UNKNOWN',
-                url: hideApiKeyFromurl(`${baseUrl}?${params.toString()}`),
-                source: 'PolygonAPI.fetchLastTrade',
-                timestamp: new Date().toISOString(),
-            });
-            throw new Error(`${contextualMessage}: ${errorMessage}`);
-        }
-    });
-};
-// use Polygon for all price data fetching
-/**
- * Fetches price data for a given stock ticker.
- * @param {Object} params - The parameters for fetching price data.
- * @param {string} params.ticker - The stock ticker symbol.
- * @param {number} params.start - The start timestamp for fetching price data.
- * @param {number} [params.end] - The end timestamp for fetching price data.
- * @param {number} params.multiplier - The multiplier for the price data.
- * @param {string} params.timespan - The timespan for the price data.
- * @param {number} [params.limit] - The maximum number of price data points to fetch.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @returns {Promise<PolygonPriceData[]>} The fetched price data.
- */
-const fetchPrices = async (params, options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const { ticker, start, end = Date.now().valueOf(), multiplier, timespan, limit = 1000 } = params;
-    const baseUrl = `https://api.polygon.io/v2/aggs/ticker/${encodeURIComponent(ticker)}/range/${multiplier}/${timespan}/${start}/${end}`;
-    const urlParams = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-        adjusted: 'true',
-        sort: 'asc',
-        limit: limit.toString(),
-    });
-    return polygonLimit(async () => {
-        try {
-            let allResults = [];
-            let nextUrl = `${baseUrl}?${urlParams.toString()}`;
-            while (nextUrl) {
-                //console.log(`Debug: Fetching ${nextUrl}`);
-                const response = await fetchWithRetry(nextUrl, {}, 3, 1000);
-                const data = await response.json();
-                if (data.status !== 'OK') {
-                    throw new Error(`Polygon.io API responded with status: ${data.status}`);
-                }
-                if (data.results) {
-                    allResults = [...allResults, ...data.results];
-                }
-                // Check if there's a next page and append API key
-                nextUrl = data.next_url ? `${data.next_url}&apiKey=${options?.apiKey || POLYGON_API_KEY}` : '';
-            }
-            return allResults.map((entry) => ({
-                date: new Date(entry.t).toLocaleString('en-US', {
-                    year: 'numeric',
-                    month: 'short',
-                    day: '2-digit',
-                    hour: '2-digit',
-                    minute: '2-digit',
-                    second: '2-digit',
-                    timeZone: 'America/New_York',
-                    timeZoneName: 'short',
-                    hourCycle: 'h23',
-                }),
-                timeStamp: entry.t,
-                open: entry.o,
-                high: entry.h,
-                low: entry.l,
-                close: entry.c,
-                vol: entry.v,
-                vwap: entry.vw,
-                trades: entry.n,
-            }));
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            const contextualMessage = `Error fetching price data for ${ticker}`;
-            console.error(`${contextualMessage}: ${errorMessage}`, {
-                ticker,
-                errorType: error instanceof Error && error.message.includes('AUTH_ERROR')
-                    ? 'AUTH_ERROR'
-                    : error instanceof Error && error.message.includes('RATE_LIMIT')
-                        ? 'RATE_LIMIT'
-                        : error instanceof Error && error.message.includes('NETWORK_ERROR')
-                            ? 'NETWORK_ERROR'
-                            : 'UNKNOWN',
-                source: 'PolygonAPI.fetchPrices',
-                timestamp: new Date().toISOString(),
-            });
-            throw new Error(`${contextualMessage}: ${errorMessage}`);
-        }
-    });
-};
-/**
- * Analyzes the price data for a given stock.
- * @param {PolygonPriceData[]} priceData - The price data to analyze.
- * @returns {string} The analysis report.
- */
-function analysePolygonPriceData(priceData) {
-    if (!priceData || priceData.length === 0) {
-        return 'No price data available for analysis.';
-    }
-    // Parse the dates into Date objects
-    const parsedData = priceData.map((entry) => ({
-        ...entry,
-        date: new Date(entry.date),
-    }));
-    // Sort the data by date
-    parsedData.sort((a, b) => a.date.getTime() - b.date.getTime());
-    // Extract start and end times
-    const startTime = parsedData[0].date;
-    const endTime = parsedData[parsedData.length - 1].date;
-    // Calculate the total time in hours
-    (endTime.getTime() - startTime.getTime()) / (1000 * 60 * 60);
-    // Calculate the interval between data points
-    const intervals = parsedData
-        .slice(1)
-        .map((_, i) => (parsedData[i + 1].date.getTime() - parsedData[i].date.getTime()) / 1000); // in seconds
-    const avgInterval = intervals.length > 0 ? intervals.reduce((sum, interval) => sum + interval, 0) / intervals.length : 0;
-    // Format the report
-    const report = `
-Report:
-* Start time of data (US Eastern): ${startTime.toLocaleString('en-US', { timeZone: 'America/New_York' })}
-* End time of data (US Eastern): ${endTime.toLocaleString('en-US', { timeZone: 'America/New_York' })}
-* Number of data points: ${priceData.length}
-* Average interval between data points (seconds): ${avgInterval.toFixed(2)}
-  `;
-    return report.trim();
-}
-/**
- * Fetches grouped daily price data for a specific date.
- * @param {string} date - The date to fetch grouped daily data for.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @param {boolean} [options.adjusted] - Whether to adjust the data.
- * @param {boolean} [options.includeOTC] - Whether to include OTC data.
- * @returns {Promise<PolygonGroupedDailyResponse>} The grouped daily response.
- */
-const fetchGroupedDaily = async (date, options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const baseUrl = `https://api.polygon.io/v2/aggs/grouped/locale/us/market/stocks/${date}`;
-    const params = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-        adjusted: options?.adjusted !== false ? 'true' : 'false',
-        include_otc: options?.includeOTC ? 'true' : 'false',
-    });
-    return polygonLimit(async () => {
-        try {
-            const response = await fetchWithRetry(`${baseUrl}?${params.toString()}`, {}, 3, 1000);
-            const data = await response.json();
-            if (data.status !== 'OK') {
-                throw new Error(`Polygon.io API responded with status: ${data.status}`);
-            }
-            return {
-                adjusted: data.adjusted,
-                queryCount: data.queryCount,
-                request_id: data.request_id,
-                resultsCount: data.resultsCount,
-                status: data.status,
-                results: data.results.map((result) => ({
-                    symbol: result.T,
-                    timeStamp: result.t,
-                    open: result.o,
-                    high: result.h,
-                    low: result.l,
-                    close: result.c,
-                    vol: result.v,
-                    vwap: result.vw,
-                    trades: result.n,
-                })),
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            const contextualMessage = `Error fetching grouped daily data for ${date}`;
-            console.error(`${contextualMessage}: ${errorMessage}`, {
-                date,
-                errorType: error instanceof Error && error.message.includes('AUTH_ERROR')
-                    ? 'AUTH_ERROR'
-                    : error instanceof Error && error.message.includes('RATE_LIMIT')
-                        ? 'RATE_LIMIT'
-                        : error instanceof Error && error.message.includes('NETWORK_ERROR')
-                            ? 'NETWORK_ERROR'
-                            : 'UNKNOWN',
-                url: hideApiKeyFromurl(`${baseUrl}?${params.toString()}`),
-                source: 'PolygonAPI.fetchGroupedDaily',
-                timestamp: new Date().toISOString(),
-            });
-            throw new Error(`${contextualMessage}: ${errorMessage}`);
-        }
-    });
-};
-/**
- * Formats the price data into a readable string.
- * @param {PolygonPriceData[]} priceData - The price data to format.
- * @returns {string} The formatted price data.
- */
-function formatPriceData(priceData) {
-    if (!priceData || priceData.length === 0)
-        return 'No price data available';
-    return priceData
-        .map((d) => {
-        // For daily data, remove the time portion if it's all zeros
-        const dateStr = d.date.includes(', 00:00:00') ? d.date.split(', 00:00:00')[0] : d.date;
-        return [
-            dateStr,
-            `O: ${formatCurrency(d.open)}`,
-            `H: ${formatCurrency(d.high)}`,
-            `L: ${formatCurrency(d.low)}`,
-            `C: ${formatCurrency(d.close)}`,
-            `Vol: ${d.vol}`,
-        ].join(' | ');
-    })
-        .join('\n');
-}
-const fetchDailyOpenClose = async (
-/**
- * Fetches the daily open and close data for a given stock ticker.
- * @param {string} symbol - The stock ticker symbol to fetch data for.
- * @param {Date} [date=new Date()] - The date to fetch data for.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @param {boolean} [options.adjusted] - Whether to adjust the data.
- * @returns {Promise<PolygonDailyOpenClose>} The daily open and close data.
- */
-symbol, date = new Date(), options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const formattedDate = date.toISOString().split('T')[0]; // Format as YYYY-MM-DD
-    const baseUrl = `https://api.polygon.io/v1/open-close/${encodeURIComponent(symbol)}/${formattedDate}`;
-    const params = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-        adjusted: (options?.adjusted ?? true).toString(),
-    });
-    return polygonLimit(async () => {
-        const response = await fetchWithRetry(`${baseUrl}?${params.toString()}`, {}, 3, 1000);
-        const data = await response.json();
-        if (data.status !== 'OK') {
-            throw new Error(`Failed to fetch daily open/close data for ${symbol}: ${data.status}`);
-        }
-        return data;
-    });
-};
-/**
- * Gets the previous close price for a given stock ticker.
- * @param {string} symbol - The stock ticker symbol to fetch the previous close for.
- * @param {Date} [referenceDate] - The reference date to use for fetching the previous close.
- * @returns {Promise<{ close: number; date: Date }>} The previous close price and date.
- */
-async function getPreviousClose(symbol, referenceDate, options) {
-    const previousDate = getLastFullTradingDate(referenceDate);
-    const lastOpenClose = await fetchDailyOpenClose(symbol, previousDate, options);
-    if (!lastOpenClose) {
-        throw new Error(`Could not fetch last trade price for ${symbol}`);
-    }
-    return {
-        close: lastOpenClose.close,
-        date: previousDate,
-    };
-}
-/**
- * Fetches trade data for a given stock ticker.
- * @param {string} symbol - The stock ticker symbol to fetch trades for.
- * @param {Object} [options] - Optional parameters.
- * @param {string} [options.apiKey] - The API key to use for the request.
- * @param {string | number} [options.timestamp] - The timestamp for fetching trades.
- * @param {string | number} [options.timestampgt] - Greater than timestamp for fetching trades.
- * @param {string | number} [options.timestampgte] - Greater than or equal to timestamp for fetching trades.
- * @param {string | number} [options.timestamplt] - Less than timestamp for fetching trades.
- * @param {string | number} [options.timestamplte] - Less than or equal to timestamp for fetching trades.
- * @param {'asc' | 'desc'} [options.order] - The order of the trades.
- * @param {number} [options.limit] - The maximum number of trades to fetch.
- * @param {string} [options.sort] - The sort order for the trades.
- * @returns {Promise<PolygonTradesResponse>} The fetched trades response.
- */
-const fetchTrades = async (symbol, options) => {
-    if (!options?.apiKey && !POLYGON_API_KEY) {
-        throw new Error('Polygon API key is missing');
-    }
-    const baseUrl = `https://api.polygon.io/v3/trades/${encodeURIComponent(symbol)}`;
-    const params = new URLSearchParams({
-        apiKey: options?.apiKey || POLYGON_API_KEY,
-    });
-    // Add optional parameters if they exist
-    if (options?.timestamp)
-        params.append('timestamp', options.timestamp.toString());
-    if (options?.timestampgt)
-        params.append('timestamp.gt', options.timestampgt.toString());
-    if (options?.timestampgte)
-        params.append('timestamp.gte', options.timestampgte.toString());
-    if (options?.timestamplt)
-        params.append('timestamp.lt', options.timestamplt.toString());
-    if (options?.timestamplte)
-        params.append('timestamp.lte', options.timestamplte.toString());
-    if (options?.order)
-        params.append('order', options.order);
-    if (options?.limit)
-        params.append('limit', options.limit.toString());
-    if (options?.sort)
-        params.append('sort', options.sort);
-    return polygonLimit(async () => {
-        const url = `${baseUrl}?${params.toString()}`;
-        try {
-            console.log(`[DEBUG] Fetching trades for ${symbol} from ${url}`);
-            const response = await fetchWithRetry(url, {}, 3, 1000);
-            const data = (await response.json());
-            if ('message' in data) {
-                // This is an error response
-                throw new Error(`Polygon API Error: ${data.message}`);
-            }
-            return data;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            const contextualMessage = `Error fetching trades for ${symbol}`;
-            console.error(`${contextualMessage}: ${errorMessage}`, {
-                symbol,
-                errorType: error instanceof Error && error.message.includes('AUTH_ERROR')
-                    ? 'AUTH_ERROR'
-                    : error instanceof Error && error.message.includes('RATE_LIMIT')
-                        ? 'RATE_LIMIT'
-                        : error instanceof Error && error.message.includes('NETWORK_ERROR')
-                            ? 'NETWORK_ERROR'
-                            : 'UNKNOWN',
-                url: hideApiKeyFromurl(url),
-                source: 'PolygonAPI.fetchTrades',
-                timestamp: new Date().toISOString(),
-            });
-            throw new Error(`${contextualMessage}: ${errorMessage}`);
-        }
-    });
-};
-
-/**
- * Polygon Indices API Implementation
- *
- * This module provides functions to interact with the Polygon.io Indices API.
- */
-// Constants from environment variables
-const { ALPACA_INDICES_API_KEY } = process.env;
-// Define concurrency limits for API
-const POLYGON_INDICES_CONCURRENCY_LIMIT = 5;
-const polygonIndicesLimit = pLimit(POLYGON_INDICES_CONCURRENCY_LIMIT);
-// Base URL for Polygon API
-const POLYGON_API_BASE_URL = 'https://api.polygon.io';
-/**
- * Validates that an API key is available
- * @param {string | undefined} apiKey - Optional API key to use
- * @throws {Error} If no API key is available
- */
-const validateApiKey = (apiKey) => {
-    const key = apiKey || ALPACA_INDICES_API_KEY;
-    if (!key) {
-        throw new Error('Polygon Indices API key is missing');
-    }
-    return key;
-};
-/**
- * Fetches aggregate bars for an index over a given date range in custom time window sizes.
- *
- * @param {PolygonIndicesAggregatesParams} params - Parameters for the aggregates request
- * @param {Object} [options] - Optional parameters
- * @param {string} [options.apiKey] - API key to use for the request
- * @returns {Promise<PolygonIndicesAggregatesResponse>} The aggregates response
- */
-const fetchIndicesAggregates = async (params, options) => {
-    const apiKey = validateApiKey(options?.apiKey);
-    const { indicesTicker, multiplier, timespan, from, to, sort = 'asc', limit } = params;
-    const url = new URL(`${POLYGON_API_BASE_URL}/v2/aggs/ticker/${encodeURIComponent(indicesTicker)}/range/${multiplier}/${timespan}/${from}/${to}`);
-    const queryParams = new URLSearchParams();
-    queryParams.append('apiKey', apiKey);
-    if (sort) {
-        queryParams.append('sort', sort);
-    }
-    if (limit) {
-        queryParams.append('limit', limit.toString());
-    }
-    url.search = queryParams.toString();
-    return polygonIndicesLimit(async () => {
-        try {
-            const response = await fetchWithRetry(url.toString(), {}, 3, 300);
-            const data = await response.json();
-            if (data.status === 'ERROR') {
-                throw new Error(`Polygon API Error: ${data.error}`);
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('Error fetching indices aggregates:', error);
-            throw error;
-        }
-    });
-};
-/**
- * Gets the previous day's open, high, low, and close (OHLC) for the specified index.
- *
- * @param {string} indicesTicker - The ticker symbol of the index
- * @param {Object} [options] - Optional parameters
- * @param {string} [options.apiKey] - API key to use for the request
- * @returns {Promise<PolygonIndicesPrevCloseResponse>} The previous close response
- */
-const fetchIndicesPreviousClose = async (indicesTicker, options) => {
-    const apiKey = validateApiKey(options?.apiKey);
-    const url = new URL(`${POLYGON_API_BASE_URL}/v2/aggs/ticker/${encodeURIComponent(indicesTicker)}/prev`);
-    const queryParams = new URLSearchParams();
-    queryParams.append('apiKey', apiKey);
-    url.search = queryParams.toString();
-    return polygonIndicesLimit(async () => {
-        try {
-            const response = await fetchWithRetry(url.toString(), {}, 3, 300);
-            const data = await response.json();
-            if (data.status === 'ERROR') {
-                throw new Error(`Polygon API Error: ${data.error}`);
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('Error fetching indices previous close:', error);
-            throw error;
-        }
-    });
-};
-/**
- * Gets the open, close and afterhours values of an index symbol on a certain date.
- *
- * @param {string} indicesTicker - The ticker symbol of the index
- * @param {string} date - The date in YYYY-MM-DD format
- * @param {Object} [options] - Optional parameters
- * @param {string} [options.apiKey] - API key to use for the request
- * @returns {Promise<PolygonIndicesDailyOpenCloseResponse>} The daily open/close response
- */
-const fetchIndicesDailyOpenClose = async (indicesTicker, date, options) => {
-    const apiKey = validateApiKey(options?.apiKey);
-    const url = new URL(`${POLYGON_API_BASE_URL}/v1/open-close/${encodeURIComponent(indicesTicker)}/${date}`);
-    const queryParams = new URLSearchParams();
-    queryParams.append('apiKey', apiKey);
-    url.search = queryParams.toString();
-    return polygonIndicesLimit(async () => {
-        try {
-            const response = await fetchWithRetry(url.toString(), {}, 3, 300);
-            const data = await response.json();
-            if (data.status === 'ERROR') {
-                throw new Error(`Polygon API Error: ${data.error}`);
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('Error fetching indices daily open/close:', error);
-            throw error;
-        }
-    });
-};
-/**
- * Gets a snapshot of indices data for specified tickers.
- *
- * @param {PolygonIndicesSnapshotParams} [params] - Parameters for the snapshot request
- * @param {Object} [options] - Optional parameters
- * @param {string} [options.apiKey] - API key to use for the request
- * @returns {Promise<PolygonIndicesSnapshotResponse>} The indices snapshot response
- */
-const fetchIndicesSnapshot = async (params, options) => {
-    const apiKey = validateApiKey(options?.apiKey);
-    const url = new URL(`${POLYGON_API_BASE_URL}/v3/snapshot/indices`);
-    const queryParams = new URLSearchParams();
-    queryParams.append('apiKey', apiKey);
-    if (params?.tickers?.length) {
-        queryParams.append('ticker.any_of', params.tickers.join(','));
-    }
-    if (params?.order) {
-        queryParams.append('order', params.order);
-    }
-    if (params?.limit) {
-        queryParams.append('limit', params.limit.toString());
-    }
-    if (params?.sort) {
-        queryParams.append('sort', params.sort);
-    }
-    url.search = queryParams.toString();
-    return polygonIndicesLimit(async () => {
-        try {
-            const response = await fetchWithRetry(url.toString(), {}, 3, 300);
-            const data = await response.json();
-            if (data.status === 'ERROR') {
-                throw new Error(`Polygon API Error: ${data.error}`);
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('Error fetching indices snapshot:', error);
-            throw error;
-        }
-    });
-};
-/**
- * Gets snapshots for assets of all types, including indices.
- *
- * @param {string[]} tickers - Array of tickers to fetch snapshots for
- * @param {Object} [options] - Optional parameters
- * @param {string} [options.apiKey] - API key to use for the request
- * @param {string} [options.type] - Filter by asset type
- * @param {string} [options.order] - Order results
- * @param {number} [options.limit] - Limit the number of results
- * @param {string} [options.sort] - Sort field
- * @returns {Promise<any>} The universal snapshot response
- */
-const fetchUniversalSnapshot = async (tickers, options) => {
-    const apiKey = validateApiKey(options?.apiKey);
-    const url = new URL(`${POLYGON_API_BASE_URL}/v3/snapshot`);
-    const queryParams = new URLSearchParams();
-    queryParams.append('apiKey', apiKey);
-    if (tickers.length) {
-        queryParams.append('ticker.any_of', tickers.join(','));
-    }
-    if (options?.type) {
-        queryParams.append('type', options.type);
-    }
-    if (options?.order) {
-        queryParams.append('order', options.order);
-    }
-    if (options?.limit) {
-        queryParams.append('limit', options.limit.toString());
-    }
-    if (options?.sort) {
-        queryParams.append('sort', options.sort);
-    }
-    url.search = queryParams.toString();
-    return polygonIndicesLimit(async () => {
-        try {
-            const response = await fetchWithRetry(url.toString(), {}, 3, 300);
-            const data = await response.json();
-            if (data.status === 'ERROR') {
-                throw new Error(`Polygon API Error: ${data.error}`);
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('Error fetching universal snapshot:', error);
-            throw error;
-        }
-    });
-};
-/**
- * Converts Polygon Indices bar data to a more standardized format
- *
- * @param {PolygonIndicesAggregatesResponse} data - The raw aggregates response
- * @returns {Array<{date: string, open: number, high: number, low: number, close: number, timestamp: number}>} Formatted bar data
- */
-const formatIndicesBarData = (data) => {
-    return data.results.map((bar) => {
-        const date = new Date(bar.t);
-        return {
-            date: date.toISOString().split('T')[0],
-            open: bar.o,
-            high: bar.h,
-            low: bar.l,
-            close: bar.c,
-            timestamp: bar.t,
-        };
-    });
-};
 
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
     if (typeof state === "function" ? receiver !== state || true : !state.has(receiver))
@@ -2539,7 +1612,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.22.0'; // x-release-please-version
+const VERSION = '6.27.0'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -3159,6 +2232,11 @@ function stringify(object, opts = {}) {
     return joined.length > 0 ? prefix + joined : '';
 }
 
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+function stringifyQuery(query) {
+    return stringify(query, { arrayFormat: 'brackets' });
+}
+
 function concatBytes(buffers) {
     let length = 0;
     for (const buffer of buffers) {
@@ -3377,7 +2455,7 @@ class Stream {
         this.controller = controller;
         __classPrivateFieldSet(this, _Stream_client, client);
     }
-    static fromSSEResponse(response, controller, client) {
+    static fromSSEResponse(response, controller, client, synthesizeEventData) {
         let consumed = false;
         const logger = client ? loggerFor(client) : console;
         async function* iterator() {
@@ -3407,7 +2485,7 @@ class Stream {
                         if (data && data.error) {
                             throw new APIError(undefined, data.error, undefined, response.headers);
                         }
-                        yield data;
+                        yield synthesizeEventData ? { event: sse.event, data } : data;
                     }
                     else {
                         let data;
@@ -3657,9 +2735,9 @@ async function defaultParseResponse(client, props) {
             // Note: there is an invariant here that isn't represented in the type system
             // that if you set `stream: true` the response type must also be `Stream<T>`
             if (props.options.__streamClass) {
-                return props.options.__streamClass.fromSSEResponse(response, props.controller, client);
+                return props.options.__streamClass.fromSSEResponse(response, props.controller, client, props.options.__synthesizeEventData);
             }
-            return Stream.fromSSEResponse(response, props.controller, client);
+            return Stream.fromSSEResponse(response, props.controller, client, props.options.__synthesizeEventData);
         }
         // fetch refuses to read the body when the status code is 204.
         if (response.status === 204) {
@@ -4212,6 +3290,9 @@ const createPathTagFunction = (pathEncoder = encodeURIPath) => function path(sta
 const path = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Given a list of messages comprising a conversation, the model will return a response.
+ */
 let Messages$1 = class Messages extends APIResource {
     /**
      * Get the messages in a stored chat completion. Only Chat Completions that have
@@ -5574,6 +4655,9 @@ class ChatCompletionStreamingRunner extends ChatCompletionStream {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Given a list of messages comprising a conversation, the model will return a response.
+ */
 let Completions$1 = class Completions extends APIResource {
     constructor() {
         super(...arguments);
@@ -5744,10 +4828,15 @@ const buildHeaders = (newHeaders) => {
 };
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Turn audio into text or text into audio.
+ */
 class Speech extends APIResource {
     /**
      * Generates audio from the input text.
      *
+     * Returns the audio file content, or a stream of audio events.
+     *
      * @example
      * ```ts
      * const speech = await client.audio.speech.create({
@@ -5771,6 +4860,9 @@ class Speech extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Turn audio into text or text into audio.
+ */
 class Transcriptions extends APIResource {
     create(body, options) {
         return this._client.post('/audio/transcriptions', multipartFormRequestOptions({
@@ -5783,6 +4875,9 @@ class Transcriptions extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Turn audio into text or text into audio.
+ */
 class Translations extends APIResource {
     create(body, options) {
         return this._client.post('/audio/translations', multipartFormRequestOptions({ body, ...options, __metadata: { model: body.model } }, this._client));
@@ -5803,6 +4898,9 @@ Audio.Translations = Translations;
 Audio.Speech = Speech;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Create large batches of API requests to run asynchronously.
+ */
 class Batches extends APIResource {
     /**
      * Creates and executes a batch from an uploaded file of requests
@@ -5833,6 +4931,9 @@ class Batches extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Build Assistants that can call models and use tools.
+ */
 class Assistants extends APIResource {
     /**
      * Create an assistant with a model and instructions.
@@ -5963,7 +5064,7 @@ Realtime$1.TranscriptionSessions = TranscriptionSessions;
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class Sessions extends APIResource {
     /**
-     * Create a ChatKit session
+     * Create a ChatKit session.
      *
      * @example
      * ```ts
@@ -5982,7 +5083,9 @@ class Sessions extends APIResource {
         });
     }
     /**
-     * Cancel a ChatKit session
+     * Cancel an active ChatKit session and return its most recent metadata.
+     *
+     * Cancelling prevents new requests from using the issued client secret.
      *
      * @example
      * ```ts
@@ -6001,7 +5104,7 @@ class Sessions extends APIResource {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 let Threads$1 = class Threads extends APIResource {
     /**
-     * Retrieve a ChatKit thread
+     * Retrieve a ChatKit thread by its identifier.
      *
      * @example
      * ```ts
@@ -6016,7 +5119,7 @@ let Threads$1 = class Threads extends APIResource {
         });
     }
     /**
-     * List ChatKit threads
+     * List ChatKit threads with optional pagination and user filters.
      *
      * @example
      * ```ts
@@ -6034,7 +5137,7 @@ let Threads$1 = class Threads extends APIResource {
         });
     }
     /**
-     * Delete a ChatKit thread
+     * Delete a ChatKit thread along with its items and stored attachments.
      *
      * @example
      * ```ts
@@ -6050,7 +5153,7 @@ let Threads$1 = class Threads extends APIResource {
         });
     }
     /**
-     * List ChatKit thread items
+     * List items that belong to a ChatKit thread.
      *
      * @example
      * ```ts
@@ -6080,6 +5183,8 @@ ChatKit.Threads = Threads$1;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 /**
+ * Build Assistants that can call models and use tools.
+ *
  * @deprecated The Assistants API is deprecated in favor of the Responses API
  */
 class Messages extends APIResource {
@@ -6148,6 +5253,8 @@ class Messages extends APIResource {
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 /**
+ * Build Assistants that can call models and use tools.
+ *
  * @deprecated The Assistants API is deprecated in favor of the Responses API
  */
 class Steps extends APIResource {
@@ -6760,6 +5867,8 @@ _a$1 = AssistantStream, _AssistantStream_addEvent = function _AssistantStream_ad
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 /**
+ * Build Assistants that can call models and use tools.
+ *
  * @deprecated The Assistants API is deprecated in favor of the Responses API
  */
 let Runs$1 = class Runs extends APIResource {
@@ -6775,6 +5884,7 @@ let Runs$1 = class Runs extends APIResource {
             ...options,
             headers: buildHeaders([{ 'OpenAI-Beta': 'assistants=v2' }, options?.headers]),
             stream: params.stream ?? false,
+            __synthesizeEventData: true,
         });
     }
     /**
@@ -6905,6 +6015,7 @@ let Runs$1 = class Runs extends APIResource {
             ...options,
             headers: buildHeaders([{ 'OpenAI-Beta': 'assistants=v2' }, options?.headers]),
             stream: params.stream ?? false,
+            __synthesizeEventData: true,
         });
     }
     /**
@@ -6929,6 +6040,8 @@ Runs$1.Steps = Steps;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 /**
+ * Build Assistants that can call models and use tools.
+ *
  * @deprecated The Assistants API is deprecated in favor of the Responses API
  */
 class Threads extends APIResource {
@@ -6989,6 +6102,7 @@ class Threads extends APIResource {
             ...options,
             headers: buildHeaders([{ 'OpenAI-Beta': 'assistants=v2' }, options?.headers]),
             stream: body.stream ?? false,
+            __synthesizeEventData: true,
         });
     }
     /**
@@ -7026,6 +6140,9 @@ Beta.Assistants = Assistants;
 Beta.Threads = Threads;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position.
+ */
 class Completions extends APIResource {
     create(body, options) {
         return this._client.post('/completions', { body, ...options, stream: body.stream ?? false });
@@ -7128,6 +6245,9 @@ class Containers extends APIResource {
 Containers.Files = Files$2;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Manage conversations and conversation items.
+ */
 class Items extends APIResource {
     /**
      * Create items in a conversation with the given ID.
@@ -7163,6 +6283,9 @@ class Items extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Manage conversations and conversation items.
+ */
 class Conversations extends APIResource {
     constructor() {
         super(...arguments);
@@ -7196,6 +6319,9 @@ class Conversations extends APIResource {
 Conversations.Items = Items;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.
+ */
 class Embeddings extends APIResource {
     /**
      * Creates an embedding vector representing the input text.
@@ -7246,6 +6372,9 @@ class Embeddings extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Manage and run evals in the OpenAI platform.
+ */
 class OutputItems extends APIResource {
     /**
      * Get an evaluation run output item by ID.
@@ -7264,6 +6393,9 @@ class OutputItems extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Manage and run evals in the OpenAI platform.
+ */
 class Runs extends APIResource {
     constructor() {
         super(...arguments);
@@ -7311,6 +6443,9 @@ class Runs extends APIResource {
 Runs.OutputItems = OutputItems;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Manage and run evals in the OpenAI platform.
+ */
 class Evals extends APIResource {
     constructor() {
         super(...arguments);
@@ -7355,6 +6490,9 @@ class Evals extends APIResource {
 Evals.Runs = Runs;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Files are used to upload documents that can be used with features like Assistants and Fine-tuning.
+ */
 let Files$1 = class Files extends APIResource {
     /**
      * Upload a file that can be used across various endpoints. Individual files can be
@@ -7434,6 +6572,9 @@ class Methods extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Manage fine-tuning jobs to tailor a model to your specific training data.
+ */
 let Graders$1 = class Graders extends APIResource {
     /**
      * Run a grader.
@@ -7487,6 +6628,9 @@ class Alpha extends APIResource {
 Alpha.Graders = Graders$1;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Manage fine-tuning jobs to tailor a model to your specific training data.
+ */
 class Permissions extends APIResource {
     /**
      * **NOTE:** Calling this endpoint requires an [admin API key](../admin-api-keys).
@@ -7514,13 +6658,7 @@ class Permissions extends APIResource {
      * Organization owners can use this endpoint to view all permissions for a
      * fine-tuned model checkpoint.
      *
-     * @example
-     * ```ts
-     * const permission =
-     *   await client.fineTuning.checkpoints.permissions.retrieve(
-     *     'ft-AF1WoRqd3aJAHsqc9NY7iL8F',
-     *   );
-     * ```
+     * @deprecated Retrieve is deprecated. Please swap to the paginated list method instead.
      */
     retrieve(fineTunedModelCheckpoint, query = {}, options) {
         return this._client.get(path `/fine_tuning/checkpoints/${fineTunedModelCheckpoint}/permissions`, {
@@ -7528,6 +6666,25 @@ class Permissions extends APIResource {
             ...options,
         });
     }
+    /**
+     * **NOTE:** This endpoint requires an [admin API key](../admin-api-keys).
+     *
+     * Organization owners can use this endpoint to view all permissions for a
+     * fine-tuned model checkpoint.
+     *
+     * @example
+     * ```ts
+     * // Automatically fetches more pages as needed.
+     * for await (const permissionListResponse of client.fineTuning.checkpoints.permissions.list(
+     *   'ft-AF1WoRqd3aJAHsqc9NY7iL8F',
+     * )) {
+     *   // ...
+     * }
+     * ```
+     */
+    list(fineTunedModelCheckpoint, query = {}, options) {
+        return this._client.getAPIList(path `/fine_tuning/checkpoints/${fineTunedModelCheckpoint}/permissions`, (ConversationCursorPage), { query, ...options });
+    }
     /**
      * **NOTE:** This endpoint requires an [admin API key](../admin-api-keys).
      *
@@ -7562,6 +6719,9 @@ let Checkpoints$1 = class Checkpoints extends APIResource {
 Checkpoints$1.Permissions = Permissions;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Manage fine-tuning jobs to tailor a model to your specific training data.
+ */
 class Checkpoints extends APIResource {
     /**
      * List checkpoints for a fine-tuning job.
@@ -7582,6 +6742,9 @@ class Checkpoints extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Manage fine-tuning jobs to tailor a model to your specific training data.
+ */
 class Jobs extends APIResource {
     constructor() {
         super(...arguments);
@@ -7723,6 +6886,9 @@ class Graders extends APIResource {
 Graders.GraderModels = GraderModels;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Given a prompt and/or an input image, the model will generate a new image.
+ */
 class Images extends APIResource {
     /**
      * Creates a variation of a given image. This endpoint only supports `dall-e-2`.
@@ -7746,6 +6912,9 @@ class Images extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * List and describe the various models available in the API.
+ */
 class Models extends APIResource {
     /**
      * Retrieves a model instance, providing basic information about the model such as
@@ -7771,6 +6940,9 @@ class Models extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Given text and/or image inputs, classifies if those inputs are potentially harmful.
+ */
 class Moderations extends APIResource {
     /**
      * Classifies if text and/or image inputs are potentially harmful. Learn more in
@@ -7854,6 +7026,20 @@ class ClientSecrets extends APIResource {
     /**
      * Create a Realtime client secret with an associated session configuration.
      *
+     * Client secrets are short-lived tokens that can be passed to a client app, such
+     * as a web frontend or mobile client, which grants access to the Realtime API
+     * without leaking your main API key. You can configure a custom TTL for each
+     * client secret.
+     *
+     * You can also attach session configuration options to the client secret, which
+     * will be applied to any sessions created using that client secret, but these can
+     * also be overridden by the client connection.
+     *
+     * [Learn more about authentication with client secrets over WebRTC](https://platform.openai.com/docs/guides/realtime-webrtc).
+     *
+     * Returns the created client secret and the effective session object. The client
+     * secret is a string that looks like `ek_1234`.
+     *
      * @example
      * ```ts
      * const clientSecret =
@@ -8279,7 +7465,10 @@ class InputItems extends APIResource {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class InputTokens extends APIResource {
     /**
-     * Get input token counts
+     * Returns input token counts of the request.
+     *
+     * Returns an object with `object` set to `response.input_tokens` and an
+     * `input_tokens` count.
      *
      * @example
      * ```ts
@@ -8361,12 +7550,17 @@ class Responses extends APIResource {
         return this._client.post(path `/responses/${responseID}/cancel`, options);
     }
     /**
-     * Compact conversation
+     * Compact a conversation. Returns a compacted response object.
+     *
+     * Learn when and how to compact long-running conversations in the
+     * [conversation state guide](https://platform.openai.com/docs/guides/conversation-state#managing-the-context-window).
+     * For ZDR-compatible compaction details, see
+     * [Compaction (advanced)](https://platform.openai.com/docs/guides/conversation-state#compaction-advanced).
      *
      * @example
      * ```ts
      * const compactedResponse = await client.responses.compact({
-     *   model: 'gpt-5.2',
+     *   model: 'gpt-5.4',
      * });
      * ```
      */
@@ -8380,7 +7574,7 @@ Responses.InputTokens = InputTokens;
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 let Content$1 = class Content extends APIResource {
     /**
-     * Get Skill Content
+     * Download a skill zip bundle by its ID.
      */
     retrieve(skillID, options) {
         return this._client.get(path `/skills/${skillID}/content`, {
@@ -8394,7 +7588,7 @@ let Content$1 = class Content extends APIResource {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class Content extends APIResource {
     /**
-     * Get Skill Version Content
+     * Download a skill version zip bundle.
      */
     retrieve(version, params, options) {
         const { skill_id } = params;
@@ -8413,20 +7607,20 @@ class Versions extends APIResource {
         this.content = new Content(this._client);
     }
     /**
-     * Create Skill Version
+     * Create a new immutable skill version.
      */
     create(skillID, body = {}, options) {
         return this._client.post(path `/skills/${skillID}/versions`, maybeMultipartFormRequestOptions({ body, ...options }, this._client));
     }
     /**
-     * Get Skill Version
+     * Get a specific skill version.
      */
     retrieve(version, params, options) {
         const { skill_id } = params;
         return this._client.get(path `/skills/${skill_id}/versions/${version}`, options);
     }
     /**
-     * List Skill Versions
+     * List skill versions for a skill.
      */
     list(skillID, query = {}, options) {
         return this._client.getAPIList(path `/skills/${skillID}/versions`, (CursorPage), {
@@ -8435,7 +7629,7 @@ class Versions extends APIResource {
         });
     }
     /**
-     * Delete Skill Version
+     * Delete a skill version.
      */
     delete(version, params, options) {
         const { skill_id } = params;
@@ -8452,31 +7646,31 @@ class Skills extends APIResource {
         this.versions = new Versions(this._client);
     }
     /**
-     * Create Skill
+     * Create a new skill.
      */
     create(body = {}, options) {
         return this._client.post('/skills', maybeMultipartFormRequestOptions({ body, ...options }, this._client));
     }
     /**
-     * Get Skill
+     * Get a skill by its ID.
      */
     retrieve(skillID, options) {
         return this._client.get(path `/skills/${skillID}`, options);
     }
     /**
-     * Update Skill Default Version
+     * Update the default version pointer for a skill.
      */
     update(skillID, body, options) {
         return this._client.post(path `/skills/${skillID}`, { body, ...options });
     }
     /**
-     * List Skills
+     * List all skills for the current project.
      */
     list(query = {}, options) {
         return this._client.getAPIList('/skills', (CursorPage), { query, ...options });
     }
     /**
-     * Delete Skill
+     * Delete a skill by its ID.
      */
     delete(skillID, options) {
         return this._client.delete(path `/skills/${skillID}`, options);
@@ -8486,6 +7680,9 @@ Skills.Content = Content$1;
 Skills.Versions = Versions;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Use Uploads to upload large files in multiple parts.
+ */
 class Parts extends APIResource {
     /**
      * Adds a
@@ -8506,6 +7703,9 @@ class Parts extends APIResource {
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Use Uploads to upload large files in multiple parts.
+ */
 class Uploads extends APIResource {
     constructor() {
         super(...arguments);
@@ -8531,12 +7731,16 @@ class Uploads extends APIResource {
      * For guidance on the proper filename extensions for each purpose, please follow
      * the documentation on
      * [creating a File](https://platform.openai.com/docs/api-reference/files/create).
+     *
+     * Returns the Upload object with status `pending`.
      */
     create(body, options) {
         return this._client.post('/uploads', { body, ...options });
     }
     /**
      * Cancels the Upload. No Parts may be added after an Upload is cancelled.
+     *
+     * Returns the Upload object with status `cancelled`.
      */
     cancel(uploadID, options) {
         return this._client.post(path `/uploads/${uploadID}/cancel`, options);
@@ -8554,7 +7758,9 @@ class Uploads extends APIResource {
      *
      * The number of bytes uploaded upon completion must match the number of bytes
      * initially specified when creating the Upload object. No Parts may be added after
-     * an Upload is completed.
+     * an Upload is completed. Returns the Upload object with status `completed`,
+     * including an additional `file` property containing the created usable File
+     * object.
      */
     complete(uploadID, body, options) {
         return this._client.post(path `/uploads/${uploadID}/complete`, { body, ...options });
@@ -8914,31 +8120,33 @@ VectorStores.FileBatches = FileBatches;
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class Videos extends APIResource {
     /**
-     * Create a video
+     * Create a new video generation job from a prompt and optional reference assets.
      */
     create(body, options) {
         return this._client.post('/videos', maybeMultipartFormRequestOptions({ body, ...options }, this._client));
     }
     /**
-     * Retrieve a video
+     * Fetch the latest metadata for a generated video.
      */
     retrieve(videoID, options) {
         return this._client.get(path `/videos/${videoID}`, options);
     }
     /**
-     * List videos
+     * List recently generated videos for the current project.
      */
     list(query = {}, options) {
         return this._client.getAPIList('/videos', (ConversationCursorPage), { query, ...options });
     }
     /**
-     * Delete a video
+     * Permanently delete a completed or failed video and its stored assets.
      */
     delete(videoID, options) {
         return this._client.delete(path `/videos/${videoID}`, options);
     }
     /**
-     * Download video content
+     * Download the generated video bytes or a derived preview asset.
+     *
+     * Streams the rendered video content for the specified video job.
      */
     downloadContent(videoID, query = {}, options) {
         return this._client.get(path `/videos/${videoID}/content`, {
@@ -8949,7 +8157,7 @@ class Videos extends APIResource {
         });
     }
     /**
-     * Create a video remix
+     * Create a remix of a completed video using a refreshed prompt.
      */
     remix(videoID, body, options) {
         return this._client.post(path `/videos/${videoID}/remix`, maybeMultipartFormRequestOptions({ body, ...options }, this._client));
@@ -9074,24 +8282,54 @@ class OpenAI {
     constructor({ baseURL = readEnv('OPENAI_BASE_URL'), apiKey = readEnv('OPENAI_API_KEY'), organization = readEnv('OPENAI_ORG_ID') ?? null, project = readEnv('OPENAI_PROJECT_ID') ?? null, webhookSecret = readEnv('OPENAI_WEBHOOK_SECRET') ?? null, ...opts } = {}) {
         _OpenAI_instances.add(this);
         _OpenAI_encoder.set(this, void 0);
+        /**
+         * Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position.
+         */
         this.completions = new Completions(this);
         this.chat = new Chat(this);
+        /**
+         * Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.
+         */
         this.embeddings = new Embeddings(this);
+        /**
+         * Files are used to upload documents that can be used with features like Assistants and Fine-tuning.
+         */
         this.files = new Files$1(this);
+        /**
+         * Given a prompt and/or an input image, the model will generate a new image.
+         */
         this.images = new Images(this);
         this.audio = new Audio(this);
+        /**
+         * Given text and/or image inputs, classifies if those inputs are potentially harmful.
+         */
         this.moderations = new Moderations(this);
+        /**
+         * List and describe the various models available in the API.
+         */
         this.models = new Models(this);
         this.fineTuning = new FineTuning(this);
         this.graders = new Graders(this);
         this.vectorStores = new VectorStores(this);
         this.webhooks = new Webhooks(this);
         this.beta = new Beta(this);
+        /**
+         * Create large batches of API requests to run asynchronously.
+         */
         this.batches = new Batches(this);
+        /**
+         * Use Uploads to upload large files in multiple parts.
+         */
         this.uploads = new Uploads(this);
         this.responses = new Responses(this);
         this.realtime = new Realtime(this);
+        /**
+         * Manage conversations and conversation items.
+         */
         this.conversations = new Conversations(this);
+        /**
+         * Manage and run evals in the OpenAI platform.
+         */
         this.evals = new Evals(this);
         this.containers = new Containers(this);
         this.skills = new Skills(this);
@@ -9161,7 +8399,7 @@ class OpenAI {
         return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
     }
     stringifyQuery(query) {
-        return stringify(query, { arrayFormat: 'brackets' });
+        return stringifyQuery(query);
     }
     getUserAgent() {
         return `${this.constructor.name}/JS ${VERSION}`;
@@ -9430,9 +8668,9 @@ class OpenAI {
                 timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
             }
         }
-        // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
-        // just do what it says, but otherwise calculate a default
-        if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1000)) {
+        // If the API asks us to wait a certain amount of time, just do what it
+        // says, but otherwise calculate a default
+        if (timeoutMillis === undefined) {
             const maxRetries = options.maxRetries ?? this.maxRetries;
             timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
         }
@@ -9529,6 +8767,13 @@ class OpenAI {
                 (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))) {
             return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
         }
+        else if (typeof body === 'object' &&
+            headers.values.get('content-type') === 'application/x-www-form-urlencoded') {
+            return {
+                bodyHeaders: { 'content-type': 'application/x-www-form-urlencoded' },
+                body: this.stringifyQuery(body),
+            };
+        }
         else {
             return __classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, { body, headers });
         }
@@ -11059,428 +10304,6 @@ class PerformanceTimer {
     }
 }
 
-/**
- * Calculates Bollinger Bands for a given set of price data.
- * Bollinger Bands consist of a middle band (SMA) and two outer bands
- * that are standard deviations away from the middle band.
- *
- * @param priceData - An array of price data objects containing closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.period - The number of periods to use for the SMA (default is 20).
- * @param params.standardDeviations - The number of standard deviations for the outer bands (default is 2).
- * @returns An array of BollingerBandsData objects containing the calculated bands.
- */
-function calculateBollingerBands(priceData, { period = 20, standardDeviations = 2 } = {}) {
-    if (priceData.length < period) {
-        logIfDebug(`Insufficient data for Bollinger Bands calculation: required periods: ${period}, but only received ${priceData.length} periods of data`);
-        return [];
-    }
-    const result = [];
-    for (let i = period - 1; i < priceData.length; i++) {
-        const periodSlice = priceData.slice(i - period + 1, i + 1);
-        const prices = periodSlice.map((d) => d.close);
-        // Calculate middle band (SMA)
-        const sum = prices.reduce((acc, price) => acc + price, 0);
-        const sma = sum / period;
-        // Calculate standard deviation
-        const squaredDifferences = prices.map((price) => Math.pow(price - sma, 2));
-        const variance = squaredDifferences.reduce((acc, val) => acc + val, 0) / period;
-        const standardDeviation = Math.sqrt(variance);
-        // Calculate bands
-        const upperBand = sma + standardDeviation * standardDeviations;
-        const lowerBand = sma - standardDeviation * standardDeviations;
-        result.push({
-            date: priceData[i].date,
-            middle: parseFloat(sma.toFixed(2)),
-            upper: parseFloat(upperBand.toFixed(2)),
-            lower: parseFloat(lowerBand.toFixed(2)),
-            close: priceData[i].close,
-        });
-    }
-    // logIfDebug(`Calculated Bollinger Bands for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates the Exponential Moving Average (EMA) for a given set of price data.
- * The EMA gives more weight to recent prices, making it more responsive to new information.
- *
- * @param priceData - An array of price data objects containing closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.period - The number of periods to use for the EMA (default is 20).
- * @param params.period2 - An optional second period for a second EMA (default is 9).
- * @returns An array of EMAData objects containing the calculated EMA values.
- */
-function calculateEMA(priceData, { period = 20, period2 = 9 } = {}) {
-    if (priceData.length < period || (period2 && priceData.length < period2)) {
-        logIfDebug(`Insufficient data for EMA calculation: required periods: ${period}, ${period2}, but only received ${priceData.length} periods of data`);
-        return [];
-    }
-    const result = [];
-    const multiplier = 2 / (period + 1);
-    const multiplier2 = period2 ? 2 / (period2 + 1) : 0;
-    // Calculate initial SMA for first period
-    let sum = 0;
-    for (let i = 0; i < period; i++) {
-        sum += priceData[i].close;
-    }
-    let prevEMA = sum / period;
-    // Calculate initial SMA for second period if needed
-    let prevEMA2;
-    if (period2) {
-        sum = 0;
-        for (let i = 0; i < period2; i++) {
-            sum += priceData[i].close;
-        }
-        prevEMA2 = sum / period2;
-    }
-    // Add first EMA(s)
-    const firstEntry = {
-        date: priceData[Math.max(period, period2 || 0) - 1].date,
-        ema: parseFloat(prevEMA.toFixed(2)),
-        close: priceData[Math.max(period, period2 || 0) - 1].close,
-    };
-    if (period2) {
-        firstEntry.ema2 = parseFloat(prevEMA2.toFixed(2));
-    }
-    result.push(firstEntry);
-    // Calculate EMA for remaining periods
-    for (let i = Math.max(period, period2 || 0); i < priceData.length; i++) {
-        const currentClose = priceData[i].close;
-        const currentEMA = (currentClose - prevEMA) * multiplier + prevEMA;
-        prevEMA = currentEMA;
-        const entry = {
-            date: priceData[i].date,
-            ema: parseFloat(currentEMA.toFixed(2)),
-            close: currentClose,
-        };
-        if (period2) {
-            const currentEMA2 = (currentClose - prevEMA2) * multiplier2 + prevEMA2;
-            prevEMA2 = currentEMA2;
-            entry.ema2 = parseFloat(currentEMA2.toFixed(2));
-        }
-        result.push(entry);
-    }
-    // logIfDebug(`Calculated EMA for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates Fibonacci retracement and extension levels based on price data.
- * Fibonacci levels are used to identify potential support and resistance levels.
- *
- * @param priceData - An array of price data objects containing high and low prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.lookbackPeriod - The number of periods to look back for swing high/low (default is 20).
- * @param params.retracementLevels - An array of retracement levels to calculate (default is [0.236, 0.382, 0.5, 0.618, 0.786]).
- * @param params.extensionLevels - An array of extension levels to calculate (default is [1.272, 1.618, 2.618]).
- * @param params.reverseDirection - A boolean indicating if the trend is reversed (default is false).
- * @returns An array of FibonacciData objects containing the calculated levels.
- */
-function calculateFibonacciLevels(priceData, { lookbackPeriod = 20, retracementLevels = [0.236, 0.382, 0.5, 0.618, 0.786], extensionLevels = [1.272, 1.618, 2.618], reverseDirection = false, } = {}) {
-    const result = [];
-    for (let i = 0; i < priceData.length; i++) {
-        const periodSlice = priceData.slice(Math.max(0, i - lookbackPeriod + 1), i + 1);
-        const swingHigh = Math.max(...periodSlice.map((d) => d.high));
-        const swingLow = Math.min(...periodSlice.map((d) => d.low));
-        const priceRange = swingHigh - swingLow;
-        const trend = reverseDirection ? 'downtrend' : 'uptrend';
-        let levels = [];
-        if (priceRange > 0) {
-            // Calculate retracement levels
-            retracementLevels.forEach((level) => {
-                const price = reverseDirection ? swingLow + priceRange * level : swingHigh - priceRange * level;
-                levels.push({
-                    level,
-                    price: parseFloat(price.toFixed(2)),
-                    type: 'retracement',
-                });
-            });
-            // Calculate extension levels
-            extensionLevels.forEach((level) => {
-                const price = reverseDirection
-                    ? swingHigh - priceRange * (level - 1) // For downtrend
-                    : swingHigh + priceRange * (level - 1); // For uptrend
-                levels.push({
-                    level,
-                    price: parseFloat(price.toFixed(2)),
-                    type: 'extension',
-                });
-            });
-            // Sort levels by price
-            levels.sort((a, b) => (reverseDirection ? b.price - a.price : a.price - b.price));
-        }
-        else {
-            logIfDebug(`Price range is zero on date ${priceData[i].date}; no levels calculated.`);
-        }
-        result.push({
-            date: priceData[i].date,
-            levels,
-            swingHigh,
-            swingLow,
-            trend,
-            close: priceData[i].close,
-        });
-    }
-    // logIfDebug(`Calculated Fibonacci levels for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates the Moving Average Convergence Divergence (MACD) for a given set of price data.
- * MACD is a trend-following momentum indicator that shows the relationship between two EMAs.
- *
- * @param priceData - An array of price data objects containing closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.shortPeriod - The short EMA period (default is 12).
- * @param params.longPeriod - The long EMA period (default is 26).
- * @param params.signalPeriod - The signal line period (default is 9).
- * @returns An array of MACDData objects containing the calculated MACD values.
- */
-function calculateMACD(priceData, { shortPeriod = 12, longPeriod = 26, signalPeriod = 9 } = {}) {
-    if (priceData.length < longPeriod + signalPeriod) {
-        logIfDebug(`Insufficient data for MACD calculation: required periods: ${longPeriod + signalPeriod}, but only received ${priceData.length} periods of data`);
-        return [];
-    }
-    const emaShort = calculateEMA(priceData, { period: shortPeriod });
-    const emaLong = calculateEMA(priceData, { period: longPeriod });
-    // Align EMAs by trimming the beginning of emaShort to match emaLong length
-    if (emaShort.length < emaLong.length) {
-        logIfDebug('Short EMA length is less than Long EMA length for MACD calculation');
-        return [];
-    }
-    const emaShortAligned = emaShort.slice(emaShort.length - emaLong.length);
-    const macdLine = emaShortAligned.map((short, i) => short.ema - emaLong[i].ema);
-    const result = [];
-    if (macdLine.length < signalPeriod) {
-        logIfDebug(`Insufficient MACD data for Signal Line calculation: required periods: ${signalPeriod}, but only received ${macdLine.length} periods of data`);
-        return [];
-    }
-    const signalMultiplier = 2 / (signalPeriod + 1);
-    let signalEMA = macdLine.slice(0, signalPeriod).reduce((sum, val) => sum + val, 0) / signalPeriod;
-    for (let i = signalPeriod; i < macdLine.length; i++) {
-        const macdValue = macdLine[i];
-        signalEMA = (macdValue - signalEMA) * signalMultiplier + signalEMA;
-        const hist = macdValue - signalEMA;
-        result.push({
-            date: emaLong[i].date, // Use emaLong's date for alignment
-            macd: parseFloat(macdValue.toFixed(2)),
-            signal: parseFloat(signalEMA.toFixed(2)),
-            histogram: parseFloat(hist.toFixed(2)),
-            close: emaLong[i].close,
-        });
-    }
-    // logIfDebug(`Calculated MACD for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates the Relative Strength Index (RSI) for a given set of price data.
- * RSI is a momentum oscillator that measures the speed and change of price movements.
- *
- * @param priceData - An array of price data objects containing closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.period - The number of periods to use for the RSI (default is 14).
- * @returns An array of RSIData objects containing the calculated RSI values.
- */
-function calculateRSI(priceData, { period = 14 } = {}) {
-    if (priceData.length < period + 1) {
-        logIfDebug(`Insufficient data for RSI calculation: required periods: ${period + 1}, but only received ${priceData.length} periods of data`);
-        return [];
-    }
-    const result = [];
-    let avgGain = 0;
-    let avgLoss = 0;
-    // Calculate first average gain and loss
-    for (let i = 1; i <= period; i++) {
-        const change = priceData[i].close - priceData[i - 1].close;
-        if (change >= 0) {
-            avgGain += change;
-        }
-        else {
-            avgLoss += Math.abs(change);
-        }
-    }
-    avgGain = avgGain / period;
-    avgLoss = avgLoss / period;
-    // Calculate RSI for the first period
-    let rs = avgGain / avgLoss;
-    let rsi = 100 - 100 / (1 + rs);
-    result.push({
-        date: priceData[period].date,
-        rsi: parseFloat(rsi.toFixed(2)),
-        close: priceData[period].close,
-    });
-    // Calculate subsequent periods using smoothed averages
-    for (let i = period + 1; i < priceData.length; i++) {
-        const change = priceData[i].close - priceData[i - 1].close;
-        const gain = change >= 0 ? change : 0;
-        const loss = change < 0 ? Math.abs(change) : 0;
-        // Use smoothed averages
-        avgGain = (avgGain * (period - 1) + gain) / period;
-        avgLoss = (avgLoss * (period - 1) + loss) / period;
-        rs = avgGain / avgLoss;
-        rsi = 100 - 100 / (1 + rs);
-        result.push({
-            date: priceData[i].date,
-            rsi: parseFloat(rsi.toFixed(2)),
-            close: priceData[i].close,
-        });
-    }
-    // logIfDebug(`Calculated RSI for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates the Stochastic Oscillator for a given set of price data.
- * The Stochastic Oscillator compares a particular closing price of a security to a range of its prices over a certain period of time.
- *
- * @param priceData - An array of price data objects containing high, low, and closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.lookbackPeriod - The number of periods to look back for the calculation of %K (default is 5).
- * @param params.signalPeriod - The number of periods for the %D signal line (default is 3).
- * @param params.smoothingFactor - The smoothing factor for %K (default is 3).
- * @returns An array of StochData objects containing the calculated %K and %D values.
- */
-function calculateStochasticOscillator(priceData, { lookbackPeriod = 5, signalPeriod = 3, smoothingFactor = 3 } = {}) {
-    if (priceData.length < lookbackPeriod) {
-        logIfDebug(`Insufficient data for Stochastic Oscillator calculation: required periods: ${lookbackPeriod}, but only received ${priceData.length} periods of data`);
-        return [];
-    }
-    const kValues = [];
-    const result = [];
-    let kSum = 0;
-    let dSum = 0;
-    for (let i = lookbackPeriod - 1; i < priceData.length; i++) {
-        const periodSlice = priceData.slice(i - lookbackPeriod + 1, i + 1);
-        const currentClose = periodSlice[periodSlice.length - 1].close;
-        const highPrices = periodSlice.map((d) => d.high);
-        const lowPrices = periodSlice.map((d) => d.low);
-        const highestHigh = Math.max(...highPrices);
-        const lowestLow = Math.min(...lowPrices);
-        const k = highestHigh === lowestLow ? 0 : ((currentClose - lowestLow) / (highestHigh - lowestLow)) * 100;
-        kValues.push(k);
-        kSum += k;
-        if (kValues.length > smoothingFactor)
-            kSum -= kValues[kValues.length - smoothingFactor - 1];
-        const smoothedK = kSum / Math.min(kValues.length, smoothingFactor);
-        dSum += smoothedK;
-        if (kValues.length > smoothingFactor + signalPeriod - 1)
-            dSum -= kValues[kValues.length - smoothingFactor - signalPeriod];
-        const smoothedD = dSum / Math.min(kValues.length - smoothingFactor + 1, signalPeriod);
-        if (kValues.length >= smoothingFactor + signalPeriod - 1) {
-            result.push({
-                date: priceData[i].date,
-                slowK: parseFloat(smoothedK.toFixed(2)),
-                slowD: parseFloat(smoothedD.toFixed(2)),
-                close: currentClose,
-            });
-        }
-    }
-    // logIfDebug(`Calculated Stochastic Oscillator for ${result.length} periods`);
-    return result;
-}
-/**
- * Calculates support and resistance levels based on price data.
- * Support and resistance levels are price levels at which a stock tends to stop and reverse.
- *
- * @param priceData - An array of price data objects containing high, low, and closing prices.
- * @param params - An object containing optional parameters for the calculation.
- * @param params.maxLevels - The maximum number of support/resistance levels to return (default is 5).
- * @param params.lookbackPeriod - The number of periods to look back for pivot points (default is 10).
- * @returns An array of SupportResistanceData objects containing the calculated levels.
- */
-function calculateSupportAndResistance(priceData, { maxLevels = 5, lookbackPeriod = 10 } = {}) {
-    const result = [];
-    for (let i = 0; i < priceData.length; i++) {
-        const startIdx = Math.max(0, i - lookbackPeriod);
-        const analysisWindow = priceData.slice(startIdx, i + 1);
-        const pivotPoints = [];
-        // **Compute Volatility Metrics**
-        const priceChanges = analysisWindow.slice(1).map((bar, idx) => Math.abs(bar.close - analysisWindow[idx].close));
-        const avgPriceChange = priceChanges.reduce((sum, change) => sum + change, 0) / priceChanges.length;
-        const volatility = avgPriceChange / analysisWindow[0].close; // Relative volatility
-        // **Adjust Sensitivity and minGapBetweenLevels Dynamically**
-        const sensitivity = volatility * 2; // Adjust the multiplier as needed
-        const minGapBetweenLevels = volatility * 100; // Convert to percentage
-        // Analyze each point in window for pivot status
-        for (let j = 1; j < analysisWindow.length - 1; j++) {
-            const curr = analysisWindow[j];
-            const prevBar = analysisWindow[j - 1];
-            const nextBar = analysisWindow[j + 1];
-            // Check for high pivot
-            if (curr.high > prevBar.high && curr.high > nextBar.high) {
-                const existingPivot = pivotPoints.find((p) => Math.abs(p.price - curr.high) / curr.high < sensitivity);
-                if (existingPivot) {
-                    existingPivot.count++;
-                    existingPivot.volume += curr.vol; // **Include Volume**
-                }
-                else {
-                    pivotPoints.push({ price: curr.high, count: 1, volume: curr.vol });
-                }
-            }
-            // Check for low pivot
-            if (curr.low < prevBar.low && curr.low < nextBar.low) {
-                const existingPivot = pivotPoints.find((p) => Math.abs(p.price - curr.low) / curr.low < sensitivity);
-                if (existingPivot) {
-                    existingPivot.count++;
-                    existingPivot.volume += curr.vol; // **Include Volume**
-                }
-                else {
-                    pivotPoints.push({ price: curr.low, count: 1, volume: curr.vol });
-                }
-            }
-        }
-        // Group nearby levels
-        const currentPrice = priceData[i].close;
-        const levels = [];
-        // Sort pivots by price
-        pivotPoints.sort((a, b) => a.price - b.price);
-        // Group close pivots
-        let currentGroup = [];
-        for (let j = 0; j < pivotPoints.length; j++) {
-            if (currentGroup.length === 0) {
-                currentGroup.push(pivotPoints[j]);
-            }
-            else {
-                const lastPrice = currentGroup[currentGroup.length - 1].price;
-                if ((Math.abs(pivotPoints[j].price - lastPrice) / lastPrice) * 100 <= minGapBetweenLevels) {
-                    currentGroup.push(pivotPoints[j]);
-                }
-                else {
-                    // Process current group
-                    if (currentGroup.length > 0) {
-                        const totalVolume = currentGroup.reduce((sum, p) => sum + p.volume, 0);
-                        const avgPrice = currentGroup.reduce((sum, p) => sum + p.price * p.volume, 0) / totalVolume;
-                        const totalStrength = currentGroup.reduce((sum, p) => sum + p.count * (p.volume / totalVolume), 0);
-                        levels.push({
-                            price: parseFloat(avgPrice.toFixed(2)),
-                            strength: parseFloat(totalStrength.toFixed(2)),
-                            type: avgPrice > currentPrice ? 'resistance' : 'support',
-                        });
-                    }
-                    currentGroup = [pivotPoints[j]];
-                }
-            }
-        }
-        // Process final group
-        if (currentGroup.length > 0) {
-            const totalVolume = currentGroup.reduce((sum, p) => sum + p.volume, 0);
-            const avgPrice = currentGroup.reduce((sum, p) => sum + p.price * p.volume, 0) / totalVolume;
-            const totalStrength = currentGroup.reduce((sum, p) => sum + p.count * (p.volume / totalVolume), 0);
-            levels.push({
-                price: parseFloat(avgPrice.toFixed(2)),
-                strength: parseFloat(totalStrength.toFixed(2)),
-                type: avgPrice > currentPrice ? 'resistance' : 'support',
-            });
-        }
-        // Sort by strength and limit
-        const finalLevels = levels.sort((a, b) => b.strength - a.strength).slice(0, maxLevels);
-        result.push({
-            date: priceData[i].date,
-            levels: finalLevels,
-            close: currentPrice,
-        });
-    }
-    logIfDebug(`Found ${result.reduce((sum, r) => sum + r.levels.length, 0)} support/resistance levels across ${result.length} periods`);
-    return result;
-}
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -19886,40 +18709,12 @@ const disco = {
         pct: formatPercentage,
         dateTimeForGS: dateTimeForGS,
     },
-    indices: {
-        fetchAggregates: fetchIndicesAggregates,
-        fetchPreviousClose: fetchIndicesPreviousClose,
-        fetchDailyOpenClose: fetchIndicesDailyOpenClose,
-        fetchSnapshot: fetchIndicesSnapshot,
-        fetchUniversalSnapshot: fetchUniversalSnapshot,
-        formatBarData: formatIndicesBarData,
-    },
     llm: {
         call: makeLLMCall,
         seek: makeDeepseekCall,
         images: makeImagesCall,
         open: makeOpenRouterCall,
     },
-    polygon: {
-        fetchTickerInfo: fetchTickerInfo,
-        fetchGroupedDaily: fetchGroupedDaily,
-        fetchLastTrade: fetchLastTrade,
-        fetchTrades: fetchTrades,
-        fetchPrices: fetchPrices,
-        analysePolygonPriceData: analysePolygonPriceData,
-        formatPriceData: formatPriceData,
-        fetchDailyOpenClose: fetchDailyOpenClose,
-        getPreviousClose: getPreviousClose,
-    },
-    ta: {
-        calculateEMA: calculateEMA,
-        calculateMACD: calculateMACD,
-        calculateRSI: calculateRSI,
-        calculateStochasticOscillator: calculateStochasticOscillator,
-        calculateBollingerBands: calculateBollingerBands,
-        calculateSupportAndResistance: calculateSupportAndResistance,
-        calculateFibonacciLevels: calculateFibonacciLevels,
-    },
     time: {
         convertDateToMarketTimeZone: convertDateToMarketTimeZone,
         getStartAndEndDates: getStartAndEndDates,
@@ -19942,7 +18737,6 @@ const disco = {
     utils: {
         logIfDebug: logIfDebug,
         fetchWithRetry: fetchWithRetry,
-        validatePolygonApiKey: validatePolygonApiKey,
         Timer: PerformanceTimer,
     },
 };