@discomedia/utils 1.0.51 → 1.0.53

package/dist/test.js

@@ -146,18 +146,12 @@ const marketEarlyCloses = {
 
 // Constants for NY market times (Eastern Time)
 const MARKET_CONFIG = {
-    TIMEZONE: 'America/New_York',
     UTC_OFFSET_STANDARD: -5, // EST
     UTC_OFFSET_DST: -4, // EDT
     TIMES: {
-        EXTENDED_START: { hour: 4, minute: 0 },
         MARKET_OPEN: { hour: 9, minute: 30 },
-        EARLY_MARKET_END: { hour: 10, minute: 0 },
         MARKET_CLOSE: { hour: 16, minute: 0 },
-        EARLY_CLOSE: { hour: 13, minute: 0 },
-        EXTENDED_END: { hour: 20, minute: 0 },
-        EARLY_EXTENDED_END: { hour: 17, minute: 0 },
-    },
+        EARLY_CLOSE: { hour: 13, minute: 0 }},
 };
 // Helper: Get NY offset for a given UTC date (DST rules for US)
 /**
@@ -225,33 +219,6 @@ function fromNYTime(date) {
     const utcMillis = nyMillis - offset * 60 * 60 * 1000;
     return new Date(utcMillis);
 }
-// Helper: Format date in ISO, unix, etc.
-/**
- * Formats a date in ISO, unix-seconds, or unix-ms format.
- * @param date - Date object
- * @param outputFormat - Output format ('iso', 'unix-seconds', 'unix-ms')
- * @returns Formatted date string or number
- */
-function formatDate(date, outputFormat = 'iso') {
-    switch (outputFormat) {
-        case 'unix-seconds':
-            return Math.floor(date.getTime() / 1000);
-        case 'unix-ms':
-            return date.getTime();
-        case 'iso':
-        default:
-            return date.toISOString();
-    }
-}
-// Helper: Format date in NY locale string
-/**
- * Formats a date in NY locale string.
- * @param date - Date object
- * @returns NY locale string
- */
-function formatNYLocale(date) {
-    return date.toLocaleString('en-US', { timeZone: 'America/New_York' });
-}
 // Market calendar logic
 /**
  * Market calendar logic for holidays, weekends, and market days.
@@ -347,82 +314,6 @@ class MarketCalendar {
         return prevDay;
     }
 }
-// Market open/close times
-/**
- * Returns market open/close times for a given date, including extended and early closes.
- * @param date - Date object
- * @returns MarketOpenCloseResult
- */
-function getMarketTimes(date) {
-    const calendar = new MarketCalendar();
-    const nyDate = toNYTime(date);
-    if (!calendar.isMarketDay(date)) {
-        return {
-            marketOpen: false,
-            open: null,
-            close: null,
-            openExt: null,
-            closeExt: null,
-        };
-    }
-    const year = nyDate.getUTCFullYear();
-    const month = nyDate.getUTCMonth();
-    const day = nyDate.getUTCDate();
-    // Helper to build NY time for a given hour/minute
-    function buildNYTime(hour, minute) {
-        const d = new Date(Date.UTC(year, month, day, hour, minute, 0, 0));
-        return fromNYTime(d);
-    }
-    let open = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute);
-    let close = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute);
-    let openExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute);
-    let closeExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute);
-    if (calendar.isEarlyCloseDay(date)) {
-        close = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute);
-        closeExt = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute);
-    }
-    return {
-        marketOpen: true,
-        open,
-        close,
-        openExt,
-        closeExt,
-    };
-}
-// Is within market hours
-/**
- * Checks if a date/time is within market hours, extended hours, or continuous.
- * @param date - Date object
- * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
- * @returns true if within hours, false otherwise
- */
-function isWithinMarketHours(date, intradayReporting = 'market_hours') {
-    const calendar = new MarketCalendar();
-    if (!calendar.isMarketDay(date))
-        return false;
-    const nyDate = toNYTime(date);
-    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
-    switch (intradayReporting) {
-        case 'extended_hours': {
-            let endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
-            if (calendar.isEarlyCloseDay(date)) {
-                endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
-            }
-            const startMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
-            return minutes >= startMinutes && minutes <= endMinutes;
-        }
-        case 'continuous':
-            return true;
-        default: {
-            let endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-            if (calendar.isEarlyCloseDay(date)) {
-                endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-            }
-            const startMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-            return minutes >= startMinutes && minutes <= endMinutes;
-        }
-    }
-}
 // Get last full trading date
 /**
  * Returns the last full trading date (market close) for a given date.
@@ -463,244 +354,6 @@ function getLastFullTradingDateImpl(currentDate = new Date()) {
     const closeMinute = marketCloseMinutes % 60;
     return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
 }
-// Get day boundaries
-/**
- * Returns the start and end boundaries for a market day, extended hours, or continuous.
- * @param date - Date object
- * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
- * @returns Object with start and end Date
- */
-function getDayBoundaries(date, intradayReporting = 'market_hours') {
-    const calendar = new MarketCalendar();
-    const nyDate = toNYTime(date);
-    const year = nyDate.getUTCFullYear();
-    const month = nyDate.getUTCMonth();
-    const day = nyDate.getUTCDate();
-    function buildNYTime(hour, minute, sec = 0, ms = 0) {
-        const d = new Date(Date.UTC(year, month, day, hour, minute, sec, ms));
-        return fromNYTime(d);
-    }
-    let start;
-    let end;
-    switch (intradayReporting) {
-        case 'extended_hours':
-            start = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute, 0, 0);
-            end = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute, 59, 999);
-            if (calendar.isEarlyCloseDay(date)) {
-                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute, 59, 999);
-            }
-            break;
-        case 'continuous':
-            start = new Date(Date.UTC(year, month, day, 0, 0, 0, 0));
-            end = new Date(Date.UTC(year, month, day, 23, 59, 59, 999));
-            break;
-        default:
-            start = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute, 0, 0);
-            end = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute, 59, 999);
-            if (calendar.isEarlyCloseDay(date)) {
-                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute, 59, 999);
-            }
-            break;
-    }
-    return { start, end };
-}
-// Period calculator
-/**
- * Calculates the start date for a given period ending at endDate.
- * @param endDate - Date object
- * @param period - Period string
- * @returns Date object for period start
- */
-function calculatePeriodStartDate(endDate, period) {
-    const calendar = new MarketCalendar();
-    let startDate;
-    switch (period) {
-        case 'YTD':
-            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), 0, 1));
-            break;
-        case '1D':
-            startDate = calendar.getPreviousMarketDay(endDate);
-            break;
-        case '3D':
-            startDate = new Date(endDate.getTime() - 3 * 24 * 60 * 60 * 1000);
-            break;
-        case '1W':
-            startDate = new Date(endDate.getTime() - 7 * 24 * 60 * 60 * 1000);
-            break;
-        case '2W':
-            startDate = new Date(endDate.getTime() - 14 * 24 * 60 * 60 * 1000);
-            break;
-        case '1M':
-            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 1, endDate.getUTCDate()));
-            break;
-        case '3M':
-            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 3, endDate.getUTCDate()));
-            break;
-        case '6M':
-            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 6, endDate.getUTCDate()));
-            break;
-        case '1Y':
-            startDate = new Date(Date.UTC(endDate.getUTCFullYear() - 1, endDate.getUTCMonth(), endDate.getUTCDate()));
-            break;
-        default:
-            throw new Error(`Invalid period: ${period}`);
-    }
-    // Ensure start date is a market day
-    while (!calendar.isMarketDay(startDate)) {
-        startDate = calendar.getNextMarketDay(startDate);
-    }
-    return startDate;
-}
-// Get market time period
-/**
- * Returns the start and end dates for a market time period.
- * @param params - MarketTimeParams
- * @returns PeriodDates object
- */
-function getMarketTimePeriod(params) {
-    const { period, end = new Date(), intraday_reporting = 'market_hours', outputFormat = 'iso' } = params;
-    if (!period)
-        throw new Error('Period is required');
-    const calendar = new MarketCalendar();
-    const nyEndDate = toNYTime(end);
-    let endDate;
-    const isCurrentMarketDay = calendar.isMarketDay(end);
-    const isWithinHours = isWithinMarketHours(end, intraday_reporting);
-    const minutes = nyEndDate.getUTCHours() * 60 + nyEndDate.getUTCMinutes();
-    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-    if (isCurrentMarketDay) {
-        if (minutes < marketStartMinutes) {
-            // Before market open - use previous day's close
-            const lastMarketDay = calendar.getPreviousMarketDay(end);
-            const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
-            endDate = dayEnd;
-        }
-        else if (isWithinHours) {
-            // During market hours - use current time
-            endDate = end;
-        }
-        else {
-            // After market close - use today's close
-            const { end: dayEnd } = getDayBoundaries(end, intraday_reporting);
-            endDate = dayEnd;
-        }
-    }
-    else {
-        // Not a market day - use previous market day's close
-        const lastMarketDay = calendar.getPreviousMarketDay(end);
-        const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
-        endDate = dayEnd;
-    }
-    // Calculate start date
-    const periodStartDate = calculatePeriodStartDate(endDate, period);
-    const { start: dayStart } = getDayBoundaries(periodStartDate, intraday_reporting);
-    if (endDate.getTime() < dayStart.getTime()) {
-        throw new Error('Start date cannot be after end date');
-    }
-    return {
-        start: formatDate(dayStart, outputFormat),
-        end: formatDate(endDate, outputFormat),
-    };
-}
-// Market status
-/**
- * Returns the current market status for a given date.
- * @param date - Date object (default: now)
- * @returns MarketStatus object
- */
-function getMarketStatusImpl(date = new Date()) {
-    const calendar = new MarketCalendar();
-    const nyDate = toNYTime(date);
-    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
-    const isMarketDay = calendar.isMarketDay(date);
-    const isEarlyCloseDay = calendar.isEarlyCloseDay(date);
-    const extendedStartMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
-    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-    const earlyMarketEndMinutes = MARKET_CONFIG.TIMES.EARLY_MARKET_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_MARKET_END.minute;
-    let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-    let extendedEndMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
-    if (isEarlyCloseDay) {
-        marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-        extendedEndMinutes =
-            MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
-    }
-    let status;
-    let nextStatus;
-    let nextStatusTime;
-    let marketPeriod;
-    if (!isMarketDay) {
-        status = 'closed';
-        nextStatus = 'extended hours';
-        marketPeriod = 'closed';
-        const nextMarketDay = calendar.getNextMarketDay(date);
-        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
-    }
-    else if (minutes < extendedStartMinutes) {
-        status = 'closed';
-        nextStatus = 'extended hours';
-        marketPeriod = 'closed';
-        nextStatusTime = getDayBoundaries(date, 'extended_hours').start;
-    }
-    else if (minutes < marketStartMinutes) {
-        status = 'extended hours';
-        nextStatus = 'open';
-        marketPeriod = 'preMarket';
-        nextStatusTime = getDayBoundaries(date, 'market_hours').start;
-    }
-    else if (minutes < marketCloseMinutes) {
-        status = 'open';
-        nextStatus = 'extended hours';
-        marketPeriod = minutes < earlyMarketEndMinutes ? 'earlyMarket' : 'regularMarket';
-        nextStatusTime = getDayBoundaries(date, 'market_hours').end;
-    }
-    else if (minutes < extendedEndMinutes) {
-        status = 'extended hours';
-        nextStatus = 'closed';
-        marketPeriod = 'afterMarket';
-        nextStatusTime = getDayBoundaries(date, 'extended_hours').end;
-    }
-    else {
-        status = 'closed';
-        nextStatus = 'extended hours';
-        marketPeriod = 'closed';
-        const nextMarketDay = calendar.getNextMarketDay(date);
-        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
-    }
-    // I think using nyDate here may be wrong - should use current time? i.e. date.getTime()
-    const nextStatusTimeDifference = nextStatusTime.getTime() - date.getTime();
-    return {
-        time: date,
-        timeString: formatNYLocale(nyDate),
-        status,
-        nextStatus,
-        marketPeriod,
-        nextStatusTime,
-        nextStatusTimeDifference,
-        nextStatusTimeString: formatNYLocale(nextStatusTime),
-    };
-}
-// API exports
-/**
- * Returns market open/close times for a given date.
- * @param options - { date?: Date }
- * @returns MarketOpenCloseResult
- */
-function getMarketOpenClose(options = {}) {
-    const { date = new Date() } = options;
-    return getMarketTimes(date);
-}
-/**
- * Returns the start and end dates for a market time period as Date objects.
- * @param params - MarketTimeParams
- * @returns Object with start and end Date
- */
-function getStartAndEndDates(params = {}) {
-    const { start, end } = getMarketTimePeriod(params);
-    return {
-        start: typeof start === 'string' || typeof start === 'number' ? new Date(start) : start,
-        end: typeof end === 'string' || typeof end === 'number' ? new Date(end) : end,
-    };
-}
 /**
  * Returns the last full trading date as a Date object.
  */
@@ -712,43 +365,6 @@ function getStartAndEndDates(params = {}) {
 function getLastFullTradingDate(currentDate = new Date()) {
     return getLastFullTradingDateImpl(currentDate);
 }
-/**
- * Returns the next market day after the reference date.
- * @param referenceDate - Date object (default: now)
- * @returns Object with date, yyyymmdd string, and ISO string
- */
-function getNextMarketDay({ referenceDate } = {}) {
-    const calendar = new MarketCalendar();
-    const startDate = referenceDate ?? new Date();
-    // Find the next trading day (UTC Date object)
-    const nextDate = calendar.getNextMarketDay(startDate);
-    // Convert to NY time before extracting Y-M-D parts
-    const nyNext = toNYTime(nextDate);
-    const yyyymmdd = `${nyNext.getUTCFullYear()}-${String(nyNext.getUTCMonth() + 1).padStart(2, '0')}-${String(nyNext.getUTCDate()).padStart(2, '0')}`;
-    return {
-        date: nextDate, // raw Date, unchanged
-        yyyymmdd, // correct trading date string
-        dateISOString: nextDate.toISOString(),
-    };
-}
-/**
- * Returns the previous market day before the reference date.
- * @param referenceDate - Date object (default: now)
- * @returns Object with date, yyyymmdd string, and ISO string
- */
-function getPreviousMarketDay({ referenceDate } = {}) {
-    const calendar = new MarketCalendar();
-    const startDate = referenceDate || new Date();
-    const prevDate = calendar.getPreviousMarketDay(startDate);
-    // convert to NY time first
-    const nyPrev = toNYTime(prevDate); // ← already in this file
-    const yyyymmdd = `${nyPrev.getUTCFullYear()}-${String(nyPrev.getUTCMonth() + 1).padStart(2, '0')}-${String(nyPrev.getUTCDate()).padStart(2, '0')}`;
-    return {
-        date: prevDate,
-        yyyymmdd,
-        dateISOString: prevDate.toISOString(),
-    };
-}
 /**
  * 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
@@ -764,656 +380,25 @@ function getTradingDate(time) {
     const nyDate = toNYTime(date);
     return `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
 }
-/**
- * Returns the NY timezone offset string for a given date.
- * @param date - Date object (default: now)
- * @returns '-04:00' for EDT, '-05:00' for EST
- */
-function getNYTimeZone(date) {
-    const offset = getNYOffset(date || new Date());
-    return offset === -4 ? '-04:00' : '-05:00';
-}
-/**
- * Returns the regular market open and close Date objects for a given trading day string in the
- * America/New_York timezone (NYSE/NASDAQ calendar).
- *
- * This helper is convenient when you have a calendar date like '2025-10-03' and want the precise
- * open and close Date values for that day. It internally:
- * - Determines the NY offset for the day using `getNYTimeZone()`.
- * - Anchors a noon-time Date on that day in NY time to avoid DST edge cases.
- * - Verifies the day is a market day via `isMarketDay()`.
- * - Fetches the open/close times via `getMarketOpenClose()`.
- *
- * Throws if the provided day is not a market day or if open/close times are unavailable.
- *
- * See also:
- * - `getNYTimeZone(date?: Date)`
- * - `isMarketDay(date: Date)`
- * - `getMarketOpenClose(options?: { date?: Date })`
- *
- * @param dateStr - Trading day string in 'YYYY-MM-DD' format (Eastern Time date)
- * @returns An object containing `{ open: Date; close: Date }`
- * @example
- * ```ts
- * const { open, close } = disco.time.getOpenCloseForTradingDay('2025-10-03');
- * ```
- */
-function getOpenCloseForTradingDay(dateStr) {
-    // Build a UTC midnight anchor for the date, then derive the NY offset for that day.
-    const utcAnchor = new Date(`${dateStr}T00:00:00Z`);
-    const nyOffset = getNYTimeZone(utcAnchor); // '-04:00' | '-05:00'
-    // Create a NY-local noon date to avoid DST midnight transitions.
-    const nyNoon = new Date(`${dateStr}T12:00:00${nyOffset}`);
-    if (!isMarketDay(nyNoon)) {
-        throw new Error(`Not a market day in ET: ${dateStr}`);
-    }
-    const { open, close } = getMarketOpenClose({ date: nyNoon });
-    if (!open || !close) {
-        throw new Error(`No market times available for ${dateStr}`);
-    }
-    return { open, close };
-}
-/**
- * Converts any date to the market time zone (America/New_York, Eastern Time).
- * Returns a new Date object representing the same moment in time but adjusted to NY/Eastern timezone.
- * Automatically handles daylight saving time transitions (EST/EDT).
- *
- * @param date - Date object to convert to market time zone
- * @returns Date object in NY/Eastern time zone
- * @example
- * ```typescript
- * const utcDate = new Date('2024-01-15T15:30:00Z'); // 3:30 PM UTC
- * const nyDate = convertDateToMarketTimeZone(utcDate); // 10:30 AM EST (winter) or 11:30 AM EDT (summer)
- * ```
- */
-function convertDateToMarketTimeZone(date) {
-    return toNYTime(date);
-}
-/**
- * Returns the current market status for a given date.
- * @param options - { date?: Date }
- * @returns MarketStatus object
- */
-function getMarketStatus(options = {}) {
-    const { date = new Date() } = options;
-    return getMarketStatusImpl(date);
-}
-/**
- * Checks if a date is a market day.
- * @param date - Date object
- * @returns true if market day, false otherwise
- */
-function isMarketDay(date) {
-    const calendar = new MarketCalendar();
-    return calendar.isMarketDay(date);
-}
-/**
- * Returns full trading days from market open to market close.
- * endDate is always the most recent market close (previous day's close if before open, today's close if after open).
- * days: 1 or not specified = that day's open; 2 = previous market day's open, etc.
- */
-/**
- * Returns full trading days from market open to market close.
- * @param options - { endDate?: Date, days?: number }
- * @returns Object with startDate and endDate
- */
-function getTradingStartAndEndDates(options = {}) {
-    const { endDate = new Date(), days = 1 } = options;
-    const calendar = new MarketCalendar();
-    // Find the most recent market close
-    let endMarketDay = endDate;
-    const nyEnd = toNYTime(endDate);
-    const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-    const marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-    const minutes = nyEnd.getUTCHours() * 60 + nyEnd.getUTCMinutes();
-    if (!calendar.isMarketDay(endDate) ||
-        minutes < marketOpenMinutes ||
-        (minutes >= marketOpenMinutes && minutes < marketCloseMinutes)) {
-        // Before market open, not a market day, or during market hours: use previous market day
-        endMarketDay = calendar.getPreviousMarketDay(endDate);
-    }
-    else {
-        // After market close: use today
-        endMarketDay = endDate;
-    }
-    // Get market close for endMarketDay
-    const endClose = getMarketOpenClose({ date: endMarketDay }).close;
-    // Find start market day by iterating back over market days
-    let startMarketDay = endMarketDay;
-    let count = Math.max(1, days);
-    for (let i = 1; i < count; i++) {
-        startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
-    }
-    // If days > 1, we need to go back (days-1) market days from endMarketDay
-    if (days > 1) {
-        startMarketDay = endMarketDay;
-        for (let i = 1; i < days; i++) {
-            startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
-        }
-    }
-    const startOpen = getMarketOpenClose({ date: startMarketDay }).open;
-    return { startDate: startOpen, endDate: endClose };
-}
-/**
- * Counts trading time between two dates (passed as standard Date objects), excluding weekends and holidays, and closed market hours, using other functions in this library.
- *
- * This function calculates the actual trading time between two dates by:
- * 1. Iterating through each calendar day between startDate and endDate (inclusive)
- * 2. For each day that is a market day (not weekend/holiday), getting market open/close times
- * 3. Calculating the overlap between the time range and market hours for that day
- * 4. Summing up all the trading minutes across all days
- *
- * The function automatically handles:
- * - Weekends (Saturday/Sunday) - skipped entirely
- * - Market holidays - skipped entirely
- * - Early close days (e.g. day before holidays) - uses early close time
- * - Times outside market hours - only counts time within 9:30am-4pm ET (or early close)
- *
- * Examples:
- * - 12pm to 3:30pm same day = 3.5 hours = 210 minutes = 0.54 days
- * - 9:30am to 4pm same day = 6.5 hours = 390 minutes = 1 day
- * - Friday 2pm to Monday 2pm = 6.5 hours (Friday 2pm-4pm + Monday 9:30am-2pm)
- *
- * @param startDate - Start date/time
- * @param endDate - End date/time (default: now)
- * @returns Object containing:
- *   - days: Trading time as fraction of full trading days (6.5 hours = 1 day)
- *   - hours: Trading time in hours
- *   - minutes: Trading time in minutes
- */
-function countTradingDays(startDate, endDate = new Date()) {
-    const calendar = new MarketCalendar();
-    // Ensure start is before end
-    if (startDate.getTime() > endDate.getTime()) {
-        throw new Error('Start date must be before end date');
-    }
-    let totalMinutes = 0;
-    // Get the NY dates for iteration
-    const startNY = toNYTime(startDate);
-    const endNY = toNYTime(endDate);
-    // Create date at start of first day (in NY time)
-    const currentNY = new Date(Date.UTC(startNY.getUTCFullYear(), startNY.getUTCMonth(), startNY.getUTCDate(), 0, 0, 0, 0));
-    // Iterate through each calendar day
-    while (currentNY.getTime() <= endNY.getTime()) {
-        const currentUTC = fromNYTime(currentNY);
-        // Check if this is a market day
-        if (calendar.isMarketDay(currentUTC)) {
-            // Get market hours for this day
-            const marketTimes = getMarketTimes(currentUTC);
-            if (marketTimes.marketOpen && marketTimes.open && marketTimes.close) {
-                // Calculate the overlap between our time range and market hours
-                const dayStart = Math.max(startDate.getTime(), marketTimes.open.getTime());
-                const dayEnd = Math.min(endDate.getTime(), marketTimes.close.getTime());
-                // Only count if there's actual overlap
-                if (dayStart < dayEnd) {
-                    totalMinutes += (dayEnd - dayStart) / (1000 * 60);
-                }
-            }
-        }
-        // Move to next day
-        currentNY.setUTCDate(currentNY.getUTCDate() + 1);
-    }
-    // Convert to days, hours, minutes
-    const MINUTES_PER_TRADING_DAY = 390; // 6.5 hours
-    const days = totalMinutes / MINUTES_PER_TRADING_DAY;
-    const hours = totalMinutes / 60;
-    const minutes = totalMinutes;
-    return {
-        days: Math.round(days * 1000) / 1000, // Round to 3 decimal places
-        hours: Math.round(hours * 100) / 100, // Round to 2 decimal places
-        minutes: Math.round(minutes),
-    };
-}
-/**
- * Returns the trading day N days back from a reference date, along with its market open time.
- * Trading days are counted as full or half trading days (days that end count as 1 full trading day).
- *
- * @param options - Object with:
- *   - referenceDate: Date to count back from (default: now)
- *   - days: Number of trading days to go back (must be >= 1)
- * @returns Object containing:
- *   - date: Trading date in YYYY-MM-DD format
- *   - marketOpenISO: Market open time as ISO string (e.g., "2025-11-15T13:30:00.000Z")
- *   - unixTimestamp: Market open time as Unix timestamp in seconds
- * @example
- * ```typescript
- * // Get the trading day 1 day back (most recent full trading day)
- * const result = getTradingDaysBack({ days: 1 });
- * console.log(result.date); // "2025-11-01"
- * console.log(result.marketOpenISO); // "2025-11-01T13:30:00.000Z"
- * console.log(result.unixTimestamp); // 1730466600
- *
- * // Get the trading day 5 days back from a specific date
- * const result2 = getTradingDaysBack({
- *   referenceDate: new Date('2025-11-15T12:00:00-05:00'),
- *   days: 5
- * });
- * ```
- */
-function getTradingDaysBack(options) {
-    const calendar = new MarketCalendar();
-    const refDate = options.referenceDate || new Date();
-    const daysBack = options.days;
-    if (daysBack < 1) {
-        throw new Error('days must be at least 1');
-    }
-    // Start from the last full trading date relative to reference
-    let targetDate = getLastFullTradingDateImpl(refDate);
-    // Go back the specified number of days (we're already at day 1, so go back days-1 more)
-    for (let i = 1; i < daysBack; i++) {
-        targetDate = calendar.getPreviousMarketDay(targetDate);
-    }
-    // Get market open time for this date
-    const marketTimes = getMarketTimes(targetDate);
-    if (!marketTimes.open) {
-        throw new Error(`No market open time for target date`);
-    }
-    // Format the date string (YYYY-MM-DD) in NY time
-    const nyDate = toNYTime(marketTimes.open);
-    const dateStr = `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
-    const marketOpenISO = marketTimes.open.toISOString();
-    const unixTimestamp = Math.floor(marketTimes.open.getTime() / 1000);
-    return {
-        date: dateStr,
-        marketOpenISO,
-        unixTimestamp,
-    };
-}
-// Export MARKET_TIMES for compatibility
-const MARKET_TIMES = {
-    TIMEZONE: MARKET_CONFIG.TIMEZONE,
-    PRE: {
-        START: { HOUR: 4, MINUTE: 0, MINUTES: 240 },
-        END: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
-    },
-    EARLY_MORNING: {
-        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
-        END: { HOUR: 10, MINUTE: 0, MINUTES: 600 },
-    },
-    EARLY_CLOSE_BEFORE_HOLIDAY: {
-        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
-        END: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
-    },
-    EARLY_EXTENDED_BEFORE_HOLIDAY: {
-        START: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
-        END: { HOUR: 17, MINUTE: 0, MINUTES: 1020 },
-    },
-    REGULAR: {
-        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
-        END: { HOUR: 16, MINUTE: 0, MINUTES: 960 },
-    },
-    EXTENDED: {
-        START: { HOUR: 4, MINUTE: 0, MINUTES: 240 },
-        END: { HOUR: 20, MINUTE: 0, MINUTES: 1200 },
-    },
-};
 
-// format-tools.ts
-/**
- * Capitalizes the first letter of a string
- * @param {string} str - The string to capitalize
- * @returns {string} The capitalized string, or original value if not a string
- * @example
- * capitalize('hello') // 'Hello'
- * capitalize(123) // 123
- */
-function capFirstLetter(str) {
-    if (!str || typeof str !== 'string')
-        return str;
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
-/**
- * Formats a number as US currency
- * @param {number} value - The number to format
- * @returns {string} The formatted currency string (e.g. '$1,234.56')
- * @example
- * formatCurrency(1234.56) // '$1,234.56'
- * formatCurrency(NaN) // '$0.00'
- */
-function formatCurrency(value) {
-    if (isNaN(value)) {
-        return '$0.00';
-    }
-    return new Intl.NumberFormat('en-US', {
-        style: 'currency',
-        currency: 'USD',
-    }).format(value);
-}
-/**
- * Formats a number with commas
- * @param {number} value - The number to format
- * @returns {string} The formatted number string (e.g. '1,234.56')
- * @example
- * formatNumber(1234.56) // '1,234.56'
- * formatNumber(NaN) // '0'
- */
-function formatNumber(value) {
-    if (isNaN(value)) {
-        return '0';
-    }
-    return new Intl.NumberFormat('en-US').format(value);
-}
-/**
- * Formats a number as a percentage
- * @param {number} value - The number to format (e.g. 0.75 for 75%)
- * @param {number} [decimalPlaces=2] - Number of decimal places to show
- * @returns {string} The formatted percentage string (e.g. '75.00%')
- * @example
- * formatPercentage(0.75) // '75.00%'
- * formatPercentage(0.753, 1) // '75.3%'
- */
-function formatPercentage(value, decimalPlaces = 2) {
-    if (isNaN(value)) {
-        return '0%';
-    }
-    return new Intl.NumberFormat('en-US', {
-        style: 'percent',
-        minimumFractionDigits: decimalPlaces,
-    }).format(value);
-}
-/**
- * Formats a Date object to Australian datetime format for Google Sheets
- * @param {Date} date - The date to format
- * @returns {string} The formatted datetime string in 'DD/MM/YYYY HH:MM:SS' format
- * @example
- * dateTimeForGS(new Date('2025-01-01T12:34:56')) // '01/01/2025 12:34:56'
- */
-function dateTimeForGS(date) {
-    return date
-        .toLocaleString('en-AU', {
-        day: '2-digit',
-        month: '2-digit',
-        year: 'numeric',
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-        hour12: false,
-    })
-        .replace(/\./g, '/');
-}
+/*
+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.
+*/
 
-/**
- * Type guard to check if a model is an OpenRouter model
- */
-function isOpenRouterModel(model) {
-    const openRouterModels = [
-        'openai/gpt-5',
-        'openai/gpt-5-mini',
-        'openai/gpt-5-nano',
-        'openai/gpt-5.1',
-        'openai/gpt-5.2',
-        'openai/gpt-5.2-pro',
-        'openai/gpt-5.1-codex',
-        'openai/gpt-5.1-codex-max',
-        'openai/gpt-oss-120b',
-        'z.ai/glm-4.5',
-        'z.ai/glm-4.5-air',
-        'google/gemini-2.5-flash',
-        'google/gemini-2.5-flash-lite',
-        'deepseek/deepseek-r1-0528',
-        'deepseek/deepseek-chat-v3-0324',
-    ];
-    return openRouterModels.includes(model);
+class Node {
+	value;
+	next;
+
+	constructor(value) {
+		this.value = value;
+	}
 }
 
-var Types = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    isOpenRouterModel: isOpenRouterModel
-});
-
-// Utility function for debug logging
-// Define the possible log types as a const array for better type inference
-/**
- * Debug logging utility that respects environment debug flags.
- * Logs messages to the console based on the specified log level.
- *
- * @param message - The message to log.
- * @param data - Optional data to log alongside the message. This can be any type of data.
- * @param type - Log level. One of: 'info' | 'warn' | 'error' | 'debug' | 'trace'. Defaults to 'info'.
- *
- * @example
- * logIfDebug("User login failed", { userId: 123 }, "error");
- * logIfDebug("Cache miss", undefined, "warn");
- * logIfDebug("Processing request", { requestId: "abc" }, "debug");
- */
-const logIfDebug = (message, data, type = 'info') => {
-    const prefix = `[DEBUG][${type.toUpperCase()}]`;
-    const formattedData = data !== undefined ? JSON.stringify(data, null, 2) : '';
-    switch (type) {
-        case 'error':
-            console.error(prefix, message, formattedData);
-            break;
-        case 'warn':
-            console.warn(prefix, message, formattedData);
-            break;
-        case 'debug':
-            console.debug(prefix, message, formattedData);
-            break;
-        case 'trace':
-            console.trace(prefix, message, formattedData);
-            break;
-        case 'info':
-        default:
-            console.info(prefix, message, formattedData);
-    }
-};
-/**
- * Masks the middle part of an API key, returning only the first 2 and last 2 characters.
- * If the API key is very short (<= 4 characters), it will be returned as is.
- *
- * @param keyValue - The API key to mask.
- * @returns The masked API key.
- *
- * @example
- * maskApiKey("12341239856677"); // Returns "12****77"
- */
-function maskApiKey(keyValue) {
-    if (keyValue.length <= 4) {
-        return keyValue;
-    }
-    const firstTwo = keyValue.slice(0, 2);
-    const lastTwo = keyValue.slice(-2);
-    return `${firstTwo}****${lastTwo}`;
-}
-/**
- * Hides (masks) the value of any query parameter that is "apiKey" (case-insensitive),
- * replacing the middle part with **** and keeping only the first 2 and last 2 characters.
- *
- * @param url - The URL containing the query parameters.
- * @returns The URL with the masked API key.
- *
- * @example
- * hideApiKeyFromurl("https://xxx.com/s/23/fdsa/?apiKey=12341239856677");
- * // Returns "https://xxx.com/s/23/fdsa/?apiKey=12****77"
- */
-function hideApiKeyFromurl(url) {
-    try {
-        const parsedUrl = new URL(url);
-        // We iterate over all search params and look for one named 'apikey' (case-insensitive)
-        for (const [key, value] of parsedUrl.searchParams.entries()) {
-            if (key.toLowerCase() === 'apikey') {
-                const masked = maskApiKey(value);
-                parsedUrl.searchParams.set(key, masked);
-            }
-        }
-        return parsedUrl.toString();
-    }
-    catch {
-        // If we can't parse it as a valid URL, just return the original string
-        return url;
-    }
-}
-/**
- * Extracts meaningful error information from various error types.
- * @param error - The error to analyze.
- * @param response - Optional response object for HTTP errors.
- * @returns Structured error details.
- */
-function extractErrorDetails(error, response) {
-    const errMsg = error instanceof Error ? error.message : String(error);
-    const errName = error instanceof Error ? error.name : 'Error';
-    if (errName === 'TypeError' && errMsg.includes('fetch')) {
-        return { type: 'NETWORK_ERROR', reason: 'Network connectivity issue', status: null };
-    }
-    if (errMsg.includes('HTTP error: 429')) {
-        const match = errMsg.match(/RATE_LIMIT: 429:(\d+)/);
-        const retryAfter = match ? parseInt(match[1]) : undefined;
-        return { type: 'RATE_LIMIT', reason: 'Rate limit exceeded', status: 429, retryAfter };
-    }
-    if (errMsg.includes('HTTP error: 401') || errMsg.includes('AUTH_ERROR: 401')) {
-        return { type: 'AUTH_ERROR', reason: 'Authentication failed - invalid API key', status: 401 };
-    }
-    if (errMsg.includes('HTTP error: 403') || errMsg.includes('AUTH_ERROR: 403')) {
-        return { type: 'AUTH_ERROR', reason: 'Access forbidden - insufficient permissions', status: 403 };
-    }
-    if (errMsg.includes('SERVER_ERROR:')) {
-        const status = parseInt(errMsg.split('SERVER_ERROR: ')[1]) || 500;
-        return { type: 'SERVER_ERROR', reason: `Server error (${status})`, status };
-    }
-    if (errMsg.includes('CLIENT_ERROR:')) {
-        const status = parseInt(errMsg.split('CLIENT_ERROR: ')[1]) || 400;
-        return { type: 'CLIENT_ERROR', reason: `Client error (${status})`, status };
-    }
-    return { type: 'UNKNOWN', reason: errMsg || 'Unknown error', status: null };
-}
-/**
- * Fetches a resource with intelligent retry logic for handling transient errors.
- * Features enhanced error logging, rate limit detection, and adaptive backoff.
- *
- * @param url - The URL to fetch.
- * @param options - Optional fetch options.
- * @param retries - The number of retry attempts. Defaults to 3.
- * @param initialBackoff - The initial backoff time in milliseconds. Defaults to 1000.
- * @returns A promise that resolves to the response.
- *
- * @throws Will throw an error if the fetch fails after the specified number of retries.
- */
-async function fetchWithRetry(url, options = {}, retries = 3, initialBackoff = 1000) {
-    let backoff = initialBackoff;
-    for (let attempt = 1; attempt <= retries; attempt++) {
-        try {
-            const response = await fetch(url, options);
-            if (!response.ok) {
-                // Enhanced HTTP error handling with specific error types
-                if (response.status === 429) {
-                    // Check for Retry-After header
-                    const retryAfter = response.headers.get('Retry-After');
-                    const retryDelay = retryAfter ? parseInt(retryAfter) * 1000 : null;
-                    throw new Error(`RATE_LIMIT: ${response.status}${retryDelay ? `:${retryDelay}` : ''}`);
-                }
-                if ([500, 502, 503, 504].includes(response.status)) {
-                    throw new Error(`SERVER_ERROR: ${response.status}`);
-                }
-                if ([401, 403].includes(response.status)) {
-                    throw new Error(`AUTH_ERROR: ${response.status}`);
-                }
-                if (response.status >= 400 && response.status < 500) {
-                    // Don't retry most 4xx client errors
-                    throw new Error(`CLIENT_ERROR: ${response.status}`);
-                }
-                throw new Error(`HTTP_ERROR: ${response.status}`);
-            }
-            return response;
-        }
-        catch (error) {
-            if (attempt === retries) {
-                throw error;
-            }
-            // Extract meaningful error information
-            const errorDetails = extractErrorDetails(error);
-            let adaptiveBackoff = backoff;
-            // Adaptive backoff based on error type
-            if (errorDetails.type === 'RATE_LIMIT') {
-                // Use Retry-After header if available, otherwise use minimum 5s for rate limits
-                if (errorDetails.retryAfter) {
-                    adaptiveBackoff = errorDetails.retryAfter;
-                }
-                else {
-                    adaptiveBackoff = Math.max(backoff, 5000);
-                }
-            }
-            else if (errorDetails.type === 'AUTH_ERROR') {
-                // Don't retry auth errors - fail fast
-                console.error(`Authentication error for ${hideApiKeyFromurl(url)}: ${errorDetails.reason}`, {
-                    attemptNumber: attempt,
-                    errorType: errorDetails.type,
-                    httpStatus: errorDetails.status,
-                    url: hideApiKeyFromurl(url),
-                    source: 'fetchWithRetry',
-                    timestamp: new Date().toISOString(),
-                });
-                throw error;
-            }
-            else if (errorDetails.type === 'CLIENT_ERROR') {
-                // Don't retry client errors (except 429 which is handled above)
-                console.error(`Client error for ${hideApiKeyFromurl(url)}: ${errorDetails.reason}`, {
-                    attemptNumber: attempt,
-                    errorType: errorDetails.type,
-                    httpStatus: errorDetails.status,
-                    url: hideApiKeyFromurl(url),
-                    source: 'fetchWithRetry',
-                    timestamp: new Date().toISOString(),
-                });
-                throw error;
-            }
-            // Enhanced error logging with structured data
-            console.warn(`Fetch attempt ${attempt} of ${retries} for ${hideApiKeyFromurl(url)} failed: ${errorDetails.reason}. Retrying in ${adaptiveBackoff}ms...`, {
-                attemptNumber: attempt,
-                totalRetries: retries,
-                errorType: errorDetails.type,
-                httpStatus: errorDetails.status,
-                retryDelay: adaptiveBackoff,
-                url: hideApiKeyFromurl(url),
-                source: 'fetchWithRetry',
-                timestamp: new Date().toISOString(),
-            });
-            await new Promise((resolve) => setTimeout(resolve, adaptiveBackoff));
-            backoff = Math.min(backoff * 2, 30000); // Cap at 30 seconds
-        }
-    }
-    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;
+class Queue {
+	#head;
+	#tail;
+	#size;
 
 	constructor() {
 		this.clear();
@@ -1583,473 +568,10 @@ function validateConcurrency(concurrency) {
  * Polygon.io calls
  **********************************************************************************/
 // Constants from environment variables
-const POLYGON_API_KEY = process.env.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}`);
-        }
-    });
-};
+pLimit(POLYGON_CONCURRENCY_LIMIT);
 
 /**
  * Polygon Indices API Implementation
@@ -2060,224 +582,7 @@ const fetchTrades = async (symbol, options) => {
 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,
-        };
-    });
-};
+pLimit(POLYGON_INDICES_CONCURRENCY_LIMIT);
 
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
     if (typeof state === "function" ? receiver !== state || true : !state.has(receiver))
@@ -7894,9 +6199,9 @@ function maybeParseResponse(response, params) {
             }),
         };
     }
-    return parseResponse$1(response, params);
+    return parseResponse(response, params);
 }
-function parseResponse$1(response, params) {
+function parseResponse(response, params) {
     const output = response.output.map((item) => {
         if (item.type === 'function_call') {
             return {
@@ -8328,7 +6633,7 @@ class Responses extends APIResource {
     parse(body, options) {
         return this._client.responses
             .create(body, options)
-            ._thenUnwrap((response) => parseResponse$1(response, body));
+            ._thenUnwrap((response) => parseResponse(response, body));
     }
     /**
      * Creates a model response stream
@@ -9326,2033 +7631,129 @@ class OpenAI {
         const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
         // Apply some jitter, take up to at most 25 percent of the retry time.
         const jitter = 1 - Math.random() * 0.25;
-        return sleepSeconds * jitter * 1000;
-    }
-    async buildRequest(inputOptions, { retryCount = 0 } = {}) {
-        const options = { ...inputOptions };
-        const { method, path, query, defaultBaseURL } = options;
-        const url = this.buildURL(path, query, defaultBaseURL);
-        if ('timeout' in options)
-            validatePositiveInteger('timeout', options.timeout);
-        options.timeout = options.timeout ?? this.timeout;
-        const { bodyHeaders, body } = this.buildBody({ options });
-        const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
-        const req = {
-            method,
-            headers: reqHeaders,
-            ...(options.signal && { signal: options.signal }),
-            ...(globalThis.ReadableStream &&
-                body instanceof globalThis.ReadableStream && { duplex: 'half' }),
-            ...(body && { body }),
-            ...(this.fetchOptions ?? {}),
-            ...(options.fetchOptions ?? {}),
-        };
-        return { req, url, timeout: options.timeout };
-    }
-    async buildHeaders({ options, method, bodyHeaders, retryCount, }) {
-        let idempotencyHeaders = {};
-        if (this.idempotencyHeader && method !== 'get') {
-            if (!options.idempotencyKey)
-                options.idempotencyKey = this.defaultIdempotencyKey();
-            idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
-        }
-        const headers = buildHeaders([
-            idempotencyHeaders,
-            {
-                Accept: 'application/json',
-                'User-Agent': this.getUserAgent(),
-                'X-Stainless-Retry-Count': String(retryCount),
-                ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
-                ...getPlatformHeaders(),
-                'OpenAI-Organization': this.organization,
-                'OpenAI-Project': this.project,
-            },
-            await this.authHeaders(options),
-            this._options.defaultHeaders,
-            bodyHeaders,
-            options.headers,
-        ]);
-        this.validateHeaders(headers);
-        return headers.values;
-    }
-    buildBody({ options: { body, headers: rawHeaders } }) {
-        if (!body) {
-            return { bodyHeaders: undefined, body: undefined };
-        }
-        const headers = buildHeaders([rawHeaders]);
-        if (
-        // Pass raw type verbatim
-        ArrayBuffer.isView(body) ||
-            body instanceof ArrayBuffer ||
-            body instanceof DataView ||
-            (typeof body === 'string' &&
-                // Preserve legacy string encoding behavior for now
-                headers.values.has('content-type')) ||
-            // `Blob` is superset of `File`
-            (globalThis.Blob && body instanceof globalThis.Blob) ||
-            // `FormData` -> `multipart/form-data`
-            body instanceof FormData ||
-            // `URLSearchParams` -> `application/x-www-form-urlencoded`
-            body instanceof URLSearchParams ||
-            // Send chunked stream (each chunk has own `length`)
-            (globalThis.ReadableStream && body instanceof globalThis.ReadableStream)) {
-            return { bodyHeaders: undefined, body: body };
-        }
-        else if (typeof body === 'object' &&
-            (Symbol.asyncIterator in body ||
-                (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))) {
-            return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
-        }
-        else {
-            return __classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, { body, headers });
-        }
-    }
-}
-_a = OpenAI, _OpenAI_encoder = new WeakMap(), _OpenAI_instances = new WeakSet(), _OpenAI_baseURLOverridden = function _OpenAI_baseURLOverridden() {
-    return this.baseURL !== 'https://api.openai.com/v1';
-};
-OpenAI.OpenAI = _a;
-OpenAI.DEFAULT_TIMEOUT = 600000; // 10 minutes
-OpenAI.OpenAIError = OpenAIError;
-OpenAI.APIError = APIError;
-OpenAI.APIConnectionError = APIConnectionError;
-OpenAI.APIConnectionTimeoutError = APIConnectionTimeoutError;
-OpenAI.APIUserAbortError = APIUserAbortError;
-OpenAI.NotFoundError = NotFoundError;
-OpenAI.ConflictError = ConflictError;
-OpenAI.RateLimitError = RateLimitError;
-OpenAI.BadRequestError = BadRequestError;
-OpenAI.AuthenticationError = AuthenticationError;
-OpenAI.InternalServerError = InternalServerError;
-OpenAI.PermissionDeniedError = PermissionDeniedError;
-OpenAI.UnprocessableEntityError = UnprocessableEntityError;
-OpenAI.InvalidWebhookSignatureError = InvalidWebhookSignatureError;
-OpenAI.toFile = toFile;
-OpenAI.Completions = Completions;
-OpenAI.Chat = Chat;
-OpenAI.Embeddings = Embeddings;
-OpenAI.Files = Files$1;
-OpenAI.Images = Images;
-OpenAI.Audio = Audio;
-OpenAI.Moderations = Moderations;
-OpenAI.Models = Models;
-OpenAI.FineTuning = FineTuning;
-OpenAI.Graders = Graders;
-OpenAI.VectorStores = VectorStores;
-OpenAI.Webhooks = Webhooks;
-OpenAI.Beta = Beta;
-OpenAI.Batches = Batches;
-OpenAI.Uploads = Uploads;
-OpenAI.Responses = Responses;
-OpenAI.Realtime = Realtime;
-OpenAI.Conversations = Conversations;
-OpenAI.Evals = Evals;
-OpenAI.Containers = Containers;
-OpenAI.Videos = Videos;
-
-// llm-openai-config.ts
-const DEFAULT_MODEL = 'gpt-4.1-mini';
-/** Token costs in USD per 1M tokens. Last updated Feb 2025. */
-const openAiModelCosts = {
-    'gpt-4o': {
-        inputCost: 2.5 / 1_000_000,
-        outputCost: 10 / 1_000_000,
-    },
-    'gpt-4o-mini': {
-        inputCost: 0.15 / 1_000_000,
-        outputCost: 0.6 / 1_000_000,
-    },
-    'o1-mini': {
-        inputCost: 1.1 / 1_000_000,
-        outputCost: 4.4 / 1_000_000,
-    },
-    'o1': {
-        inputCost: 15 / 1_000_000,
-        outputCost: 60 / 1_000_000,
-    },
-    'o3-mini': {
-        inputCost: 1.1 / 1_000_000,
-        outputCost: 4.4 / 1_000_000,
-    },
-    'o3': {
-        inputCost: 2 / 1_000_000,
-        outputCost: 8 / 1_000_000,
-    },
-    'gpt-4.1': {
-        inputCost: 2 / 1_000_000,
-        outputCost: 8 / 1_000_000,
-    },
-    'gpt-4.1-mini': {
-        inputCost: 0.4 / 1_000_000,
-        outputCost: 1.6 / 1_000_000,
-    },
-    'gpt-4.1-nano': {
-        inputCost: 0.1 / 1_000_000,
-        outputCost: 0.4 / 1_000_000,
-    },
-    'gpt-5': {
-        inputCost: 1.25 / 1_000_000,
-        outputCost: 10 / 1_000_000,
-    },
-    'gpt-5-mini': {
-        inputCost: 0.25 / 1_000_000,
-        outputCost: 2 / 1_000_000,
-    },
-    'gpt-5-nano': {
-        inputCost: 0.05 / 1_000_000,
-        outputCost: 0.4 / 1_000_000,
-    },
-    'gpt-5.1': {
-        inputCost: 1.25 / 1_000_000,
-        outputCost: 10 / 1_000_000,
-    },
-    'gpt-5.2': {
-        inputCost: 1.5 / 1_000_000,
-        outputCost: 12 / 1_000_000,
-    },
-    'gpt-5.2-pro': {
-        inputCost: 3 / 1_000_000,
-        outputCost: 24 / 1_000_000,
-    },
-    'gpt-5.1-codex': {
-        inputCost: 1.1 / 1_000_000,
-        outputCost: 8.8 / 1_000_000,
-    },
-    'gpt-5.1-codex-max': {
-        inputCost: 1.8 / 1_000_000,
-        outputCost: 14.4 / 1_000_000,
-    },
-    'o4-mini': {
-        inputCost: 1.1 / 1_000_000,
-        outputCost: 4.4 / 1_000_000,
-    },
-};
-const deepseekModelCosts = {
-    'deepseek-chat': {
-        inputCost: 0.27 / 1_000_000, // $0.27 per 1M tokens (Cache miss price)
-        cacheHitCost: 0.07 / 1_000_000, // $0.07 per 1M tokens (Cache hit price)
-        outputCost: 1.1 / 1_000_000, // $1.10 per 1M tokens
-    },
-    'deepseek-reasoner': {
-        inputCost: 0.55 / 1_000_000, // $0.55 per 1M tokens (Cache miss price)
-        cacheHitCost: 0.14 / 1_000_000, // $0.14 per 1M tokens (Cache hit price)
-        outputCost: 2.19 / 1_000_000, // $2.19 per 1M tokens
-    },
-};
-/** Image generation costs in USD per image. Based on OpenAI pricing as of Feb 2025. */
-const openAiImageCosts = {
-    'gpt-image-1': 0.0075, // $0.0075 per image for gpt-image-1
-    'gpt-image-1.5': 0.0075, // Assumes parity pricing with gpt-image-1 until OpenAI publishes updated rates
-};
-/**
- * Calculates the cost of generating images using OpenAI's Images API.
- *
- * @param model The image generation model name.
- * @param imageCount The number of images generated.
- * @returns The cost of generating the images in USD.
- */
-function calculateImageCost(model, imageCount) {
-    if (typeof model !== 'string' || typeof imageCount !== 'number' || imageCount <= 0) {
-        return 0;
-    }
-    const costPerImage = openAiImageCosts[model];
-    if (!costPerImage)
-        return 0;
-    return imageCount * costPerImage;
-}
-/**
- * Calculates the cost of calling a language model in USD based on the provider and model, tokens, and given costs per 1M tokens.
- *
- * @param provider The provider of the language model. Supported providers are 'openai' and 'deepseek'.
- * @param model The name of the language model. Supported models are listed in the `openAiModelCosts` and `deepseekModelCosts` objects.
- * @param inputTokens The number of input tokens passed to the language model.
- * @param outputTokens The number of output tokens generated by the language model.
- * @param reasoningTokens The number of output tokens generated by the language model for reasoning. This is only used for Deepseek models.
- * @param cacheHitTokens The number of input tokens that were cache hits for Deepseek models.
- * @returns The cost of calling the language model in USD.
- */
-function calculateCost(provider, model, inputTokens, outputTokens, reasoningTokens, cacheHitTokens) {
-    if (typeof provider !== 'string' ||
-        typeof model !== 'string' ||
-        typeof inputTokens !== 'number' ||
-        typeof outputTokens !== 'number' ||
-        (reasoningTokens !== undefined && typeof reasoningTokens !== 'number') ||
-        (cacheHitTokens !== undefined && typeof cacheHitTokens !== 'number')) {
-        return 0;
-    }
-    const modelCosts = provider === 'deepseek' ? deepseekModelCosts[model] : openAiModelCosts[model];
-    if (!modelCosts)
-        return 0;
-    // Calculate input cost based on cache hit/miss for Deepseek
-    const inputCost = provider === 'deepseek' && modelCosts.cacheHitCost
-        ? (cacheHitTokens || 0) * modelCosts.cacheHitCost + (inputTokens - (cacheHitTokens || 0)) * modelCosts.inputCost
-        : inputTokens * modelCosts.inputCost;
-    const outputCost = outputTokens * modelCosts.outputCost;
-    const reasoningCost = (reasoningTokens || 0) * modelCosts.outputCost;
-    return inputCost + outputCost + reasoningCost;
-}
-
-/**
- * Fix a broken JSON string by attempting to extract and parse valid JSON content. This function is very lenient and will attempt to fix many types of JSON errors, including unbalanced brackets, missing or extra commas, improperly escaped $ signs, unquoted strings, trailing commas, missing closing brackets or braces, etc.
- * @param {string} jsonStr - The broken JSON string to fix
- * @returns {JsonValue} - The parsed JSON value
- */
-function fixBrokenJson(jsonStr) {
-    // Pre-process: Fix improperly escaped $ signs
-    jsonStr = jsonStr.replace(/\\\$/g, '$');
-    let index = 0;
-    function parse() {
-        const results = [];
-        while (index < jsonStr.length) {
-            skipWhitespace();
-            const value = parseValue();
-            if (value !== undefined) {
-                results.push(value);
-            }
-            else {
-                index++; // Skip invalid character
-            }
-        }
-        return results.length === 1 ? results[0] : results;
-    }
-    function parseValue() {
-        skipWhitespace();
-        const char = getChar();
-        if (!char)
-            return undefined;
-        if (char === '{')
-            return parseObject();
-        if (char === '[')
-            return parseArray();
-        if (char === '"' || char === "'")
-            return parseString();
-        if (char === 't' && jsonStr.slice(index, index + 4).toLowerCase() === 'true') {
-            index += 4;
-            return true;
-        }
-        if (char === 'f' && jsonStr.slice(index, index + 5).toLowerCase() === 'false') {
-            index += 5;
-            return false;
-        }
-        if (char === 'n' && jsonStr.slice(index, index + 4).toLowerCase() === 'null') {
-            index += 4;
-            return null;
-        }
-        if (/[a-zA-Z]/.test(char))
-            return parseString(); // Unquoted string
-        if (char === '-' || char === '.' || /\d/.test(char))
-            return parseNumber();
-        return undefined; // Unknown character
-    }
-    function parseObject() {
-        const obj = {};
-        index++; // Skip opening brace
-        skipWhitespace();
-        while (index < jsonStr.length && getChar() !== '}') {
-            skipWhitespace();
-            const key = parseString();
-            if (key === undefined) {
-                console.warn(`Expected key at position ${index}`);
-                index++;
-                continue;
-            }
-            skipWhitespace();
-            if (getChar() === ':') {
-                index++; // Skip colon
-            }
-            else {
-                console.warn(`Missing colon after key "${key}" at position ${index}`);
-            }
-            skipWhitespace();
-            const value = parseValue();
-            if (value === undefined) {
-                console.warn(`Expected value for key "${key}" at position ${index}`);
-                index++;
-                continue;
-            }
-            obj[key] = value;
-            skipWhitespace();
-            if (getChar() === ',') {
-                index++; // Skip comma
-            }
-            else {
-                break;
-            }
-            skipWhitespace();
-        }
-        if (getChar() === '}') {
-            index++; // Skip closing brace
-        }
-        else {
-            // Add a closing brace if it's missing
-            jsonStr += '}';
-        }
-        return obj;
-    }
-    function parseArray() {
-        const arr = [];
-        index++; // Skip opening bracket
-        skipWhitespace();
-        while (index < jsonStr.length && getChar() !== ']') {
-            const value = parseValue();
-            if (value === undefined) {
-                console.warn(`Expected value at position ${index}`);
-                index++;
-            }
-            else {
-                arr.push(value);
-            }
-            skipWhitespace();
-            if (getChar() === ',') {
-                index++; // Skip comma
-            }
-            else {
-                break;
-            }
-            skipWhitespace();
-        }
-        if (getChar() === ']') {
-            index++; // Skip closing bracket
-        }
-        else {
-            console.warn(`Missing closing bracket for array at position ${index}`);
-        }
-        return arr;
-    }
-    function parseString() {
-        const startChar = getChar();
-        let result = '';
-        let isQuoted = false;
-        let delimiter = '';
-        if (startChar === '"' || startChar === "'") {
-            isQuoted = true;
-            delimiter = startChar;
-            index++; // Skip opening quote
-        }
-        while (index < jsonStr.length) {
-            const char = getChar();
-            if (isQuoted) {
-                if (char === delimiter) {
-                    index++; // Skip closing quote
-                    return result;
-                }
-                else if (char === '\\') {
-                    index++;
-                    const escapeChar = getChar();
-                    const escapeSequences = {
-                        n: '\n',
-                        r: '\r',
-                        t: '\t',
-                        b: '\b',
-                        f: '\f',
-                        '\\': '\\',
-                        '/': '/',
-                        '"': '"',
-                        "'": "'",
-                        $: '$',
-                    };
-                    result += escapeSequences[escapeChar] || escapeChar;
-                }
-                else {
-                    result += char;
-                }
-                index++;
-            }
-            else {
-                if (/\s|,|}|]|\:/.test(char)) {
-                    return result;
-                }
-                else {
-                    result += char;
-                    index++;
-                }
-            }
-        }
-        if (isQuoted) {
-            console.warn(`Missing closing quote for string starting at position ${index}`);
-        }
-        return result;
-    }
-    function parseNumber() {
-        const numberRegex = /^-?\d+(\.\d+)?([eE][+-]?\d+)?/;
-        const match = numberRegex.exec(jsonStr.slice(index));
-        if (match) {
-            index += match[0].length;
-            return parseFloat(match[0]);
-        }
-        else {
-            console.warn(`Invalid number at position ${index}`);
-            index++;
-            return undefined;
-        }
-    }
-    function getChar() {
-        return jsonStr[index];
-    }
-    function skipWhitespace() {
-        while (/\s/.test(getChar()))
-            index++;
-    }
-    try {
-        return parse();
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        console.error(`Error parsing JSON at position ${index}: ${msg}`);
-        return null;
-    }
-}
-/**
- * Returns true if the given JSON string is valid, false otherwise.
- *
- * This function simply attempts to parse the given string as JSON and returns true if successful, or false if an error is thrown.
- *
- * @param {string} jsonString The JSON string to validate.
- * @returns {boolean} True if the JSON string is valid, false otherwise.
- */
-function isValidJson(jsonString) {
-    try {
-        JSON.parse(jsonString);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-let openai;
-/**
- * Initializes an instance of the OpenAI client, using the provided API key or the value of the OPENAI_API_KEY environment variable if no key is provided.
- * @param apiKey - the API key to use, or undefined to use the value of the OPENAI_API_KEY environment variable
- * @returns an instance of the OpenAI client
- * @throws an error if the API key is not provided and the OPENAI_API_KEY environment variable is not set
- */
-function initializeOpenAI(apiKey) {
-    const key = process.env.OPENAI_API_KEY;
-    if (!key) {
-        throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
-    }
-    return new OpenAI({
-        apiKey: key,
-        defaultHeaders: { 'User-Agent': 'My Server-side Application (compatible; OpenAI API Client)' },
-    });
-}
-/**
- * Fixes broken JSON by sending it to OpenAI to fix it.
- * If the model fails to return valid JSON, an error is thrown.
- * @param jsonStr - the broken JSON to fix
- * @param apiKey - the OpenAI API key to use, or undefined to use the value of the OPENAI_API_KEY environment variable
- * @returns the fixed JSON
- * @throws an error if the model fails to return valid JSON
- */
-async function fixJsonWithAI(jsonStr, apiKey) {
-    try {
-        if (!openai) {
-            openai = initializeOpenAI();
-        }
-        const completion = await openai.chat.completions.create({
-            model: DEFAULT_MODEL,
-            messages: [
-                {
-                    role: 'system',
-                    content: 'You are a JSON fixer. Return only valid JSON without any additional text or explanation.',
-                },
-                {
-                    role: 'user',
-                    content: `Fix this broken JSON:\n${jsonStr}`,
-                },
-            ],
-            response_format: { type: 'json_object' },
-        });
-        const fixedJson = completion.choices[0]?.message?.content;
-        if (fixedJson && isValidJson(fixedJson)) {
-            return JSON.parse(fixedJson);
-        }
-        throw new Error('Failed to fix JSON with AI');
-    }
-    catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
-        throw new Error(`Error fixing JSON with AI: ${errorMessage}`);
-    }
-}
-
-// llm-utils.ts
-function normalizeModelName(model) {
-    return model.replace(/_/g, '-').toLowerCase();
-}
-const CODE_BLOCK_TYPES = ['javascript', 'js', 'graphql', 'json', 'typescript', 'python', 'markdown', 'yaml'];
-/**
- * Tries to parse JSON from the given content string according to the specified
- * response format. If the response format is 'json' or a JSON schema object, it
- * will attempt to parse the content using multiple strategies. If any of the
- * strategies succeed, it will return the parsed JSON object. If all of them fail,
- * it will throw an error.
- *
- * @param content The content string to parse
- * @param responseFormat The desired format of the response
- * @returns The parsed JSON object or null if it fails
- */
-async function parseResponse(content, responseFormat) {
-    if (!content)
-        return null;
-    if (responseFormat === 'json' || (typeof responseFormat === 'object' && responseFormat?.type === 'json_schema')) {
-        let cleanedContent = content.trim();
-        let detectedType = null;
-        // Remove code block markers if present
-        const startsWithCodeBlock = CODE_BLOCK_TYPES.some((type) => {
-            if (cleanedContent.startsWith(`\`\`\`${type}`)) {
-                detectedType = type;
-                return true;
-            }
-            return false;
-        });
-        if (startsWithCodeBlock && cleanedContent.endsWith('```')) {
-            const firstLineEndIndex = cleanedContent.indexOf('\n');
-            if (firstLineEndIndex !== -1) {
-                cleanedContent = cleanedContent.slice(firstLineEndIndex + 1, -3).trim();
-                console.log(`Code block for type ${detectedType} detected and removed. Cleaned content: ${cleanedContent}`);
-            }
-        }
-        // Multiple JSON parsing strategies
-        const jsonParsingStrategies = [
-            // Strategy 1: Direct parsing
-            () => {
-                try {
-                    return JSON.parse(cleanedContent);
-                }
-                catch {
-                    return null;
-                }
-            },
-            // Strategy 2: Extract JSON from between first {} or []
-            () => {
-                const jsonMatch = cleanedContent.match(/[\{\[].*[\}\]]/s);
-                if (jsonMatch) {
-                    try {
-                        return JSON.parse(jsonMatch[0]);
-                    }
-                    catch {
-                        return null;
-                    }
-                }
-                return null;
-            },
-            // Strategy 3: Remove leading/trailing text and try parsing
-            () => {
-                const jsonMatch = cleanedContent.replace(/^[^{[]*|[^}\]]*$/g, '');
-                try {
-                    return JSON.parse(jsonMatch);
-                }
-                catch {
-                    return null;
-                }
-            },
-            // Strategy 4: Use fixJsonWithAI
-            () => {
-                return fixJsonWithAI(cleanedContent);
-            },
-            // Strategy 5: Use fixBrokenJson
-            () => {
-                return fixBrokenJson(cleanedContent);
-            },
-        ];
-        // Try each parsing strategy
-        for (const strategy of jsonParsingStrategies) {
-            const result = await strategy();
-            if (result !== null) {
-                return result;
-            }
-        }
-        // If all strategies fail, throw an error
-        console.error(`Failed to parse JSON from content: ${cleanedContent}. Original JSON: ${content}`);
-        throw new Error('Unable to parse JSON response');
-    }
-    else {
-        return content;
-    }
-}
-
-// llm-openai.ts
-const isSupportedModel = (model) => {
-    return [
-        'gpt-4o-mini',
-        'gpt-4o',
-        'o1-mini',
-        'o1',
-        'o3-mini',
-        'gpt-4.1',
-        'gpt-4.1-mini',
-        'gpt-4.1-nano',
-        'gpt-5',
-        'gpt-5-mini',
-        'gpt-5-nano',
-        'gpt-5.1',
-        'gpt-5.2',
-        'gpt-5.2-pro',
-        'gpt-5.1-codex',
-        'gpt-5.1-codex-max',
-        'o4-mini',
-        'o3',
-    ].includes(model);
-};
-/**
- * Checks if the given model supports the temperature parameter. Reasoning models (o1*, o3*, o4*) do not support temperature.
- * @param model The model to check.
- * @returns True if the model supports the temperature parameter, false otherwise.
- */
-function supportsTemperature(model) {
-    // Reasoning models don't support temperature
-    // GPT-5 models also do not support temperature
-    const reasoningAndGPT5Models = [
-        'o1',
-        'o1-mini',
-        'o3-mini',
-        'o4-mini',
-        'o3',
-        'gpt-5',
-        'gpt-5-mini',
-        'gpt-5-nano',
-        'gpt-5.1',
-        'gpt-5.2',
-        'gpt-5.2-pro',
-        'gpt-5.1-codex',
-        'gpt-5.1-codex-max',
-    ];
-    return !reasoningAndGPT5Models.includes(model);
-}
-/**
- * Checks if the given model is a reasoning model. Reasoning models have different tool choice constraints.
- * @param model The model to check.
- * @returns True if the model is a reasoning model, false otherwise.
- */
-function isReasoningModel(model) {
-    const reasoningModels = ['o1', 'o1-mini', 'o3-mini', 'o4-mini', 'o3'];
-    return reasoningModels.includes(model);
-}
-/**
- * Checks if the given model is a GPT-5 model. GPT-5 models don't support tool_choice other than 'auto'.
- * @param model The model to check.
- * @returns True if the model is a GPT-5 model, false otherwise.
- */
-function isGPT5Model(model) {
-    const gpt5Models = [
-        'gpt-5',
-        'gpt-5-mini',
-        'gpt-5-nano',
-        'gpt-5.1',
-        'gpt-5.2',
-        'gpt-5.2-pro',
-        'gpt-5.1-codex',
-        'gpt-5.1-codex-max',
-    ];
-    return gpt5Models.includes(model);
-}
-/**
- * Makes a call to OpenAI's Responses API for more advanced use cases with built-in tools.
- *
- * This function provides access to the Responses API which supports:
- * - Built-in tools (web search, file search, computer use, code interpreter, image generation)
- * - Background processing
- * - Conversation state management
- * - Reasoning support for o-series models
- *
- * @example
- * // Basic text response
- * const response = await makeResponsesAPICall('What is the weather like?');
- *
- * @example
- * // With web search tool
- * const response = await makeResponsesAPICall('Latest news about AI', {
- *   tools: [{ type: 'web_search_preview' }]
- * });
- *
- * @param input - The input content. Can be:
- * - A string for simple text prompts
- * - An array of input items for complex/multi-modal content
- * @param options - Configuration options for the Responses API
- * @returns Promise<LLMResponse<T>> - The response in the same format as makeLLMCall
- * @throws Error if the API call fails
- */
-const makeResponsesAPICall = async (input, options = {}) => {
-    const normalizedModel = normalizeModelName(options.model || DEFAULT_MODEL);
-    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-        throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
-    }
-    const openai = new OpenAI({
-        apiKey: apiKey,
-    });
-    // Remove apiKey from options before creating request body
-    const { apiKey: _, model: __, ...cleanOptions } = options;
-    const requestBody = {
-        model: normalizedModel,
-        input,
-        ...cleanOptions,
-    };
-    // Make the API call to the Responses endpoint
-    const response = await openai.responses.create(requestBody);
-    // Extract tool calls from the output
-    const toolCalls = response.output
-        ?.filter((item) => item.type === 'function_call')
-        .map((toolCall) => ({
-        id: toolCall.call_id,
-        type: 'function',
-        function: {
-            name: toolCall.name,
-            arguments: toolCall.arguments,
-        },
-    }));
-    // Extract code interpreter outputs if present
-    const codeInterpreterCalls = response.output?.filter((item) => item.type === 'code_interpreter_call');
-    let codeInterpreterOutputs = undefined;
-    if (codeInterpreterCalls && codeInterpreterCalls.length > 0) {
-        // Each code_interpreter_call has an 'outputs' array property
-        codeInterpreterOutputs = codeInterpreterCalls.flatMap((ci) => {
-            // Return outputs if present, otherwise empty array
-            if (ci.outputs)
-                return ci.outputs;
-            return [];
-        });
-    }
-    // Handle tool calls differently
-    if (toolCalls && toolCalls.length > 0) {
-        return {
-            response: {
-                tool_calls: toolCalls.map((tc) => ({
-                    id: tc.id,
-                    name: tc.function.name,
-                    arguments: JSON.parse(tc.function.arguments),
-                })),
-            },
-            usage: {
-                prompt_tokens: response.usage?.input_tokens || 0,
-                completion_tokens: response.usage?.output_tokens || 0,
-                reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0,
-                provider: 'openai',
-                model: normalizedModel,
-                cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0),
-            },
-            tool_calls: toolCalls,
-            ...(codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}),
-        };
-    }
-    // Extract text content from the response output
-    const textContent = response.output
-        ?.filter((item) => item.type === 'message')
-        .map((item) => item.content
-        .filter((content) => content.type === 'output_text')
-        .map((content) => content.text)
-        .join(''))
-        .join('') || '';
-    // Determine the format for parsing the response
-    let parsingFormat = 'text';
-    if (requestBody.text?.format?.type === 'json_object') {
-        parsingFormat = 'json';
-    }
-    // Handle regular responses
-    const parsedResponse = await parseResponse(textContent, parsingFormat);
-    if (parsedResponse === null) {
-        throw new Error('Failed to parse response from Responses API');
-    }
-    return {
-        response: parsedResponse,
-        usage: {
-            prompt_tokens: response.usage?.input_tokens || 0,
-            completion_tokens: response.usage?.output_tokens || 0,
-            reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0,
-            provider: 'openai',
-            model: normalizedModel,
-            cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0),
-        },
-        tool_calls: toolCalls,
-        ...(codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}),
-    };
-};
-/**
- * Makes a call to the OpenAI Responses API for advanced use cases with built-in tools.
- *
- * @param input The text prompt to send to the model (e.g., "What's in this image?")
- * @param options The options for the Responses API call, including optional image data and context.
- * @return A promise that resolves to the response from the Responses API.
- *
- * @example
- * // With conversation context
- * const response = await makeLLMCall("What did I ask about earlier?", {
- *   context: [
- *     { role: 'user', content: 'What is the capital of France?' },
- *     { role: 'assistant', content: 'The capital of France is Paris.' }
- *   ]
- * });
- */
-async function makeLLMCall(input, options = {}) {
-    const { apiKey, model = DEFAULT_MODEL, responseFormat = 'text', tools, useCodeInterpreter = false, useWebSearch = false, imageBase64, imageDetail = 'high', context, } = options;
-    // Validate model
-    const normalizedModel = normalizeModelName(model);
-    if (!isSupportedModel(normalizedModel)) {
-        throw new Error(`Unsupported model: ${normalizedModel}. Please use one of the supported models.`);
-    }
-    // Process input for conversation context and image analysis
-    let processedInput;
-    if (context && context.length > 0) {
-        // Build conversation array with context
-        const conversationMessages = [];
-        // Add context messages
-        for (const contextMsg of context) {
-            conversationMessages.push({
-                role: contextMsg.role,
-                content: contextMsg.content,
-                type: 'message',
-            });
-        }
-        // Add current input message
-        if (imageBase64) {
-            // Current message includes both text and image
-            conversationMessages.push({
-                role: 'user',
-                content: [
-                    { type: 'input_text', text: input },
-                    {
-                        type: 'input_image',
-                        detail: imageDetail,
-                        image_url: imageBase64.startsWith('data:') ? imageBase64 : `data:image/webp;base64,${imageBase64}`,
-                    },
-                ],
-                type: 'message',
-            });
-        }
-        else {
-            // Current message is just text
-            conversationMessages.push({
-                role: 'user',
-                content: input,
-                type: 'message',
-            });
-        }
-        processedInput = conversationMessages;
-    }
-    else if (imageBase64) {
-        // No context, but has image - use the original image logic
-        processedInput = [
-            {
-                role: 'user',
-                content: [
-                    { type: 'input_text', text: input },
-                    {
-                        type: 'input_image',
-                        detail: imageDetail,
-                        image_url: imageBase64.startsWith('data:') ? imageBase64 : `data:image/webp;base64,${imageBase64}`,
-                    },
-                ],
-                type: 'message',
-            },
-        ];
-    }
-    else {
-        // No context, no image - simple string input
-        processedInput = input;
-    }
-    // Build the options object for makeResponsesAPICall
-    let responsesOptions = {
-        apiKey,
-        model: normalizedModel,
-        parallel_tool_calls: false,
-        tools,
-    };
-    // Only include temperature if the model supports it
-    if (supportsTemperature(normalizedModel)) {
-        responsesOptions.temperature = 0.2;
-    }
-    // Configure response format
-    if (responseFormat === 'json') {
-        responsesOptions.text = { format: { type: 'json_object' } };
-    }
-    // Configure built-in tools
-    if (useCodeInterpreter) {
-        responsesOptions.tools = [{ type: 'code_interpreter', container: { type: 'auto' } }];
-        // For reasoning models, we can't force tool choice - they only support 'auto'
-        if (!isReasoningModel(normalizedModel)) {
-            responsesOptions.tool_choice = { type: 'code_interpreter' };
-        }
-        responsesOptions.include = ['code_interpreter_call.outputs'];
-    }
-    if (useWebSearch) {
-        responsesOptions.tools = [{ type: 'web_search_preview' }];
-        // For reasoning models and GPT-5 models, we can't force tool choice - they only support 'auto'
-        if (!isReasoningModel(normalizedModel) && !isGPT5Model(normalizedModel)) {
-            responsesOptions.tool_choice = { type: 'web_search_preview' };
-        }
-    }
-    return await makeResponsesAPICall(processedInput, responsesOptions);
-}
-
-const DEFAULT_IMAGE_MODEL = 'gpt-image-1.5';
-const resolveImageModel = (model) => model ?? DEFAULT_IMAGE_MODEL;
-const MULTIMODAL_VISION_MODELS = new Set([
-    'gpt-4o-mini',
-    'gpt-4o',
-    'gpt-5',
-    'gpt-5-mini',
-    'gpt-5-nano',
-    'gpt-5.1',
-    'gpt-5.2',
-    'gpt-5.2-pro',
-    'gpt-5.1-codex',
-    'gpt-5.1-codex-max',
-]);
-/**
- * Makes a call to the OpenAI Images API to generate images based on a text prompt.
- *
- * This function provides access to OpenAI's image generation capabilities with support for:
- * - Different output formats (JPEG, PNG, WebP)
- * - Various image sizes and quality settings
- * - Multiple image generation in a single call
- * - Base64 encoded image data return
- *
- * @example
- * // Basic image generation
- * const response = await makeImagesCall('A beautiful sunset over mountains');
- *
- * @example
- * // Custom options
- * const response = await makeImagesCall('A birthday cake', {
- *   size: '1024x1024',
- *   outputFormat: 'png',
- *   quality: 'high',
- *   count: 2
- * });
- *
- * @param prompt - The text prompt describing the image to generate
- * @param options - Configuration options for image generation. Includes:
- * - size: Image dimensions (uses OpenAI's size options)
- * - outputFormat: Image format ('jpeg', 'png', 'webp') - defaults to 'webp'
- * - compression: Compression level (number) - defaults to 50
- * - quality: Quality setting (uses OpenAI's quality options) - defaults to 'high'
- * - count: Number of images to generate - defaults to 1
- * - background: Background setting for transparency support
- * - moderation: Content moderation level
- * - apiKey: OpenAI API key (optional, falls back to environment variable)
- * @returns Promise<ImageResponseWithUsage> - The image generation response with cost information
- * @throws Error if the API call fails or invalid parameters are provided
- */
-async function makeImagesCall(prompt, options = {}) {
-    const { model, size = 'auto', outputFormat = 'webp', compression = 50, quality = 'high', count = 1, background = 'auto', moderation = 'auto', apiKey, visionModel, } = options;
-    const imageModel = resolveImageModel(model);
-    const supportedVisionModel = visionModel && MULTIMODAL_VISION_MODELS.has(visionModel) ? visionModel : undefined;
-    if (visionModel && !supportedVisionModel) {
-        console.warn(`Vision model ${visionModel} is not recognized as a multimodal OpenAI model. Ignoring for image usage metadata.`);
-    }
-    // Get API key
-    const effectiveApiKey = apiKey || process.env.OPENAI_API_KEY;
-    if (!effectiveApiKey) {
-        throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
-    }
-    // Validate inputs
-    if (!prompt || typeof prompt !== 'string') {
-        throw new Error('Prompt must be a non-empty string');
-    }
-    if (count && (count < 1 || count > 10)) {
-        throw new Error('Count must be between 1 and 10');
-    }
-    if (compression && (compression < 0 || compression > 100)) {
-        throw new Error('Compression must be between 0 and 100');
-    }
-    const openai = new OpenAI({
-        apiKey: effectiveApiKey,
-    });
-    // Build the request parameters using OpenAI's type
-    const requestParams = {
-        model: imageModel,
-        prompt,
-        n: count || 1,
-        size: size || 'auto',
-        quality: quality || 'auto',
-        background: background || 'auto',
-        moderation: moderation || 'auto',
-    };
-    // Add output format if specified
-    if (outputFormat) {
-        requestParams.output_format = outputFormat;
-    }
-    // Add compression if specified
-    if (compression !== undefined) {
-        requestParams.output_compression = compression;
-    }
-    try {
-        // Make the API call
-        const response = await openai.images.generate(requestParams);
-        // Validate response
-        if (!response.data || response.data.length === 0) {
-            throw new Error('No images returned from OpenAI Images API');
-        }
-        // Calculate cost
-        const cost = calculateImageCost(imageModel, count || 1);
-        // Return the response with enhanced usage information
-        const enhancedResponse = {
-            ...response,
-            usage: {
-                // OpenAI Images response may not include usage details per image; preserve if present
-                ...(response.usage ?? {
-                    input_tokens: 0,
-                    input_tokens_details: { image_tokens: 0, text_tokens: 0 },
-                    output_tokens: 0,
-                    total_tokens: 0,
-                }),
-                provider: 'openai',
-                model: imageModel,
-                cost,
-                ...(supportedVisionModel ? { visionModel: supportedVisionModel } : {}),
-            },
-        };
-        return enhancedResponse;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        throw new Error(`OpenAI Images API call failed: ${message}`);
-    }
-}
-
-/**
- * Default options for Deepseek API calls
- */
-const DEFAULT_DEEPSEEK_OPTIONS = {
-    defaultModel: 'deepseek-chat',
-};
-/**
- * Checks if the given model is a supported Deepseek model
- * @param model The model to check
- * @returns True if the model is supported, false otherwise
- */
-const isSupportedDeepseekModel = (model) => {
-    return ['deepseek-chat', 'deepseek-reasoner'].includes(model);
-};
-/**
- * Checks if the given Deepseek model supports JSON output format
- * @param model The model to check
- * @returns True if JSON output is supported, false otherwise
- */
-const supportsJsonOutput = (model) => {
-    return model === 'deepseek-chat';
-};
-/**
- * Checks if the given Deepseek model supports tool calling
- * @param model The model to check
- * @returns True if tool calling is supported, false otherwise
- */
-const supportsToolCalling = (model) => {
-    return model === 'deepseek-chat';
-};
-/**
- * Gets the appropriate response format option for Deepseek API
- *
- * @param responseFormat The desired response format
- * @param model The model being used
- * @returns Object representing the Deepseek response format option
- */
-function getDeepseekResponseFormatOption(responseFormat, model) {
-    // Check if the model supports JSON output
-    if (responseFormat !== 'text' && !supportsJsonOutput(model)) {
-        console.warn(`Model ${model} does not support JSON output. Using text format instead.`);
-        return { type: 'text' };
-    }
-    if (responseFormat === 'text') {
-        return { type: 'text' };
-    }
-    if (responseFormat === 'json' || (typeof responseFormat === 'object' && responseFormat.type === 'json_schema')) {
-        return { type: 'json_object' };
-    }
-    return { type: 'text' };
-}
-/**
- * Creates a completion using the Deepseek API
- *
- * @param content The content to pass to the API
- * @param responseFormat The desired format of the response
- * @param options Additional options for the API call
- * @returns Promise resolving to the API response
- */
-async function createDeepseekCompletion(content, responseFormat, options = {}) {
-    // Extract the model or use default
-    const modelOption = options.model || DEFAULT_DEEPSEEK_OPTIONS.defaultModel;
-    const normalizedModel = normalizeModelName(modelOption);
-    // Validate model
-    if (!isSupportedDeepseekModel(normalizedModel)) {
-        throw new Error(`Unsupported Deepseek model: ${normalizedModel}. Please use 'deepseek-chat' or 'deepseek-reasoner'.`);
-    }
-    // Check if tools are requested with a model that doesn't support them
-    if (options.tools && options.tools.length > 0 && !supportsToolCalling(normalizedModel)) {
-        throw new Error(`Model ${normalizedModel} does not support tool calling.`);
-    }
-    const apiKey = options.apiKey || process.env.DEEPSEEK_API_KEY;
-    if (!apiKey) {
-        throw new Error('Deepseek API key is not provided and DEEPSEEK_API_KEY environment variable is not set');
-    }
-    // Initialize OpenAI client with Deepseek API URL
-    const openai = new OpenAI({
-        apiKey,
-        baseURL: 'https://api.deepseek.com',
-    });
-    const messages = [];
-    // Add system message with developer prompt if present
-    if (options.developerPrompt) {
-        messages.push({
-            role: 'system',
-            content: options.developerPrompt,
-        });
-    }
-    // Add context if present
-    if (options.context) {
-        messages.push(...options.context);
-    }
-    // Add user content
-    if (typeof content === 'string') {
-        messages.push({
-            role: 'user',
-            content,
-        });
-    }
-    else {
-        messages.push({
-            role: 'user',
-            content,
-        });
-    }
-    // If JSON response format, include a hint in the system prompt
-    if ((responseFormat === 'json' || (typeof responseFormat === 'object' && responseFormat.type === 'json_schema'))
-        && supportsJsonOutput(normalizedModel)) {
-        // If there's no system message yet, add one
-        if (!messages.some(m => m.role === 'system')) {
-            messages.unshift({
-                role: 'system',
-                content: 'Please respond in valid JSON format.',
-            });
-        }
-        else {
-            // Append to existing system message
-            const systemMsgIndex = messages.findIndex(m => m.role === 'system');
-            const systemMsg = messages[systemMsgIndex];
-            if (typeof systemMsg.content === 'string') {
-                messages[systemMsgIndex] = {
-                    ...systemMsg,
-                    content: `${systemMsg.content} Please respond in valid JSON format.`,
-                };
-            }
-        }
-    }
-    const queryOptions = {
-        model: normalizedModel,
-        messages,
-        response_format: getDeepseekResponseFormatOption(responseFormat, normalizedModel),
-        temperature: options.temperature,
-        top_p: options.top_p,
-        frequency_penalty: options.frequency_penalty,
-        presence_penalty: options.presence_penalty,
-        max_tokens: options.max_completion_tokens,
-    };
-    // Only add tools if the model supports them
-    if (options.tools && supportsToolCalling(normalizedModel)) {
-        queryOptions.tools = options.tools;
-    }
-    try {
-        const completion = await openai.chat.completions.create(queryOptions);
-        return {
-            id: completion.id,
-            content: completion.choices[0]?.message?.content || '',
-            tool_calls: completion.choices[0]?.message?.tool_calls,
-            usage: completion.usage || {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                total_tokens: 0,
-            },
-            system_fingerprint: completion.system_fingerprint,
-            provider: 'deepseek',
-            model: normalizedModel,
-        };
-    }
-    catch (error) {
-        console.error('Error calling Deepseek API:', error);
-        throw error;
-    }
-}
-/**
- * Makes a call to the Deepseek AI API.
- *
- * @param content The content to pass to the LLM. Can be a string or an array of content parts.
- * @param responseFormat The format of the response. Defaults to 'json'.
- * @param options Configuration options including model ('deepseek-chat' or 'deepseek-reasoner'), tools, and apiKey.
- * @return A promise that resolves to the response from the Deepseek API.
- */
-const makeDeepseekCall = async (content, responseFormat = 'json', options = {}) => {
-    // Set default model if not provided
-    const mergedOptions = {
-        ...options,
-    };
-    if (!mergedOptions.model) {
-        mergedOptions.model = DEFAULT_DEEPSEEK_OPTIONS.defaultModel;
-    }
-    const modelName = normalizeModelName(mergedOptions.model);
-    // Check if the requested response format is compatible with the model
-    if (responseFormat !== 'text' && !supportsJsonOutput(modelName)) {
-        console.warn(`Model ${modelName} does not support JSON output. Will return error in the response.`);
-        return {
-            response: {
-                error: `Model ${modelName} does not support JSON output format.`
-            },
-            usage: {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                reasoning_tokens: 0,
-                provider: 'deepseek',
-                model: modelName,
-                cache_hit_tokens: 0,
-                cost: 0,
-            },
-            tool_calls: undefined,
-        };
-    }
-    // Check if tools are requested with a model that doesn't support them
-    if (mergedOptions.tools && mergedOptions.tools.length > 0 && !supportsToolCalling(modelName)) {
-        console.warn(`Model ${modelName} does not support tool calling. Will return error in the response.`);
-        return {
-            response: {
-                error: `Model ${modelName} does not support tool calling.`
-            },
-            usage: {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                reasoning_tokens: 0,
-                provider: 'deepseek',
-                model: modelName,
-                cache_hit_tokens: 0,
-                cost: 0,
-            },
-            tool_calls: undefined,
-        };
-    }
-    try {
-        const completion = await createDeepseekCompletion(content, responseFormat, mergedOptions);
-        // Handle tool calls similarly to OpenAI
-        if (completion.tool_calls && completion.tool_calls.length > 0) {
-            const fnCalls = completion.tool_calls
-                .filter((tc) => tc.type === 'function')
-                .map((tc) => ({
-                id: tc.id,
-                name: tc.function.name,
-                arguments: JSON.parse(tc.function.arguments),
-            }));
-            return {
-                response: { tool_calls: fnCalls },
-                usage: {
-                    prompt_tokens: completion.usage.prompt_tokens,
-                    completion_tokens: completion.usage.completion_tokens,
-                    reasoning_tokens: 0, // Deepseek doesn't provide reasoning tokens separately
-                    provider: 'deepseek',
-                    model: completion.model,
-                    cache_hit_tokens: 0, // Not provided directly in API response
-                    cost: calculateCost('deepseek', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, 0 // Cache hit tokens (not provided in the response)
-                    ),
-                },
-                tool_calls: completion.tool_calls,
-            };
-        }
-        // Handle regular responses
-        const parsedResponse = await parseResponse(completion.content, responseFormat);
-        if (parsedResponse === null) {
-            throw new Error('Failed to parse Deepseek response');
-        }
-        return {
-            response: parsedResponse,
-            usage: {
-                prompt_tokens: completion.usage.prompt_tokens,
-                completion_tokens: completion.usage.completion_tokens,
-                reasoning_tokens: 0, // Deepseek doesn't provide reasoning tokens separately
-                provider: 'deepseek',
-                model: completion.model,
-                cache_hit_tokens: 0, // Not provided directly in API response
-                cost: calculateCost('deepseek', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, 0 // Cache hit tokens (not provided in the response)
-                ),
-            },
-            tool_calls: completion.tool_calls,
-        };
-    }
-    catch (error) {
-        // If there's an error due to incompatible features, return a structured error
-        console.error('Error in Deepseek API call:', error);
-        return {
-            response: {
-                error: error instanceof Error ? error.message : 'Unknown error'
-            },
-            usage: {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                reasoning_tokens: 0,
-                provider: 'deepseek',
-                model: modelName,
-                cache_hit_tokens: 0,
-                cost: 0,
-            },
-            tool_calls: undefined,
-        };
-    }
-};
-
-// llm-openrouter.ts
-// Map our ContextMessage to OpenAI chat message
-function mapContextToMessages(context) {
-    return context.map((msg) => {
-        const role = msg.role === 'developer' ? 'system' : msg.role;
-        return { role, content: msg.content };
-    });
-}
-function toOpenRouterModel(model) {
-    if (model && model.includes('/'))
-        return model;
-    const base = normalizeModelName(model || DEFAULT_MODEL);
-    return `openai/${base}`;
-}
-// Normalize model name for pricing
-function normalizeModelForPricing(model) {
-    if (!model)
-        return { provider: 'openai', coreModel: normalizeModelName(DEFAULT_MODEL) };
-    const [maybeProvider, maybeModel] = model.includes('/') ? model.split('/') : ['openai', model];
-    const provider = (maybeProvider === 'deepseek' ? 'deepseek' : 'openai');
-    const coreModel = normalizeModelName(maybeModel || model);
-    return { provider, coreModel };
-}
-/**
- * Make a call through OpenRouter using the OpenAI Chat Completions-compatible API.
- * Supports: JSON mode, model selection, message history, and tools.
- */
-async function makeOpenRouterCall(input, options = {}) {
-    const { apiKey = process.env.OPENROUTER_API_KEY, model, responseFormat = 'text', tools, toolChoice, context, developerPrompt, temperature = 0.2, max_tokens, top_p, frequency_penalty, presence_penalty, stop, seed, referer = process.env.OPENROUTER_SITE_URL, title = process.env.OPENROUTER_SITE_NAME, } = options;
-    if (!apiKey) {
-        throw new Error('OpenRouter API key is not provided and OPENROUTER_API_KEY is not set');
-    }
-    const client = new OpenAI({
-        apiKey,
-        baseURL: 'https://openrouter.ai/api/v1',
-        defaultHeaders: {
-            ...(referer ? { 'HTTP-Referer': referer } : {}),
-            ...(title ? { 'X-Title': title } : {}),
-        },
-    });
-    const messages = [];
-    if (developerPrompt && developerPrompt.trim()) {
-        messages.push({ role: 'system', content: developerPrompt });
-    }
-    if (context && context.length > 0) {
-        messages.push(...mapContextToMessages(context));
-    }
-    messages.push({ role: 'user', content: input });
-    // Configure response_format
-    let response_format;
-    let parsingFormat = 'text';
-    if (responseFormat === 'json') {
-        response_format = { type: 'json_object' };
-        parsingFormat = 'json';
-    }
-    else if (typeof responseFormat === 'object') {
-        response_format = { type: 'json_object' };
-        parsingFormat = responseFormat;
-    }
-    const modelId = toOpenRouterModel(model);
-    const completion = await client.chat.completions.create({
-        model: modelId,
-        messages,
-        response_format,
-        tools,
-        tool_choice: toolChoice,
-        temperature,
-        max_tokens,
-        top_p,
-        frequency_penalty,
-        presence_penalty,
-        stop,
-        seed,
-    });
-    const choice = completion.choices && completion.choices.length > 0 ? completion.choices[0] : undefined;
-    const message = (choice && 'message' in choice ? choice.message : undefined);
-    const { provider: pricingProvider, coreModel } = normalizeModelForPricing(modelId);
-    const promptTokens = completion.usage?.prompt_tokens ?? 0;
-    const completionTokens = completion.usage?.completion_tokens ?? 0;
-    const cost = calculateCost(pricingProvider, coreModel, promptTokens, completionTokens);
-    // Tool calls branch: return empty string response and expose tool_calls on LLMResponse
-    const hasToolCalls = Array.isArray(message?.tool_calls) && message.tool_calls.length > 0;
-    if (hasToolCalls) {
-        const usageModel = isOpenRouterModel(modelId) ? modelId : DEFAULT_MODEL;
-        return {
-            response: '',
-            usage: {
-                prompt_tokens: promptTokens,
-                completion_tokens: completionTokens,
-                provider: 'openrouter',
-                model: usageModel,
-                cost,
-            },
-            tool_calls: message.tool_calls,
-        };
-    }
-    const rawText = typeof message?.content === 'string' ? message.content : '';
-    const parsed = await parseResponse(rawText, parsingFormat);
-    if (parsed === null) {
-        throw new Error('Failed to parse OpenRouter response');
-    }
-    // Ensure the model value conforms to LLMModel; otherwise fall back to DEFAULT_MODEL
-    const usageModel = isOpenRouterModel(modelId) ? modelId : DEFAULT_MODEL;
-    return {
-        response: parsed,
-        usage: {
-            prompt_tokens: promptTokens,
-            completion_tokens: completionTokens,
-            provider: 'openrouter',
-            model: usageModel,
-            cost,
-        },
-        ...(hasToolCalls ? { tool_calls: message.tool_calls } : {}),
-    };
-}
-
-/**
- * A class to measure performance of code execution.
- *
- * This utility records elapsed time during execution and provides a detailed
- * breakdown of elapsed time between checkpoints.
- *
- * Usage example:
- *   const timer = new PerformanceTimer();
- *   timer.checkpoint('Start Processing');
- *   // ... code for processing
- *   timer.checkpoint('After Task 1');
- *   // ... additional processing code
- *   timer.stop();
- *   console.log(timer.generateReport());
- *
- * Methods:
- *   - checkpoint(label: string): Record a timestamped checkpoint.
- *   - stop(): Stop the timer and compute the total elapsed time.
- *   - generateReport(): Return a performance report with total time and phases.
- *   - formatPerformanceReport(): Return a formatted string of the performance report.
- *   - getElapsedSeconds(): Get the current elapsed time in seconds.
- */
-class PerformanceTimer {
-    startTime;
-    checkpoints;
-    totalTime;
-    constructor() {
-        this.startTime = performance.now();
-        this.checkpoints = new Map();
-        this.totalTime = null;
-    }
-    /**
-     * Gets the current elapsed time in seconds.
-     *
-     * @returns The elapsed time in seconds with 3 decimal places of precision.
-     */
-    getElapsedSeconds() {
-        const elapsedMs = this.totalTime ?? (performance.now() - this.startTime);
-        return Number((elapsedMs / 1000).toFixed(3));
-    }
-    /**
-     * Records a checkpoint with the given label.
-     *
-     * @param label - A descriptive label for the checkpoint.
-     */
-    checkpoint(label) {
-        this.checkpoints.set(label, performance.now());
-    }
-    /**
-     * Stops the timer and sets the total elapsed time.
-     */
-    stop() {
-        this.totalTime = performance.now() - this.startTime;
-    }
-    /**
-     * Generates a performance report containing the total elapsed time and
-     * breakdown of phases between checkpoints.
-     *
-     * @returns A performance report object.
-     * @throws Error if the timer is not stopped before generating the report.
-     */
-    analyseReportData() {
-        if (this.totalTime === null) {
-            throw new Error('Timer must be stopped before generating report');
-        }
-        const report = {
-            totalTime: this.totalTime,
-            phases: []
-        };
-        let lastTime = this.startTime;
-        // Convert checkpoints to a sorted array by time
-        const sortedCheckpoints = Array.from(this.checkpoints.entries())
-            .sort((a, b) => a[1] - b[1]);
-        for (const [label, time] of sortedCheckpoints) {
-            const duration = time - lastTime;
-            if (duration < 0) {
-                throw new Error(`Negative duration detected for checkpoint: ${label}`);
-            }
-            report.phases.push({
-                label,
-                duration
-            });
-            lastTime = time;
-        }
-        // Add final phase from last checkpoint to stop
-        if (sortedCheckpoints.length > 0) {
-            const finalDuration = this.totalTime - lastTime;
-            report.phases.push({
-                label: 'Final Processing',
-                duration: Math.max(finalDuration, 0) // Prevent negative duration
-            });
-        }
-        return report;
-    }
-    /**
-     * Returns a formatted string of the performance report.
-     *
-     * @returns A string detailing the total execution time and phase breakdown.
-     */
-    generateReport() {
-        const report = this.analyseReportData();
-        // Format numbers with thousands separators and 2 decimal places
-        const formatNumber = (num) => num.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
-        // Calculate column widths
-        const maxLabelLength = Math.max(...report.phases.map(p => p.label.length), 30);
-        const maxDurationLength = Math.max(...report.phases.map(p => formatNumber(p.duration).length), 10);
-        // Create table header
-        let output = `╔${'═'.repeat(maxLabelLength + 2)}╦${'═'.repeat(maxDurationLength + 2)}╗\n`;
-        output += `║ ${'Phase'.padEnd(maxLabelLength)} ║ ${'Time (ms)'.padEnd(maxDurationLength)} ║\n`;
-        output += `╠${'═'.repeat(maxLabelLength + 2)}╬${'═'.repeat(maxDurationLength + 2)}╣\n`;
-        // Add table rows
-        report.phases.forEach(phase => {
-            output += `║ ${phase.label.padEnd(maxLabelLength)} ║ ${formatNumber(phase.duration).padStart(maxDurationLength)} ║\n`;
-        });
-        // Add table footer with total
-        output += `╠${'═'.repeat(maxLabelLength + 2)}╬${'═'.repeat(maxDurationLength + 2)}╣\n`;
-        output += `║ ${'Total'.padEnd(maxLabelLength)} ║ ${formatNumber(report.totalTime).padStart(maxDurationLength)} ║\n`;
-        output += `╚${'═'.repeat(maxLabelLength + 2)}╩${'═'.repeat(maxDurationLength + 2)}╝\n`;
-        return output;
-    }
-}
-
-/**
- * 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,
-        });
+        return sleepSeconds * jitter * 1000;
     }
-    // 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,
-        });
+    async buildRequest(inputOptions, { retryCount = 0 } = {}) {
+        const options = { ...inputOptions };
+        const { method, path, query, defaultBaseURL } = options;
+        const url = this.buildURL(path, query, defaultBaseURL);
+        if ('timeout' in options)
+            validatePositiveInteger('timeout', options.timeout);
+        options.timeout = options.timeout ?? this.timeout;
+        const { bodyHeaders, body } = this.buildBody({ options });
+        const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
+        const req = {
+            method,
+            headers: reqHeaders,
+            ...(options.signal && { signal: options.signal }),
+            ...(globalThis.ReadableStream &&
+                body instanceof globalThis.ReadableStream && { duplex: 'half' }),
+            ...(body && { body }),
+            ...(this.fetchOptions ?? {}),
+            ...(options.fetchOptions ?? {}),
+        };
+        return { req, url, timeout: options.timeout };
     }
-    // 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;
+    async buildHeaders({ options, method, bodyHeaders, retryCount, }) {
+        let idempotencyHeaders = {};
+        if (this.idempotencyHeader && method !== 'get') {
+            if (!options.idempotencyKey)
+                options.idempotencyKey = this.defaultIdempotencyKey();
+            idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
         }
-        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,
-        });
+        const headers = buildHeaders([
+            idempotencyHeaders,
+            {
+                Accept: 'application/json',
+                'User-Agent': this.getUserAgent(),
+                'X-Stainless-Retry-Count': String(retryCount),
+                ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
+                ...getPlatformHeaders(),
+                'OpenAI-Organization': this.organization,
+                'OpenAI-Project': this.project,
+            },
+            await this.authHeaders(options),
+            this._options.defaultHeaders,
+            bodyHeaders,
+            options.headers,
+        ]);
+        this.validateHeaders(headers);
+        return headers.values;
     }
-    // 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,
-            });
+    buildBody({ options: { body, headers: rawHeaders } }) {
+        if (!body) {
+            return { bodyHeaders: undefined, body: undefined };
         }
-    }
-    // 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 });
-                }
-            }
+        const headers = buildHeaders([rawHeaders]);
+        if (
+        // Pass raw type verbatim
+        ArrayBuffer.isView(body) ||
+            body instanceof ArrayBuffer ||
+            body instanceof DataView ||
+            (typeof body === 'string' &&
+                // Preserve legacy string encoding behavior for now
+                headers.values.has('content-type')) ||
+            // `Blob` is superset of `File`
+            (globalThis.Blob && body instanceof globalThis.Blob) ||
+            // `FormData` -> `multipart/form-data`
+            body instanceof FormData ||
+            // `URLSearchParams` -> `application/x-www-form-urlencoded`
+            body instanceof URLSearchParams ||
+            // Send chunked stream (each chunk has own `length`)
+            (globalThis.ReadableStream && body instanceof globalThis.ReadableStream)) {
+            return { bodyHeaders: undefined, body: body };
         }
-        // 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]];
-                }
-            }
+        else if (typeof body === 'object' &&
+            (Symbol.asyncIterator in body ||
+                (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))) {
+            return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
         }
-        // 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',
-            });
+        else {
+            return __classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, { body, headers });
         }
-        // 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;
 }
+_a = OpenAI, _OpenAI_encoder = new WeakMap(), _OpenAI_instances = new WeakSet(), _OpenAI_baseURLOverridden = function _OpenAI_baseURLOverridden() {
+    return this.baseURL !== 'https://api.openai.com/v1';
+};
+OpenAI.OpenAI = _a;
+OpenAI.DEFAULT_TIMEOUT = 600000; // 10 minutes
+OpenAI.OpenAIError = OpenAIError;
+OpenAI.APIError = APIError;
+OpenAI.APIConnectionError = APIConnectionError;
+OpenAI.APIConnectionTimeoutError = APIConnectionTimeoutError;
+OpenAI.APIUserAbortError = APIUserAbortError;
+OpenAI.NotFoundError = NotFoundError;
+OpenAI.ConflictError = ConflictError;
+OpenAI.RateLimitError = RateLimitError;
+OpenAI.BadRequestError = BadRequestError;
+OpenAI.AuthenticationError = AuthenticationError;
+OpenAI.InternalServerError = InternalServerError;
+OpenAI.PermissionDeniedError = PermissionDeniedError;
+OpenAI.UnprocessableEntityError = UnprocessableEntityError;
+OpenAI.InvalidWebhookSignatureError = InvalidWebhookSignatureError;
+OpenAI.toFile = toFile;
+OpenAI.Completions = Completions;
+OpenAI.Chat = Chat;
+OpenAI.Embeddings = Embeddings;
+OpenAI.Files = Files$1;
+OpenAI.Images = Images;
+OpenAI.Audio = Audio;
+OpenAI.Moderations = Moderations;
+OpenAI.Models = Models;
+OpenAI.FineTuning = FineTuning;
+OpenAI.Graders = Graders;
+OpenAI.VectorStores = VectorStores;
+OpenAI.Webhooks = Webhooks;
+OpenAI.Beta = Beta;
+OpenAI.Batches = Batches;
+OpenAI.Uploads = Uploads;
+OpenAI.Responses = Responses;
+OpenAI.Realtime = Realtime;
+OpenAI.Conversations = Conversations;
+OpenAI.Evals = Evals;
+OpenAI.Containers = Containers;
+OpenAI.Videos = Videos;
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -11374,6 +7775,7 @@ function requireConstants () {
 
 	constants = {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT: 30000,
 	  EMPTY_BUFFER: Buffer.alloc(0),
 	  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
 	  hasBlob,
@@ -14144,6 +10546,7 @@ function requireWebsocket () {
 
 	const {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT,
 	  EMPTY_BUFFER,
 	  GUID,
 	  kForOnEventAttribute,
@@ -14158,7 +10561,6 @@ function requireWebsocket () {
 	const { format, parse } = requireExtension();
 	const { toBuffer } = requireBufferUtil();
 
-	const closeTimeout = 30 * 1000;
 	const kAborted = Symbol('kAborted');
 	const protocolVersions = [8, 13];
 	const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
@@ -14214,6 +10616,7 @@ function requireWebsocket () {
 	      initAsClient(this, address, protocols, options);
 	    } else {
 	      this._autoPong = options.autoPong;
+	      this._closeTimeout = options.closeTimeout;
 	      this._isServer = true;
 	    }
 	  }
@@ -14755,6 +11158,8 @@ function requireWebsocket () {
 	 *     times in the same tick
 	 * @param {Boolean} [options.autoPong=true] Specifies whether or not to
 	 *     automatically send a pong in response to a ping
+	 * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to wait
+	 *     for the closing handshake to finish after `websocket.close()` is called
 	 * @param {Function} [options.finishRequest] A function which can be used to
 	 *     customize the headers of each http request before it is sent
 	 * @param {Boolean} [options.followRedirects=false] Whether or not to follow
@@ -14781,6 +11186,7 @@ function requireWebsocket () {
 	  const opts = {
 	    allowSynchronousEvents: true,
 	    autoPong: true,
+	    closeTimeout: CLOSE_TIMEOUT,
 	    protocolVersion: protocolVersions[1],
 	    maxPayload: 100 * 1024 * 1024,
 	    skipUTF8Validation: false,
@@ -14799,6 +11205,7 @@ function requireWebsocket () {
 	  };
 
 	  websocket._autoPong = opts.autoPong;
+	  websocket._closeTimeout = opts.closeTimeout;
 
 	  if (!protocolVersions.includes(opts.protocolVersion)) {
 	    throw new RangeError(
@@ -15416,7 +11823,7 @@ function requireWebsocket () {
 	function setCloseTimer(websocket) {
 	  websocket._closeTimer = setTimeout(
 	    websocket._socket.destroy.bind(websocket._socket),
-	    closeTimeout
+	    websocket._closeTimeout
 	  );
 	}
 
@@ -15434,23 +11841,23 @@ function requireWebsocket () {
 
 	  websocket._readyState = WebSocket.CLOSING;
 
-	  let chunk;
-
 	  //
 	  // The close frame might not have been received or the `'end'` event emitted,
 	  // for example, if the socket was destroyed due to an error. Ensure that the
 	  // `receiver` stream is closed after writing any remaining buffered data to
 	  // it. If the readable side of the socket is in flowing mode then there is no
-	  // buffered data as everything has been already written and `readable.read()`
-	  // will return `null`. If instead, the socket is paused, any possible buffered
-	  // data will be read as a single chunk.
+	  // buffered data as everything has been already written. If instead, the
+	  // socket is paused, any possible buffered data will be read as a single
+	  // chunk.
 	  //
 	  if (
 	    !this._readableState.endEmitted &&
 	    !websocket._closeFrameReceived &&
 	    !websocket._receiver._writableState.errorEmitted &&
-	    (chunk = websocket._socket.read()) !== null
+	    this._readableState.length !== 0
 	  ) {
+	    const chunk = this.read(this._readableState.length);
+
 	    websocket._receiver.write(chunk);
 	  }
 
@@ -15782,7 +12189,7 @@ function requireWebsocketServer () {
 	const PerMessageDeflate = requirePermessageDeflate();
 	const subprotocol = requireSubprotocol();
 	const WebSocket = requireWebsocket();
-	const { GUID, kWebSocket } = requireConstants();
+	const { CLOSE_TIMEOUT, GUID, kWebSocket } = requireConstants();
 
 	const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
 
@@ -15809,6 +12216,9 @@ function requireWebsocketServer () {
 	   *     pending connections
 	   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
 	   *     track clients
+	   * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
+	   *     wait for the closing handshake to finish after `websocket.close()` is
+	   *     called
 	   * @param {Function} [options.handleProtocols] A hook to handle protocols
 	   * @param {String} [options.host] The hostname where to bind the server
 	   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
@@ -15838,6 +12248,7 @@ function requireWebsocketServer () {
 	      perMessageDeflate: false,
 	      handleProtocols: null,
 	      clientTracking: true,
+	      closeTimeout: CLOSE_TIMEOUT,
 	      verifyClient: null,
 	      noServer: false,
 	      backlog: null, // use default (511 as implemented in net.js)
@@ -18457,6 +14868,7 @@ class AlpacaTradingAPI {
      * @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})`, {
@@ -18482,6 +14894,86 @@ class AlpacaTradingAPI {
             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;
+        }
+    }
     /**
      * 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
@@ -19466,226 +15958,73 @@ class AlpacaTradingAPI {
     }
 }
 
-const disco = {
-    types: Types,
-    alpaca: {
-        TradingAPI: AlpacaTradingAPI,
-        MarketDataAPI: AlpacaMarketDataAPI,
-    },
-    format: {
-        capFirstLetter: capFirstLetter,
-        currency: formatCurrency,
-        number: formatNumber,
-        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,
-        getMarketOpenClose: getMarketOpenClose,
-        getOpenCloseForTradingDay: getOpenCloseForTradingDay,
-        getLastFullTradingDate: getLastFullTradingDate,
-        getNextMarketDay: getNextMarketDay,
-        getPreviousMarketDay: getPreviousMarketDay,
-        getMarketTimePeriod: getMarketTimePeriod,
-        getMarketStatus: getMarketStatus,
-        getNYTimeZone: getNYTimeZone,
-        getTradingDate: getTradingDate,
-        getTradingStartAndEndDates: getTradingStartAndEndDates,
-        getTradingDaysBack: getTradingDaysBack,
-        isMarketDay: isMarketDay,
-        isWithinMarketHours: isWithinMarketHours,
-        countTradingDays: countTradingDays,
-        MARKET_TIMES: MARKET_TIMES,
-    },
-    utils: {
-        logIfDebug: logIfDebug,
-        fetchWithRetry: fetchWithRetry,
-        validatePolygonApiKey: validatePolygonApiKey,
-        Timer: PerformanceTimer,
-    },
-};
-
 // Test file for context functionality
-function testGetTradingDaysBack() {
-    const testCases = [
-        {
-            label: '1 day back from Friday after close',
-            referenceDate: '2025-07-11T18:00:00-04:00',
-            days: 1,
-            expected: {
-                date: '2025-07-11',
-                marketOpenISO: '2025-07-11T13:30:00.000Z',
-            },
-        },
-        {
-            label: '1 day back from Friday during market',
-            referenceDate: '2025-07-11T10:00:00-04:00',
-            days: 1,
-            expected: {
-                date: '2025-07-10',
-                marketOpenISO: '2025-07-10T13:30:00.000Z',
-            },
-        },
-        {
-            label: '2 days back from Friday after close',
-            referenceDate: '2025-07-11T18:00:00-04:00',
-            days: 2,
-            expected: {
-                date: '2025-07-10',
-                marketOpenISO: '2025-07-10T13:30:00.000Z',
-            },
-        },
-        {
-            label: '5 days back from Friday after close',
-            referenceDate: '2025-07-11T18:00:00-04:00',
-            days: 5,
-            expected: {
-                date: '2025-07-07',
-                marketOpenISO: '2025-07-07T13:30:00.000Z',
-            },
-        },
-        {
-            label: '6 days back from Friday after close (skips weekend and July 4)',
-            referenceDate: '2025-07-11T18:00:00-04:00',
-            days: 6,
-            expected: {
-                date: '2025-07-03',
-                marketOpenISO: '2025-07-03T13:30:00.000Z',
-            },
-        },
-        {
-            label: '1 day back from Monday after close (should be Monday)',
-            referenceDate: '2025-07-14T18:00:00-04:00',
-            days: 1,
-            expected: {
-                date: '2025-07-14',
-                marketOpenISO: '2025-07-14T13:30:00.000Z',
-            },
-        },
-        {
-            label: '1 day back from Saturday (should be Friday)',
-            referenceDate: '2025-07-12T12:00:00-04:00',
-            days: 1,
-            expected: {
-                date: '2025-07-11',
-                marketOpenISO: '2025-07-11T13:30:00.000Z',
-            },
-        },
-        {
-            label: '3 days back from Monday (skips weekend)',
-            referenceDate: '2025-07-14T18:00:00-04:00',
-            days: 3,
-            expected: {
-                date: '2025-07-10',
-                marketOpenISO: '2025-07-10T13:30:00.000Z',
-            },
-        },
-        {
-            label: '1 day back from day after holiday (July 7, after July 4)',
-            referenceDate: '2025-07-07T18:00:00-04:00',
-            days: 1,
-            expected: {
-                date: '2025-07-07',
-                marketOpenISO: '2025-07-07T13:30:00.000Z',
-            },
-        },
-        {
-            label: '2 days back from day after holiday (skips July 4)',
-            referenceDate: '2025-07-07T18:00:00-04:00',
-            days: 2,
-            expected: {
-                date: '2025-07-03',
-                marketOpenISO: '2025-07-03T13:30:00.000Z',
-            },
-        },
-        {
-            label: 'Early close day (July 3) - 1 day back from July 7',
-            referenceDate: '2025-07-07T18:00:00-04:00',
-            days: 2,
-            expected: {
-                date: '2025-07-03',
-                marketOpenISO: '2025-07-03T13:30:00.000Z', // Still opens at normal time
-            },
-        },
-    ];
-    console.log('\n=== Testing getTradingDaysBack ===\n');
-    for (const { label, referenceDate, days, expected } of testCases) {
-        try {
-            const refDate = new Date(referenceDate);
-            const result = disco.time.getTradingDaysBack({ referenceDate: refDate, days });
-            const dateMatches = result.date === expected.date;
-            const isoMatches = result.marketOpenISO === expected.marketOpenISO;
-            const unixValid = typeof result.unixTimestamp === 'number' && result.unixTimestamp > 0;
-            // Verify unix timestamp matches ISO
-            const dateFromUnix = new Date(result.unixTimestamp * 1000).toISOString();
-            const unixMatches = dateFromUnix === result.marketOpenISO;
-            const allPass = dateMatches && isoMatches && unixValid && unixMatches;
-            console.log(`${allPass ? '✅' : '❌'} ${label}`);
-            if (!allPass) {
-                console.log(`  Expected: ${JSON.stringify(expected)}`);
-                console.log(`  Got: ${JSON.stringify(result)}`);
-                if (!dateMatches)
-                    console.log(`  ❌ Date mismatch`);
-                if (!isoMatches)
-                    console.log(`  ❌ ISO mismatch`);
-                if (!unixValid)
-                    console.log(`  ❌ Unix timestamp invalid`);
-                if (!unixMatches)
-                    console.log(`  ❌ Unix timestamp doesn't match ISO`);
-            }
-        }
-        catch (error) {
-            console.log(`❌ ${label}`);
-            console.log(`  Error: ${error instanceof Error ? error.message : String(error)}`);
-        }
+async function testMOOAndMOCOrders() {
+    console.log('\n--- Testing Market on Open and Market on Close Orders ---');
+    console.log('NOTE: MOO orders must be submitted after 7:00pm ET and before 9:28am ET');
+    console.log('NOTE: MOC orders must be submitted after 7:00pm ET and before 3:50pm ET');
+    console.log('Orders submitted outside these windows will be rejected.\n');
+    const log = (message, options = { type: 'info' }) => {
+        log$1(message, { ...options, source: 'Test' });
+    };
+    if (!process.env.ALPACA_TRADING_API_KEY ||
+        !process.env.ALPACA_TRADING_SECRET_KEY ||
+        !process.env.ALPACA_TRADING_ACCOUNT_TYPE) {
+        log('Missing required ALPACA_TRADING_* environment variables', { type: 'error' });
+        return;
+    }
+    const credentials = {
+        accountName: 'Test Account',
+        apiKey: process.env.ALPACA_TRADING_API_KEY,
+        apiSecret: process.env.ALPACA_TRADING_SECRET_KEY,
+        type: process.env.ALPACA_TRADING_ACCOUNT_TYPE,
+        orderType: 'limit',
+        engine: 'quant',
+    };
+    const tradingAPI = AlpacaTradingAPI.getInstance(credentials);
+    try {
+        // Test creating a Market on Open order
+        log('Creating Market on Open (MOO) order for SPY...');
+        const mooOrder = await tradingAPI.createMOOOrder('SPY', 1, 'buy', 'buy_to_open', 'test-moo-order');
+        log(`MOO order created successfully: ${mooOrder.id}`);
+        log(`  Symbol: ${mooOrder.symbol}`);
+        log(`  Qty: ${mooOrder.qty}`);
+        log(`  Side: ${mooOrder.side}`);
+        log(`  Type: ${mooOrder.type}`);
+        log(`  Time in Force: ${mooOrder.time_in_force}`);
+        log(`  Status: ${mooOrder.status}`);
+        // Wait a moment before canceling
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        // Cancel the MOO order
+        log(`Canceling MOO order ${mooOrder.id}...`);
+        await tradingAPI.cancelOrder(mooOrder.id);
+        log(`MOO order canceled successfully`);
+        // Wait a moment before next order
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        // Test creating a Market on Close order
+        log('Creating Market on Close (MOC) order for SPY...');
+        const mocOrder = await tradingAPI.createMOCOrder('SPY', 1, 'sell', 'sell_to_open', 'test-moc-order');
+        log(`MOC order created successfully: ${mocOrder.id}`);
+        log(`  Symbol: ${mocOrder.symbol}`);
+        log(`  Qty: ${mocOrder.qty}`);
+        log(`  Side: ${mocOrder.side}`);
+        log(`  Type: ${mocOrder.type}`);
+        log(`  Time in Force: ${mocOrder.time_in_force}`);
+        log(`  Status: ${mocOrder.status}`);
+        // Wait a moment before canceling
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        // Cancel the MOC order
+        log(`Canceling MOC order ${mocOrder.id}...`);
+        await tradingAPI.cancelOrder(mocOrder.id);
+        log(`MOC order canceled successfully`);
+        log('\nMOO/MOC order test completed successfully');
+    }
+    catch (error) {
+        log(`Error during MOO/MOC order test: ${error instanceof Error ? error.message : 'Unknown error'}`, {
+            type: 'error',
+        });
+        throw error;
     }
-    const totalTests = testCases.length;
-    const passedTests = testCases.filter((tc) => {
-        try {
-            const refDate = new Date(tc.referenceDate);
-            const result = disco.time.getTradingDaysBack({ referenceDate: refDate, days: tc.days });
-            return result.date === tc.expected.date && result.marketOpenISO === tc.expected.marketOpenISO;
-        }
-        catch {
-            return false;
-        }
-    }).length;
-    console.log(`\n=== Summary: ${passedTests}/${totalTests} tests passed ===\n`);
 }
 // testGetTradingDate();
 // testGetTradingStartAndEndDates();
@@ -19704,5 +16043,6 @@ function testGetTradingDaysBack() {
 // testMarketDataAPI();
 // testLLM();
 // testImageModelDefaults();
-testGetTradingDaysBack();
+// testGetTradingDaysBack();
+testMOOAndMOCOrders();
 //# sourceMappingURL=test.js.map