@discomedia/utils 1.0.77 → 1.0.78

package/dist/test.mjs

@@ -0,0 +1,1977 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+
+// src/logging.ts
+function log(message, options = { source: "App", type: "info" }) {
+  const date = /* @__PURE__ */ new Date();
+  const timestamp = date.toLocaleString("en-US", { timeZone: "America/New_York" });
+  const account = options?.account;
+  const symbol = options?.symbol;
+  const logMessage = `[${timestamp}]${options?.source ? ` [${options.source}] ` : ""}${account ? ` [${account}] ` : ""}${symbol ? ` [${symbol}] ` : ""}${message}`;
+  if (options?.type === "error") {
+    console.error(logMessage);
+  } else if (options?.type === "warn") {
+    console.warn(logMessage);
+  } else {
+    console.log(logMessage);
+  }
+}
+var init_logging = __esm({
+  "src/logging.ts"() {
+    "use strict";
+  }
+});
+
+// src/market-hours.ts
+var marketHolidays, marketEarlyCloses;
+var init_market_hours = __esm({
+  "src/market-hours.ts"() {
+    "use strict";
+    marketHolidays = {
+      2024: {
+        "New Year's Day": { date: "2024-01-01" },
+        "Martin Luther King, Jr. Day": { date: "2024-01-15" },
+        "Washington's Birthday": { date: "2024-02-19" },
+        "Good Friday": { date: "2024-03-29" },
+        "Memorial Day": { date: "2024-05-27" },
+        "Juneteenth National Independence Day": { date: "2024-06-19" },
+        "Independence Day": { date: "2024-07-04" },
+        "Labor Day": { date: "2024-09-02" },
+        "Thanksgiving Day": { date: "2024-11-28" },
+        "Christmas Day": { date: "2024-12-25" }
+      },
+      2025: {
+        "New Year's Day": { date: "2025-01-01" },
+        "Jimmy Carter Memorial Day": { date: "2025-01-09" },
+        "Martin Luther King, Jr. Day": { date: "2025-01-20" },
+        "Washington's Birthday": { date: "2025-02-17" },
+        "Good Friday": { date: "2025-04-18" },
+        "Memorial Day": { date: "2025-05-26" },
+        "Juneteenth National Independence Day": { date: "2025-06-19" },
+        "Independence Day": { date: "2025-07-04" },
+        "Labor Day": { date: "2025-09-01" },
+        "Thanksgiving Day": { date: "2025-11-27" },
+        "Christmas Day": { date: "2025-12-25" }
+      },
+      2026: {
+        "New Year's Day": { date: "2026-01-01" },
+        "Martin Luther King, Jr. Day": { date: "2026-01-19" },
+        "Washington's Birthday": { date: "2026-02-16" },
+        "Good Friday": { date: "2026-04-03" },
+        "Memorial Day": { date: "2026-05-25" },
+        "Juneteenth National Independence Day": { date: "2026-06-19" },
+        "Independence Day": { date: "2026-07-03" },
+        "Labor Day": { date: "2026-09-07" },
+        "Thanksgiving Day": { date: "2026-11-26" },
+        "Christmas Day": { date: "2026-12-25" }
+      }
+    };
+    marketEarlyCloses = {
+      2024: {
+        "2024-07-03": {
+          date: "2024-07-03",
+          time: "13:00",
+          optionsTime: "13:15",
+          notes: "Market closes early on Wednesday, July 3, 2024 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time."
+        },
+        "2024-11-29": {
+          date: "2024-11-29",
+          time: "13:00",
+          optionsTime: "13:15",
+          notes: "Market closes early on Friday, November 29, 2024 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time."
+        },
+        "2024-12-24": {
+          date: "2024-12-24",
+          time: "13:00",
+          optionsTime: "13:15",
+          notes: "Market closes early on Tuesday, December 24, 2024 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time."
+        }
+      },
+      2025: {
+        "2025-07-03": {
+          date: "2025-07-03",
+          time: "13:00",
+          optionsTime: "13:15",
+          notes: "Market closes early on Thursday, July 3, 2025 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time."
+        },
+        "2025-11-28": {
+          date: "2025-11-28",
+          time: "13:00",
+          optionsTime: "13:15",
+          notes: "Market closes early on Friday, November 28, 2025 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time."
+        },
+        "2025-12-24": {
+          date: "2025-12-24",
+          time: "13:00",
+          optionsTime: "13:15",
+          notes: "Market closes early on Wednesday, December 24, 2025 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time."
+        }
+      },
+      2026: {
+        "2026-07-02": {
+          date: "2026-07-02",
+          time: "13:00",
+          optionsTime: "13:15",
+          notes: "Independence Day observed, market closes early at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time."
+        },
+        "2026-11-27": {
+          date: "2026-11-27",
+          time: "13:00",
+          optionsTime: "13:15",
+          notes: "Market closes early on Friday, November 27, 2026 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time."
+        },
+        "2026-12-24": {
+          date: "2026-12-24",
+          time: "13:00",
+          optionsTime: "13:15",
+          notes: "Market closes early on Thursday, December 24, 2026 at 1:00 p.m. (1:15 p.m. for eligible options). NYSE American Equities, NYSE Arca Equities, NYSE Chicago, and NYSE National late trading sessions will close at 5:00 p.m. Eastern Time."
+        }
+      }
+    };
+  }
+});
+
+// src/market-time.ts
+function getNYOffset(date) {
+  const year = date.getUTCFullYear();
+  const dstStart = getNthWeekdayOfMonth(year, 3, 0, 2);
+  const dstEnd = getNthWeekdayOfMonth(year, 11, 0, 1);
+  const utcTime = date.getTime();
+  if (utcTime >= dstStart.getTime() && utcTime < dstEnd.getTime()) {
+    return MARKET_CONFIG.UTC_OFFSET_DST;
+  }
+  return MARKET_CONFIG.UTC_OFFSET_STANDARD;
+}
+function getNthWeekdayOfMonth(year, month, weekday, n) {
+  const firstDay = new Date(Date.UTC(year, month - 1, 1));
+  let count = 0;
+  for (let d = 1; d <= 31; d++) {
+    const date = new Date(Date.UTC(year, month - 1, d));
+    if (date.getUTCMonth() !== month - 1) break;
+    if (date.getUTCDay() === weekday) {
+      count++;
+      if (count === n) return date;
+    }
+  }
+  return new Date(Date.UTC(year, month - 1, 28));
+}
+function toNYTime(date) {
+  const offset = getNYOffset(date);
+  const utcMillis = date.getTime();
+  const nyMillis = utcMillis + offset * 60 * 60 * 1e3;
+  return new Date(nyMillis);
+}
+function fromNYTime(date) {
+  const offset = getNYOffset(date);
+  const nyMillis = date.getTime();
+  const utcMillis = nyMillis - offset * 60 * 60 * 1e3;
+  return new Date(utcMillis);
+}
+function getLastFullTradingDateImpl(currentDate = /* @__PURE__ */ new Date()) {
+  const calendar = new MarketCalendar();
+  const nyDate = toNYTime(currentDate);
+  const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+  const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+  let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+  if (calendar.isEarlyCloseDay(currentDate)) {
+    marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+  }
+  if (!calendar.isMarketDay(currentDate) || minutes < marketOpenMinutes || minutes >= marketOpenMinutes && minutes < marketCloseMinutes) {
+    const prevMarketDay = calendar.getPreviousMarketDay(currentDate);
+    let prevCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    if (calendar.isEarlyCloseDay(prevMarketDay)) {
+      prevCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+    }
+    const prevNYDate = toNYTime(prevMarketDay);
+    const year2 = prevNYDate.getUTCFullYear();
+    const month2 = prevNYDate.getUTCMonth();
+    const day2 = prevNYDate.getUTCDate();
+    const closeHour2 = Math.floor(prevCloseMinutes / 60);
+    const closeMinute2 = prevCloseMinutes % 60;
+    return fromNYTime(new Date(Date.UTC(year2, month2, day2, closeHour2, closeMinute2, 0, 0)));
+  }
+  const year = nyDate.getUTCFullYear();
+  const month = nyDate.getUTCMonth();
+  const day = nyDate.getUTCDate();
+  const closeHour = Math.floor(marketCloseMinutes / 60);
+  const closeMinute = marketCloseMinutes % 60;
+  return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
+}
+function getLastFullTradingDate(currentDate = /* @__PURE__ */ new Date()) {
+  return getLastFullTradingDateImpl(currentDate);
+}
+var MARKET_CONFIG, MarketCalendar, MARKET_TIMES;
+var init_market_time = __esm({
+  "src/market-time.ts"() {
+    "use strict";
+    init_logging();
+    init_market_hours();
+    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 }
+      }
+    };
+    MarketCalendar = class {
+      /**
+       * Checks if a date is a weekend in NY time.
+       * @param date - Date object
+       * @returns true if weekend, false otherwise
+       */
+      isWeekend(date) {
+        const day = toNYTime(date).getUTCDay();
+        return day === 0 || day === 6;
+      }
+      /**
+       * Checks if a date is a market holiday in NY time.
+       * @param date - Date object
+       * @returns true if holiday, false otherwise
+       */
+      isHoliday(date) {
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+        const yearHolidays = marketHolidays[year];
+        if (!yearHolidays) return false;
+        return Object.values(yearHolidays).some((holiday) => holiday.date === formattedDate);
+      }
+      /**
+       * Checks if a date is an early close day in NY time.
+       * @param date - Date object
+       * @returns true if early close, false otherwise
+       */
+      isEarlyCloseDay(date) {
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+        const yearEarlyCloses = marketEarlyCloses[year];
+        return yearEarlyCloses && yearEarlyCloses[formattedDate] !== void 0;
+      }
+      /**
+       * Gets the early close time (in minutes from midnight) for a given date.
+       * @param date - Date object
+       * @returns minutes from midnight or null
+       */
+      getEarlyCloseTime(date) {
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+        const yearEarlyCloses = marketEarlyCloses[year];
+        if (yearEarlyCloses && yearEarlyCloses[formattedDate]) {
+          const [hours, minutes] = yearEarlyCloses[formattedDate].time.split(":").map(Number);
+          return hours * 60 + minutes;
+        }
+        return null;
+      }
+      /**
+       * Checks if a date is a market day (not weekend or holiday).
+       * @param date - Date object
+       * @returns true if market day, false otherwise
+       */
+      isMarketDay(date) {
+        return !this.isWeekend(date) && !this.isHoliday(date);
+      }
+      /**
+       * Gets the next market day after the given date.
+       * @param date - Date object
+       * @returns Date object for next market day
+       */
+      getNextMarketDay(date) {
+        let nextDay = new Date(date.getTime() + 24 * 60 * 60 * 1e3);
+        while (!this.isMarketDay(nextDay)) {
+          nextDay = new Date(nextDay.getTime() + 24 * 60 * 60 * 1e3);
+        }
+        return nextDay;
+      }
+      /**
+       * Gets the previous market day before the given date.
+       * @param date - Date object
+       * @returns Date object for previous market day
+       */
+      getPreviousMarketDay(date) {
+        let prevDay = new Date(date.getTime() - 24 * 60 * 60 * 1e3);
+        while (!this.isMarketDay(prevDay)) {
+          prevDay = new Date(prevDay.getTime() - 24 * 60 * 60 * 1e3);
+        }
+        return prevDay;
+      }
+    };
+    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 }
+      }
+    };
+  }
+});
+
+// src/alpaca-market-data-api.ts
+import "dotenv/config";
+import { EventEmitter } from "events";
+import WebSocket from "ws";
+var DEBUG_LOGGING, log2, DEFAULT_ADJUSTMENT, DEFAULT_FEED, DEFAULT_CURRENCY, AlpacaMarketDataAPI, marketDataAPI;
+var init_alpaca_market_data_api = __esm({
+  "src/alpaca-market-data-api.ts"() {
+    "use strict";
+    init_logging();
+    init_market_time();
+    DEBUG_LOGGING = process.env["DEBUG"] === "true" || false;
+    log2 = (message, options = { type: "info" }) => {
+      if (!DEBUG_LOGGING && options.type === "debug") {
+        return;
+      }
+      log(message, { ...options, source: "AlpacaMarketDataAPI" });
+    };
+    DEFAULT_ADJUSTMENT = "all";
+    DEFAULT_FEED = "sip";
+    DEFAULT_CURRENCY = "USD";
+    AlpacaMarketDataAPI = class _AlpacaMarketDataAPI extends EventEmitter {
+      static instance;
+      headers;
+      dataURL;
+      apiURL;
+      v1beta1url;
+      v1beta3url;
+      stockStreamUrl = "wss://stream.data.alpaca.markets/v2/sip";
+      // production values
+      optionStreamUrl = "wss://stream.data.alpaca.markets/v1beta3/options";
+      // production values
+      stockWs = null;
+      optionWs = null;
+      stockSubscriptions = { trades: [], quotes: [], bars: [] };
+      optionSubscriptions = { trades: [], quotes: [], bars: [] };
+      autoReconnect = true;
+      stockReconnectAttempts = 0;
+      optionReconnectAttempts = 0;
+      stockReconnectTimeout = null;
+      optionReconnectTimeout = null;
+      setMode(mode = "production") {
+        if (mode === "sandbox") {
+          this.stockStreamUrl = "wss://stream.data.sandbox.alpaca.markets/v2/sip";
+          this.optionStreamUrl = "wss://stream.data.sandbox.alpaca.markets/v1beta3/options";
+        } else if (mode === "test") {
+          this.stockStreamUrl = "wss://stream.data.alpaca.markets/v2/test";
+          this.optionStreamUrl = "wss://stream.data.alpaca.markets/v1beta3/options";
+        } else {
+          this.stockStreamUrl = "wss://stream.data.alpaca.markets/v2/sip";
+          this.optionStreamUrl = "wss://stream.data.alpaca.markets/v1beta3/options";
+        }
+      }
+      getMode() {
+        if (this.stockStreamUrl.includes("sandbox")) {
+          return "sandbox";
+        } else if (this.stockStreamUrl.includes("test")) {
+          return "test";
+        } else {
+          return "production";
+        }
+      }
+      setAutoReconnect(enabled) {
+        this.autoReconnect = enabled;
+        log2(`Auto-reconnect ${enabled ? "enabled" : "disabled"}`);
+      }
+      getAutoReconnect() {
+        return this.autoReconnect;
+      }
+      constructor() {
+        super();
+        this.dataURL = "https://data.alpaca.markets/v2";
+        this.apiURL = process.env.ALPACA_ACCOUNT_TYPE === "PAPER" ? "https://paper-api.alpaca.markets/v2" : "https://api.alpaca.markets/v2";
+        this.v1beta1url = "https://data.alpaca.markets/v1beta1";
+        this.v1beta3url = "https://data.alpaca.markets/v1beta3";
+        this.setMode("production");
+        this.headers = {
+          "APCA-API-KEY-ID": process.env.ALPACA_API_KEY,
+          "APCA-API-SECRET-KEY": process.env.ALPACA_SECRET_KEY,
+          "Content-Type": "application/json"
+        };
+      }
+      static getInstance() {
+        if (!_AlpacaMarketDataAPI.instance) {
+          _AlpacaMarketDataAPI.instance = new _AlpacaMarketDataAPI();
+        }
+        return _AlpacaMarketDataAPI.instance;
+      }
+      getReconnectDelay(attempt) {
+        const delays = [0, 5e3, 1e4, 15e3, 6e4];
+        return attempt < delays.length ? delays[attempt] : 6e4;
+      }
+      scheduleReconnect(streamType) {
+        if (!this.autoReconnect) {
+          log2(`Auto-reconnect disabled, not reconnecting ${streamType} stream`);
+          return;
+        }
+        const attempts = streamType === "stock" ? this.stockReconnectAttempts : this.optionReconnectAttempts;
+        const delay = this.getReconnectDelay(attempts);
+        log2(`Scheduling ${streamType} stream reconnect (attempt ${attempts + 1}) in ${delay}ms`);
+        const timeout = setTimeout(() => {
+          log2(`Attempting to reconnect ${streamType} stream (attempt ${attempts + 1})`);
+          if (streamType === "stock") {
+            this.stockReconnectAttempts++;
+          } else {
+            this.optionReconnectAttempts++;
+          }
+          this.connect(streamType);
+        }, delay);
+        if (streamType === "stock") {
+          this.stockReconnectTimeout = timeout;
+        } else {
+          this.optionReconnectTimeout = timeout;
+        }
+      }
+      on(event, listener) {
+        return super.on(event, listener);
+      }
+      emit(event, ...args) {
+        return super.emit(event, ...args);
+      }
+      connect(streamType) {
+        const url = streamType === "stock" ? this.stockStreamUrl : this.optionStreamUrl;
+        const ws = new WebSocket(url);
+        if (streamType === "stock") {
+          this.stockWs = ws;
+        } else {
+          this.optionWs = ws;
+        }
+        ws.on("open", () => {
+          log2(`${streamType} stream connected`);
+          if (streamType === "stock") {
+            this.stockReconnectAttempts = 0;
+            if (this.stockReconnectTimeout) {
+              clearTimeout(this.stockReconnectTimeout);
+              this.stockReconnectTimeout = null;
+            }
+          } else {
+            this.optionReconnectAttempts = 0;
+            if (this.optionReconnectTimeout) {
+              clearTimeout(this.optionReconnectTimeout);
+              this.optionReconnectTimeout = null;
+            }
+          }
+          const authMessage = {
+            action: "auth",
+            key: process.env.ALPACA_API_KEY,
+            secret: process.env.ALPACA_SECRET_KEY
+          };
+          ws.send(JSON.stringify(authMessage));
+        });
+        ws.on("message", (data) => {
+          const messages = JSON.parse(data.toString());
+          for (const message of messages) {
+            if (message.T === "success" && message.msg === "authenticated") {
+              log2(`${streamType} stream authenticated`);
+              this.sendSubscription(streamType);
+            } else if (message.T === "error") {
+              log2(`${streamType} stream error: ${message.msg}`, { type: "error" });
+            } else if (message.S) {
+              super.emit(`${streamType}-${message.T}`, message);
+              super.emit(`${streamType}-data`, message);
+            }
+          }
+        });
+        ws.on("close", (code, reason) => {
+          const reasonStr = reason.toString() || "No reason provided";
+          const codeDesc = this.getCloseCodeDescription(code);
+          log2(`${streamType} stream disconnected - Code: ${code} (${codeDesc}), Reason: ${reasonStr}`, { type: "warn" });
+          if (streamType === "stock") {
+            this.stockWs = null;
+          } else {
+            this.optionWs = null;
+          }
+          this.scheduleReconnect(streamType);
+        });
+        ws.on("error", (error) => {
+          log2(`${streamType} stream error: ${error.message}`, { type: "error" });
+        });
+      }
+      getCloseCodeDescription(code) {
+        const codes = {
+          1e3: "Normal Closure",
+          1001: "Going Away",
+          1002: "Protocol Error",
+          1003: "Unsupported Data",
+          1005: "No Status Received",
+          1006: "Abnormal Closure",
+          1007: "Invalid Frame Payload Data",
+          1008: "Policy Violation",
+          1009: "Message Too Big",
+          1010: "Mandatory Extension",
+          1011: "Internal Server Error",
+          1012: "Service Restart",
+          1013: "Try Again Later",
+          1014: "Bad Gateway",
+          1015: "TLS Handshake"
+        };
+        return codes[code] || "Unknown";
+      }
+      sendSubscription(streamType) {
+        const ws = streamType === "stock" ? this.stockWs : this.optionWs;
+        const subscriptions = streamType === "stock" ? this.stockSubscriptions : this.optionSubscriptions;
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          const subMessagePayload = {};
+          if (subscriptions.trades.length > 0) {
+            subMessagePayload.trades = subscriptions.trades;
+          }
+          if (subscriptions.quotes.length > 0) {
+            subMessagePayload.quotes = subscriptions.quotes;
+          }
+          if (subscriptions.bars.length > 0) {
+            subMessagePayload.bars = subscriptions.bars;
+          }
+          if (Object.keys(subMessagePayload).length > 0) {
+            const subMessage = {
+              action: "subscribe",
+              ...subMessagePayload
+            };
+            ws.send(JSON.stringify(subMessage));
+          }
+        }
+      }
+      connectStockStream() {
+        if (!this.stockWs) {
+          this.connect("stock");
+        }
+      }
+      connectOptionStream() {
+        if (!this.optionWs) {
+          this.connect("option");
+        }
+      }
+      disconnectStockStream() {
+        if (this.stockReconnectTimeout) {
+          clearTimeout(this.stockReconnectTimeout);
+          this.stockReconnectTimeout = null;
+        }
+        this.stockReconnectAttempts = 0;
+        if (this.stockWs) {
+          this.stockWs.close();
+        }
+      }
+      disconnectOptionStream() {
+        if (this.optionReconnectTimeout) {
+          clearTimeout(this.optionReconnectTimeout);
+          this.optionReconnectTimeout = null;
+        }
+        this.optionReconnectAttempts = 0;
+        if (this.optionWs) {
+          this.optionWs.close();
+        }
+      }
+      subscribe(streamType, subscriptions) {
+        const currentSubscriptions = streamType === "stock" ? this.stockSubscriptions : this.optionSubscriptions;
+        Object.entries(subscriptions).forEach(([key, value]) => {
+          if (value) {
+            currentSubscriptions[key] = [.../* @__PURE__ */ new Set([...currentSubscriptions[key] || [], ...value])];
+          }
+        });
+        this.sendSubscription(streamType);
+      }
+      unsubscribe(streamType, subscriptions) {
+        const currentSubscriptions = streamType === "stock" ? this.stockSubscriptions : this.optionSubscriptions;
+        Object.entries(subscriptions).forEach(([key, value]) => {
+          if (value) {
+            currentSubscriptions[key] = (currentSubscriptions[key] || []).filter((s) => !value.includes(s));
+          }
+        });
+        const unsubMessage = {
+          action: "unsubscribe",
+          ...subscriptions
+        };
+        const ws = streamType === "stock" ? this.stockWs : this.optionWs;
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify(unsubMessage));
+        }
+      }
+      async makeRequest(endpoint, method = "GET", params, baseUrlName = "data") {
+        const baseUrl = baseUrlName === "data" ? this.dataURL : baseUrlName === "api" ? this.apiURL : baseUrlName === "v1beta1" ? this.v1beta1url : this.v1beta3url;
+        const url = new URL(`${baseUrl}${endpoint}`);
+        try {
+          if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+              if (Array.isArray(value)) {
+                url.searchParams.append(key, value.join(","));
+              } else if (value !== void 0) {
+                url.searchParams.append(key, value.toString());
+              }
+            });
+          }
+          const response = await fetch(url.toString(), {
+            method,
+            headers: this.headers
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            log2(`Market Data API error (${response.status}): ${errorText}`, { type: "error" });
+            throw new Error(`Market Data API error (${response.status}): ${errorText}`);
+          }
+          const data = await response.json();
+          return data;
+        } catch (err) {
+          const error = err;
+          log2(`Error in makeRequest: ${error.message}. Endpoint: ${endpoint}. Url: ${url.toString()}`, { type: "error" });
+          if (error instanceof TypeError) {
+            log2(`Network error details: ${error.stack}`, { type: "error" });
+          }
+          throw error;
+        }
+      }
+      /**
+       * Get historical OHLCV bars for specified symbols, including pre-market and post-market data
+       * Automatically handles pagination to fetch all available data
+       * @param params Parameters for historical bars request
+       * @returns Historical bars data with all pages combined
+       */
+      async getHistoricalBars(params) {
+        const symbols = params.symbols;
+        const symbolsStr = symbols.join(",");
+        let allBars = {};
+        let pageToken = null;
+        let hasMorePages = true;
+        let totalBarsCount = 0;
+        let pageCount = 0;
+        let currency = "";
+        symbols.forEach((symbol) => {
+          allBars[symbol] = [];
+        });
+        log2(
+          `Starting ${params.timeframe}bars fetch for ${symbols.length} symbols (${symbolsStr}), ${params.start || "no start"} to ${params.end || "no end"})`,
+          { symbol: symbolsStr }
+        );
+        while (hasMorePages) {
+          pageCount++;
+          const requestParams = {
+            ...params,
+            adjustment: params.adjustment ?? DEFAULT_ADJUSTMENT,
+            feed: DEFAULT_FEED,
+            ...pageToken && { page_token: pageToken }
+          };
+          const response = await this.makeRequest("/stocks/bars", "GET", requestParams);
+          if (!response.bars) {
+            log2(`No bars data found in response for ${symbols.length} symbols`, { symbol: symbolsStr, type: "warn" });
+            break;
+          }
+          if (!currency) {
+            currency = response.currency;
+          }
+          let pageBarsCount = 0;
+          let earliestTimestamp = null;
+          let latestTimestamp = null;
+          Object.entries(response.bars).forEach(([symbol, bars]) => {
+            if (bars && bars.length > 0) {
+              allBars[symbol] = [...allBars[symbol], ...bars];
+              pageBarsCount += bars.length;
+              bars.forEach((bar) => {
+                const barDate = new Date(bar.t);
+                if (!earliestTimestamp || barDate < earliestTimestamp) {
+                  earliestTimestamp = barDate;
+                }
+                if (!latestTimestamp || barDate > latestTimestamp) {
+                  latestTimestamp = barDate;
+                }
+              });
+            }
+          });
+          totalBarsCount += pageBarsCount;
+          pageToken = response.next_page_token || null;
+          hasMorePages = !!pageToken;
+          const dateRangeStr = earliestTimestamp && latestTimestamp ? `${new Date(earliestTimestamp).toLocaleDateString("en-US", { timeZone: "America/New_York" })} to ${new Date(
+            latestTimestamp
+          ).toLocaleDateString("en-US", { timeZone: "America/New_York" })}` : "unknown range";
+          log2(
+            `Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} bars (total: ${totalBarsCount.toLocaleString()}) for ${symbols.length} symbols, date range: ${dateRangeStr}${hasMorePages ? ", more pages available" : ", complete"}`,
+            { symbol: symbolsStr, type: "debug" }
+          );
+          if (pageCount > 1e3) {
+            log2(`Stopping pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
+            break;
+          }
+        }
+        const symbolCounts = Object.entries(allBars).map(([symbol, bars]) => `${symbol}: ${bars.length}`).join(", ");
+        log2(
+          `${params.timeframe} bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages for ${symbols.length} symbols (${symbolCounts})`,
+          { symbol: symbolsStr }
+        );
+        return {
+          bars: allBars,
+          next_page_token: null,
+          // Always null since we fetch all pages
+          currency: currency || DEFAULT_CURRENCY
+        };
+      }
+      /**
+       * Get the most recent minute bar for requested symbols
+       * @param symbols Array of stock symbols to query
+       * @param currency Optional currency in ISO 4217 format
+       * @returns Latest bar data for each symbol
+       
+       */
+      async getLatestBars(symbols, currency) {
+        return this.makeRequest("/stocks/bars/latest", "GET", {
+          symbols,
+          feed: DEFAULT_FEED,
+          currency: currency || DEFAULT_CURRENCY
+        });
+      }
+      /**
+       * Get the last trade for a single symbol
+       * @param symbol The stock symbol to query
+       * @returns Last trade details including price, size, exchange, and conditions
+       */
+      async getLastTrade(symbol) {
+        return this.makeRequest(`/v1/last/stocks/${symbol}`, "GET");
+      }
+      /**
+       * Get the most recent trades for requested symbols
+       * @param symbols Array of stock symbols to query
+       * @param feed Optional data source (sip/iex/delayed_sip)
+       * @param currency Optional currency in ISO 4217 format
+       * @returns Latest trade data for each symbol
+       
+       */
+      async getLatestTrades(symbols, feed, currency) {
+        return this.makeRequest("/stocks/trades/latest", "GET", {
+          symbols,
+          feed: feed || DEFAULT_FEED,
+          currency: currency || DEFAULT_CURRENCY
+        });
+      }
+      /**
+       * Get the most recent quotes for requested symbols
+       * @param symbols Array of stock symbols to query
+       * @param feed Optional data source (sip/iex/delayed_sip)
+       * @param currency Optional currency in ISO 4217 format
+       * @returns Latest quote data for each symbol
+       */
+      async getLatestQuotes(symbols, feed, currency) {
+        if (!symbols || symbols.length === 0) {
+          log2("No symbols provided to getLatestQuotes, returning empty response", { type: "warn" });
+          return {
+            quotes: {},
+            currency: currency || DEFAULT_CURRENCY
+          };
+        }
+        return this.makeRequest("/stocks/quotes/latest", "GET", {
+          symbols,
+          feed: feed || DEFAULT_FEED,
+          currency: currency || DEFAULT_CURRENCY
+        });
+      }
+      /**
+       * Get the latest quote for a single symbol
+       * @param symbol The stock symbol to query
+       * @param feed Optional data source (sip/iex/delayed_sip)
+       * @param currency Optional currency in ISO 4217 format
+       * @returns Latest quote data with symbol and currency information
+       */
+      async getLatestQuote(symbol, feed, currency) {
+        return this.makeRequest(`/stocks/${symbol}/quotes/latest`, "GET", {
+          feed: feed || DEFAULT_FEED,
+          currency
+        });
+      }
+      /**
+       * Get the previous day's closing price for a symbol
+       * @param symbol The stock symbol to query
+       * @param referenceDate Optional reference date to get the previous close for
+       * @returns Previous day's closing price data
+       */
+      async getPreviousClose(symbol, referenceDate) {
+        const date = referenceDate || /* @__PURE__ */ new Date();
+        const prevMarketDate = getLastFullTradingDate(date);
+        const response = await this.getHistoricalBars({
+          symbols: [symbol],
+          timeframe: "1Day",
+          start: prevMarketDate.toISOString(),
+          end: prevMarketDate.toISOString(),
+          limit: 1
+        });
+        if (!response.bars[symbol] || response.bars[symbol].length === 0) {
+          log2(`No previous close data available for ${symbol}`, { type: "error", symbol });
+          return null;
+        }
+        return response.bars[symbol][0];
+      }
+      /**
+       * Get hourly price data for a symbol
+       * @param symbol The stock symbol to query
+       * @param start Start time in milliseconds
+       * @param end End time in milliseconds
+       * @returns Array of hourly price bars
+       */
+      async getHourlyPrices(symbol, start, end) {
+        const response = await this.getHistoricalBars({
+          symbols: [symbol],
+          timeframe: "1Hour",
+          start: new Date(start).toISOString(),
+          end: new Date(end).toISOString(),
+          limit: 96
+          // Last 96 hours (4 days)
+        });
+        return response.bars[symbol] || [];
+      }
+      /**
+       * Get half-hourly price data for a symbol
+       * @param symbol The stock symbol to query
+       * @param start Start time in milliseconds
+       * @param end End time in milliseconds
+       * @returns Array of half-hourly price bars
+       */
+      async getHalfHourlyPrices(symbol, start, end) {
+        const response = await this.getHistoricalBars({
+          symbols: [symbol],
+          timeframe: "30Min",
+          start: new Date(start).toISOString(),
+          end: new Date(end).toISOString(),
+          limit: 16 * 2 * 4
+          // last 4 days, 16 hours per day, 2 bars per hour
+        });
+        return response.bars[symbol] || [];
+      }
+      /**
+       * Get daily price data for a symbol
+       * @param symbol The stock symbol to query
+       * @param start Start time in milliseconds
+       * @param end End time in milliseconds
+       * @returns Array of daily price bars
+       */
+      async getDailyPrices(symbol, start, end) {
+        const response = await this.getHistoricalBars({
+          symbols: [symbol],
+          timeframe: "1Day",
+          start: new Date(start).toISOString(),
+          end: new Date(end).toISOString(),
+          limit: 100
+          // Last 100 days
+        });
+        return response.bars[symbol] || [];
+      }
+      /**
+       * Get intraday price data for a symbol
+       * @param symbol The stock symbol to query
+       * @param minutePeriod Minutes per bar (1, 5, 15, etc.)
+       * @param start Start time in milliseconds
+       * @param end End time in milliseconds
+       * @returns Array of intraday price bars
+       */
+      async getIntradayPrices(symbol, minutePeriod, start, end) {
+        const timeframe = `${minutePeriod}Min`;
+        const response = await this.getHistoricalBars({
+          symbols: [symbol],
+          timeframe,
+          start: new Date(start).toISOString(),
+          end: new Date(end).toISOString()
+        });
+        return response.bars[symbol] || [];
+      }
+      /**
+       * Analyzes an array of price bars and returns a summary string
+       * @param bars Array of price bars to analyze
+       * @returns A string summarizing the price data
+       */
+      static analyzeBars(bars) {
+        if (!bars || bars.length === 0) {
+          return "No price data available";
+        }
+        const firstBar = bars[0];
+        const lastBar = bars[bars.length - 1];
+        const priceChange = lastBar.c - firstBar.o;
+        const percentChange = priceChange / firstBar.o * 100;
+        const volumeChange = lastBar.v - firstBar.v;
+        const percentVolumeChange = volumeChange / firstBar.v * 100;
+        const high = Math.max(...bars.map((bar) => bar.h));
+        const low = Math.min(...bars.map((bar) => bar.l));
+        const totalVolume = bars.reduce((sum, bar) => sum + bar.v, 0);
+        const avgVolume = totalVolume / bars.length;
+        return `Price: $${firstBar.o.toFixed(2)} -> $${lastBar.c.toFixed(2)} (${percentChange.toFixed(2)}%), Volume: ${firstBar.v.toLocaleString()} -> ${lastBar.v.toLocaleString()} (${percentVolumeChange.toFixed(2)}%), High: $${high.toFixed(2)}, Low: $${low.toFixed(2)}, Avg Volume: ${avgVolume.toLocaleString()}`;
+      }
+      /**
+       * Get assets available for trade and data consumption from Alpaca
+       * @param params Optional query params
+       * - status: 'active' | 'inactive' (default 'active')
+       * - asset_class: 'us_equity' | 'us_option' | 'crypto' (default 'us_equity')
+       * - shortable: if true (default), filters to assets with shortable=true and easy_to_borrow=true
+       * @returns Array of AlpacaAsset objects
+       * @see https://docs.alpaca.markets/reference/get-v2-assets-1
+       */
+      async getAssets(params) {
+        const {
+          status = "active",
+          asset_class = "us_equity",
+          shortable = true
+        } = {
+          status: params?.status ?? "active",
+          asset_class: params?.asset_class ?? "us_equity",
+          shortable: params?.shortable ?? true
+        };
+        const assets = await this.makeRequest(
+          "/assets",
+          "GET",
+          { status, asset_class },
+          "api"
+        );
+        if (!shortable) return assets;
+        return assets.filter((a) => a.shortable === true && a.easy_to_borrow === true);
+      }
+      /**
+       * Get a single asset by symbol or asset_id
+       * @param symbolOrAssetId Symbol or asset_id
+       * @returns AlpacaAsset object
+       * @see https://docs.alpaca.markets/reference/get-v2-assets-symbol_or_asset_id
+       */
+      async getAsset(symbolOrAssetId) {
+        return this.makeRequest(`/assets/${encodeURIComponent(symbolOrAssetId)}`, "GET", void 0, "api");
+      }
+      // ===== OPTIONS MARKET DATA METHODS =====
+      /**
+       * Get options chain for an underlying symbol
+       * Provides the latest trade, latest quote, and greeks for each contract symbol of the underlying symbol
+       * @param params Options chain request parameters
+       * @returns Options chain data with snapshots for each contract
+       * @see https://docs.alpaca.markets/reference/optionchain
+       */
+      async getOptionsChain(params) {
+        const { underlying_symbol, ...queryParams } = params;
+        return this.makeRequest(
+          `/options/snapshots/${encodeURIComponent(underlying_symbol)}`,
+          "GET",
+          queryParams,
+          "v1beta1"
+        );
+      }
+      /**
+       * Get the most recent trades for requested option contract symbols
+       * @param params Latest options trades request parameters
+       * @returns Latest trade data for each option contract symbol
+       
+       * @see https://docs.alpaca.markets/reference/optionlatesttrades
+       */
+      async getLatestOptionsTrades(params) {
+        const { limit, page_token, ...requestParams } = params;
+        return this.makeRequest("/options/trades/latest", "GET", requestParams, "v1beta1");
+      }
+      /**
+       * Get the most recent quotes for requested option contract symbols
+       * @param params Latest options quotes request parameters
+       * @returns Latest quote data for each option contract symbol
+       
+       * @see https://docs.alpaca.markets/reference/optionlatestquotes
+       */
+      async getLatestOptionsQuotes(params) {
+        const { limit, page_token, ...requestParams } = params;
+        return this.makeRequest("/options/quotes/latest", "GET", requestParams, "v1beta1");
+      }
+      /**
+       * Get historical OHLCV bars for option contract symbols
+       * Automatically handles pagination to fetch all available data
+       * @param params Historical options bars request parameters
+       * @returns Historical bar data for each option contract symbol with all pages combined
+       
+       * @see https://docs.alpaca.markets/reference/optionbars
+       */
+      async getHistoricalOptionsBars(params) {
+        const symbols = params.symbols;
+        const symbolsStr = symbols.join(",");
+        let allBars = {};
+        let pageToken = null;
+        let hasMorePages = true;
+        let totalBarsCount = 0;
+        let pageCount = 0;
+        symbols.forEach((symbol) => {
+          allBars[symbol] = [];
+        });
+        log2(
+          `Starting historical options bars fetch for ${symbols.length} symbols (${params.timeframe}, ${params.start || "no start"} to ${params.end || "no end"})`
+        );
+        while (hasMorePages) {
+          pageCount++;
+          const requestParams = {
+            ...params,
+            ...pageToken && { page_token: pageToken }
+          };
+          const response = await this.makeRequest(
+            "/options/bars",
+            "GET",
+            requestParams,
+            "v1beta1"
+          );
+          if (!response.bars) {
+            log2(`No options bars data found in response for ${symbols.length} symbols`, { type: "warn" });
+            break;
+          }
+          let pageBarsCount = 0;
+          let earliestTimestamp = null;
+          let latestTimestamp = null;
+          Object.entries(response.bars).forEach(([symbol, bars]) => {
+            if (bars && bars.length > 0) {
+              allBars[symbol] = [...allBars[symbol], ...bars];
+              pageBarsCount += bars.length;
+              bars.forEach((bar) => {
+                const barDate = new Date(bar.t);
+                if (!earliestTimestamp || barDate < earliestTimestamp) {
+                  earliestTimestamp = barDate;
+                }
+                if (!latestTimestamp || barDate > latestTimestamp) {
+                  latestTimestamp = barDate;
+                }
+              });
+            }
+          });
+          totalBarsCount += pageBarsCount;
+          pageToken = response.next_page_token || null;
+          hasMorePages = !!pageToken;
+          const dateRangeStr = earliestTimestamp && latestTimestamp ? `${earliestTimestamp.toLocaleDateString("en-US", { timeZone: "America/New_York" })} to ${latestTimestamp.toLocaleDateString("en-US", { timeZone: "America/New_York" })}` : "unknown range";
+          log2(
+            `Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} option bars (total: ${totalBarsCount.toLocaleString()}) for ${symbols.length} symbols, date range: ${dateRangeStr}${hasMorePages ? ", more pages available" : ", complete"}`,
+            {
+              type: "debug"
+            }
+          );
+          if (pageCount > 1e3) {
+            log2(`Stopping options bars pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
+            break;
+          }
+        }
+        const symbolCounts = Object.entries(allBars).map(([symbol, bars]) => `${symbol}: ${bars.length}`).join(", ");
+        log2(
+          `Options bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages (${symbolCounts})`
+        );
+        return {
+          bars: allBars,
+          next_page_token: void 0
+          // Always undefined since we fetch all pages
+        };
+      }
+      /**
+       * Get historical trades for option contract symbols
+       * Automatically handles pagination to fetch all available data
+       * @param params Historical options trades request parameters
+       * @returns Historical trade data for each option contract symbol with all pages combined
+       
+       * @see https://docs.alpaca.markets/reference/optiontrades
+       */
+      async getHistoricalOptionsTrades(params) {
+        const symbols = params.symbols;
+        const symbolsStr = symbols.join(",");
+        let allTrades = {};
+        let pageToken = null;
+        let hasMorePages = true;
+        let totalTradesCount = 0;
+        let pageCount = 0;
+        symbols.forEach((symbol) => {
+          allTrades[symbol] = [];
+        });
+        log2(
+          `Starting historical options trades fetch for ${symbols.length} symbols (${params.start || "no start"} to ${params.end || "no end"})`
+        );
+        while (hasMorePages) {
+          pageCount++;
+          const requestParams = {
+            ...params,
+            ...pageToken && { page_token: pageToken }
+          };
+          const response = await this.makeRequest(
+            "/options/trades",
+            "GET",
+            requestParams,
+            "v1beta1"
+          );
+          if (!response.trades) {
+            log2(`No options trades data found in response for ${symbols.length} symbols`, { type: "warn" });
+            break;
+          }
+          let pageTradesCount = 0;
+          let earliestTimestamp = null;
+          let latestTimestamp = null;
+          Object.entries(response.trades).forEach(([symbol, trades]) => {
+            if (trades && trades.length > 0) {
+              allTrades[symbol] = [...allTrades[symbol], ...trades];
+              pageTradesCount += trades.length;
+              trades.forEach((trade) => {
+                const tradeDate = new Date(trade.t);
+                if (!earliestTimestamp || tradeDate < earliestTimestamp) {
+                  earliestTimestamp = tradeDate;
+                }
+                if (!latestTimestamp || tradeDate > latestTimestamp) {
+                  latestTimestamp = tradeDate;
+                }
+              });
+            }
+          });
+          totalTradesCount += pageTradesCount;
+          pageToken = response.next_page_token || null;
+          hasMorePages = !!pageToken;
+          const dateRangeStr = earliestTimestamp && latestTimestamp ? `${earliestTimestamp.toLocaleDateString("en-US", { timeZone: "America/New_York" })} to ${latestTimestamp.toLocaleDateString("en-US", { timeZone: "America/New_York" })}` : "unknown range";
+          log2(
+            `Page ${pageCount}: Fetched ${pageTradesCount.toLocaleString()} option trades (total: ${totalTradesCount.toLocaleString()}) for ${symbols.length} symbols, date range: ${dateRangeStr}${hasMorePages ? ", more pages available" : ", complete"}`,
+            {
+              type: "debug"
+            }
+          );
+          if (pageCount > 1e3) {
+            log2(`Stopping options trades pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
+            break;
+          }
+        }
+        const symbolCounts = Object.entries(allTrades).map(([symbol, trades]) => `${symbol}: ${trades.length}`).join(", ");
+        log2(
+          `Options trades fetch complete: ${totalTradesCount.toLocaleString()} total trades across ${pageCount} pages (${symbolCounts})`
+        );
+        return {
+          trades: allTrades,
+          next_page_token: void 0
+          // Always undefined since we fetch all pages
+        };
+      }
+      /**
+       * Get snapshots for option contract symbols
+       * Provides latest trade, latest quote, and greeks for each contract symbol
+       * @param params Options snapshots request parameters
+       * @returns Snapshot data for each option contract symbol
+       
+       * @see https://docs.alpaca.markets/reference/optionsnapshots
+       */
+      async getOptionsSnapshot(params) {
+        const { limit, page_token, ...requestParams } = params;
+        return this.makeRequest("/options/snapshots", "GET", requestParams, "v1beta1");
+      }
+      /**
+       * Get condition codes for options trades or quotes
+       * Returns the mapping between condition codes and their descriptions
+       * @param tickType The type of tick data ('trade' or 'quote')
+       * @returns Mapping of condition codes to descriptions
+       
+       * @see https://docs.alpaca.markets/reference/optionmetaconditions
+       */
+      async getOptionsConditionCodes(tickType) {
+        return this.makeRequest(`/options/meta/conditions/${tickType}`, "GET", void 0, "v1beta1");
+      }
+      /**
+       * Get exchange codes for options
+       * Returns the mapping between option exchange codes and exchange names
+       * @returns Mapping of exchange codes to exchange names
+       
+       * @see https://docs.alpaca.markets/reference/optionmetaexchanges
+       */
+      async getOptionsExchangeCodes() {
+        return this.makeRequest("/options/meta/exchanges", "GET", void 0, "v1beta1");
+      }
+      /**
+       * Analyzes an array of option bars and returns a summary string
+       * @param bars Array of option bars to analyze
+       * @returns A string summarizing the option price data
+       */
+      static analyzeOptionBars(bars) {
+        if (!bars || bars.length === 0) {
+          return "No option price data available";
+        }
+        const firstBar = bars[0];
+        const lastBar = bars[bars.length - 1];
+        const priceChange = lastBar.c - firstBar.o;
+        const percentChange = priceChange / firstBar.o * 100;
+        const volumeChange = lastBar.v - firstBar.v;
+        const percentVolumeChange = firstBar.v > 0 ? volumeChange / firstBar.v * 100 : 0;
+        const high = Math.max(...bars.map((bar) => bar.h));
+        const low = Math.min(...bars.map((bar) => bar.l));
+        const totalVolume = bars.reduce((sum, bar) => sum + bar.v, 0);
+        const avgVolume = totalVolume / bars.length;
+        return `Option Price: $${firstBar.o.toFixed(2)} -> $${lastBar.c.toFixed(2)} (${percentChange.toFixed(2)}%), Volume: ${firstBar.v.toLocaleString()} -> ${lastBar.v.toLocaleString()} (${percentVolumeChange.toFixed(2)}%), High: $${high.toFixed(2)}, Low: $${low.toFixed(2)}, Avg Volume: ${avgVolume.toLocaleString()}`;
+      }
+      /**
+       * Formats option greeks for display
+       * @param greeks Option greeks object
+       * @returns Formatted string with greek values
+       */
+      static formatOptionGreeks(greeks) {
+        if (!greeks) {
+          return "No greeks data available";
+        }
+        const parts = [];
+        if (greeks.delta !== void 0) parts.push(`Delta: ${greeks.delta.toFixed(4)}`);
+        if (greeks.gamma !== void 0) parts.push(`Gamma: ${greeks.gamma.toFixed(4)}`);
+        if (greeks.theta !== void 0) parts.push(`Theta: ${greeks.theta.toFixed(4)}`);
+        if (greeks.vega !== void 0) parts.push(`Vega: ${greeks.vega.toFixed(4)}`);
+        if (greeks.rho !== void 0) parts.push(`Rho: ${greeks.rho.toFixed(4)}`);
+        return parts.length > 0 ? parts.join(", ") : "No greeks data available";
+      }
+      /**
+       * Interprets condition codes using the provided condition codes mapping
+       * @param conditionCodes Array of condition codes from trade or quote
+       * @param conditionCodesMap Mapping of condition codes to descriptions
+       * @returns Formatted string with condition descriptions
+       */
+      static interpretConditionCodes(conditionCodes, conditionCodesMap) {
+        if (!conditionCodes || conditionCodes.length === 0) {
+          return "No conditions";
+        }
+        const descriptions = conditionCodes.map((code) => conditionCodesMap[code] || `Unknown (${code})`).filter((desc) => desc !== void 0);
+        return descriptions.length > 0 ? descriptions.join(", ") : "No condition descriptions available";
+      }
+      /**
+       * Gets the exchange name from exchange code using the provided exchange codes mapping
+       * @param exchangeCode Exchange code from trade or quote
+       * @param exchangeCodesMap Mapping of exchange codes to names
+       * @returns Exchange name or formatted unknown exchange
+       */
+      static getExchangeName(exchangeCode, exchangeCodesMap) {
+        return exchangeCodesMap[exchangeCode] || `Unknown Exchange (${exchangeCode})`;
+      }
+      /**
+       * Fetches news articles from Alpaca API for a symbol, paginating through all results.
+       * @param symbol The symbol to fetch news for (e.g., 'AAPL')
+       * @param params Optional parameters: start, end, limit, sort, include_content
+       * @returns Array of SimpleNews articles
+       */
+      async fetchNews(symbol, params) {
+        const defaultParams = {
+          start: new Date(Date.now() - 24 * 60 * 60 * 1e3),
+          end: /* @__PURE__ */ new Date(),
+          limit: 10,
+          sort: "desc",
+          include_content: true
+        };
+        const mergedParams = { ...defaultParams, ...params };
+        let newsArticles = [];
+        let pageToken = null;
+        let hasMorePages = true;
+        let fetchedCount = 0;
+        const maxLimit = mergedParams.limit;
+        function cleanContent(content) {
+          if (!content) return void 0;
+          return content.replace(/\s+/g, " ").trim();
+        }
+        while (hasMorePages) {
+          const queryParams = new URLSearchParams({
+            ...mergedParams.start && { start: new Date(mergedParams.start).toISOString() },
+            ...mergedParams.end && { end: new Date(mergedParams.end).toISOString() },
+            ...symbol && { symbols: symbol },
+            ...mergedParams.limit && { limit: Math.min(50, maxLimit - fetchedCount).toString() },
+            ...mergedParams.sort && { sort: mergedParams.sort },
+            ...mergedParams.include_content !== void 0 ? { include_content: mergedParams.include_content.toString() } : {},
+            ...pageToken && { page_token: pageToken }
+          });
+          const url = `${this.v1beta1url}/news?${queryParams}`;
+          log2(`Fetching news from: ${url}`, { type: "debug", symbol });
+          const response = await fetch(url, {
+            method: "GET",
+            headers: this.headers
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            log2(`Alpaca news API error (${response.status}): ${errorText}`, { type: "error", symbol });
+            throw new Error(`Alpaca news API error (${response.status}): ${errorText}`);
+          }
+          const data = await response.json();
+          if (!data.news || !Array.isArray(data.news)) {
+            log2(`No news data found in Alpaca response for ${symbol}`, { type: "warn", symbol });
+            break;
+          }
+          const transformedNews = data.news.map((article) => ({
+            symbols: article.symbols,
+            title: article.headline,
+            summary: cleanContent(article.summary) ?? "",
+            content: article.content ? cleanContent(article.content) : void 0,
+            url: article.url,
+            source: article.source,
+            author: article.author,
+            date: article.updated_at || article.created_at,
+            updatedDate: article.updated_at || article.created_at,
+            sentiment: 0
+          }));
+          newsArticles = newsArticles.concat(transformedNews);
+          fetchedCount = newsArticles.length;
+          pageToken = data.next_page_token || null;
+          hasMorePages = !!pageToken && (!maxLimit || fetchedCount < maxLimit);
+          log2(
+            `Fetched ${transformedNews.length} news articles (total: ${fetchedCount}) for ${symbol}. More pages: ${hasMorePages}`,
+            { type: "debug", symbol }
+          );
+          if (maxLimit && fetchedCount >= maxLimit) {
+            newsArticles = newsArticles.slice(0, maxLimit);
+            break;
+          }
+        }
+        return newsArticles;
+      }
+      // ===== CRYPTO MARKET DATA METHODS =====
+      /**
+       * Get historical OHLCV bars for crypto symbols
+       * Automatically handles pagination to fetch all available data
+       * @param params Parameters for crypto historical bars request
+       * @returns Historical bars data with all pages combined
+       */
+      async getCryptoHistoricalBars(params) {
+        const symbols = params.symbols;
+        const symbolsStr = symbols.join(",");
+        let allBars = {};
+        let pageToken = null;
+        let hasMorePages = true;
+        let totalBarsCount = 0;
+        let pageCount = 0;
+        symbols.forEach((symbol) => {
+          allBars[symbol] = [];
+        });
+        log2(
+          `Starting crypto historical bars fetch for ${symbols.length} symbols (${params.timeframe}, ${params.start || "no start"} to ${params.end || "no end"})`
+        );
+        while (hasMorePages) {
+          pageCount++;
+          const requestParams = {
+            ...params,
+            symbols: symbolsStr,
+            ...pageToken && { page_token: pageToken }
+          };
+          const response = await this.makeRequest(
+            "/crypto/us/bars",
+            "GET",
+            requestParams,
+            "v1beta3"
+          );
+          if (!response.bars) {
+            log2(`No crypto bars data found in response for ${symbols.length} symbols`, { type: "warn" });
+            break;
+          }
+          let pageBarsCount = 0;
+          Object.entries(response.bars).forEach(([symbol, bars]) => {
+            if (bars && bars.length > 0) {
+              allBars[symbol] = [...allBars[symbol], ...bars];
+              pageBarsCount += bars.length;
+            }
+          });
+          totalBarsCount += pageBarsCount;
+          pageToken = response.next_page_token || null;
+          hasMorePages = !!pageToken;
+          log2(
+            `Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} crypto bars (total: ${totalBarsCount.toLocaleString()}) for ${symbols.length} symbols${hasMorePages ? ", more pages available" : ", complete"}`,
+            { type: "debug" }
+          );
+          if (pageCount > 1e3) {
+            log2(`Stopping crypto bars pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
+            break;
+          }
+        }
+        log2(
+          `Crypto historical bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages`
+        );
+        return {
+          bars: allBars,
+          next_page_token: null
+          // Always null since we fetch all pages
+        };
+      }
+      /**
+       * Get the most recent minute bar for requested crypto symbols
+       * @param symbols Array of crypto symbols to query
+       * @returns Latest bar data for each symbol
+       */
+      async getCryptoLatestBars(symbols) {
+        return this.makeRequest("/crypto/us/latest/bars", "GET", { symbols: symbols.join(",") }, "v1beta3");
+      }
+      /**
+       * Get historical quotes for crypto symbols
+       * Automatically handles pagination to fetch all available data
+       * @param params Parameters for crypto historical quotes request
+       * @returns Historical quotes data with all pages combined
+       */
+      async getCryptoHistoricalQuotes(params) {
+        const symbols = params.symbols;
+        const symbolsStr = symbols.join(",");
+        let allQuotes = {};
+        let pageToken = null;
+        let hasMorePages = true;
+        let totalQuotesCount = 0;
+        let pageCount = 0;
+        symbols.forEach((symbol) => {
+          allQuotes[symbol] = [];
+        });
+        log2(
+          `Starting crypto historical quotes fetch for ${symbols.length} symbols (${params.start || "no start"} to ${params.end || "no end"})`
+        );
+        while (hasMorePages) {
+          pageCount++;
+          const requestParams = {
+            ...params,
+            symbols: symbolsStr,
+            ...pageToken && { page_token: pageToken }
+          };
+          const response = await this.makeRequest(
+            "/crypto/us/quotes",
+            "GET",
+            requestParams,
+            "v1beta3"
+          );
+          if (!response.quotes) {
+            log2(`No crypto quotes data found in response for ${symbols.length} symbols`, { type: "warn" });
+            break;
+          }
+          let pageQuotesCount = 0;
+          Object.entries(response.quotes).forEach(([symbol, quotes]) => {
+            if (quotes && quotes.length > 0) {
+              allQuotes[symbol] = [...allQuotes[symbol], ...quotes];
+              pageQuotesCount += quotes.length;
+            }
+          });
+          totalQuotesCount += pageQuotesCount;
+          pageToken = response.next_page_token || null;
+          hasMorePages = !!pageToken;
+          log2(
+            `Page ${pageCount}: Fetched ${pageQuotesCount.toLocaleString()} crypto quotes (total: ${totalQuotesCount.toLocaleString()}) for ${symbols.length} symbols${hasMorePages ? ", more pages available" : ", complete"}`,
+            { type: "debug" }
+          );
+          if (pageCount > 1e3) {
+            log2(`Stopping crypto quotes pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
+            break;
+          }
+        }
+        log2(
+          `Crypto historical quotes fetch complete: ${totalQuotesCount.toLocaleString()} total quotes across ${pageCount} pages`
+        );
+        return {
+          quotes: allQuotes,
+          next_page_token: null
+          // Always null since we fetch all pages
+        };
+      }
+      /**
+       * Get the most recent quotes for requested crypto symbols
+       * @param symbols Array of crypto symbols to query
+       * @returns Latest quote data for each symbol
+       */
+      async getCryptoLatestQuotes(symbols) {
+        if (!symbols || symbols.length === 0) {
+          log2("No symbols provided to getCryptoLatestQuotes, returning empty response", { type: "warn" });
+          return { quotes: {} };
+        }
+        return this.makeRequest("/crypto/us/latest/quotes", "GET", { symbols: symbols.join(",") }, "v1beta3");
+      }
+      /**
+       * Get historical trades for crypto symbols
+       * Automatically handles pagination to fetch all available data
+       * @param params Parameters for crypto historical trades request
+       * @returns Historical trades data with all pages combined
+       */
+      async getCryptoHistoricalTrades(params) {
+        const symbols = params.symbols;
+        const symbolsStr = symbols.join(",");
+        let allTrades = {};
+        let pageToken = null;
+        let hasMorePages = true;
+        let totalTradesCount = 0;
+        let pageCount = 0;
+        symbols.forEach((symbol) => {
+          allTrades[symbol] = [];
+        });
+        log2(
+          `Starting crypto historical trades fetch for ${symbols.length} symbols (${params.start || "no start"} to ${params.end || "no end"})`
+        );
+        while (hasMorePages) {
+          pageCount++;
+          const requestParams = {
+            ...params,
+            symbols: symbolsStr,
+            ...pageToken && { page_token: pageToken }
+          };
+          const response = await this.makeRequest(
+            "/crypto/us/trades",
+            "GET",
+            requestParams,
+            "v1beta3"
+          );
+          if (!response.trades) {
+            log2(`No crypto trades data found in response for ${symbols.length} symbols`, { type: "warn" });
+            break;
+          }
+          let pageTradesCount = 0;
+          Object.entries(response.trades).forEach(([symbol, trades]) => {
+            if (trades && trades.length > 0) {
+              allTrades[symbol] = [...allTrades[symbol], ...trades];
+              pageTradesCount += trades.length;
+            }
+          });
+          totalTradesCount += pageTradesCount;
+          pageToken = response.next_page_token || null;
+          hasMorePages = !!pageToken;
+          log2(
+            `Page ${pageCount}: Fetched ${pageTradesCount.toLocaleString()} crypto trades (total: ${totalTradesCount.toLocaleString()}) for ${symbols.length} symbols${hasMorePages ? ", more pages available" : ", complete"}`,
+            { type: "debug" }
+          );
+          if (pageCount > 1e3) {
+            log2(`Stopping crypto trades pagination after ${pageCount} pages to prevent infinite loop`, { type: "warn" });
+            break;
+          }
+        }
+        log2(
+          `Crypto historical trades fetch complete: ${totalTradesCount.toLocaleString()} total trades across ${pageCount} pages`
+        );
+        return {
+          trades: allTrades,
+          next_page_token: null
+          // Always null since we fetch all pages
+        };
+      }
+      /**
+       * Get the most recent trades for requested crypto symbols
+       * @param symbols Array of crypto symbols to query
+       * @returns Latest trade data for each symbol
+       */
+      async getCryptoLatestTrades(symbols) {
+        if (!symbols || symbols.length === 0) {
+          log2("No symbols provided to getCryptoLatestTrades, returning empty response", { type: "warn" });
+          return { trades: {} };
+        }
+        return this.makeRequest("/crypto/us/latest/trades", "GET", { symbols: symbols.join(",") }, "v1beta3");
+      }
+      /**
+       * Get snapshots for crypto symbols
+       * Returns the latest trade, latest quote, latest minute bar, latest daily bar, and previous daily bar data
+       * @param symbols Array of crypto symbols to query
+       * @returns Snapshot data for each symbol
+       */
+      async getCryptoSnapshots(symbols) {
+        if (!symbols || symbols.length === 0) {
+          log2("No symbols provided to getCryptoSnapshots, returning empty response", { type: "warn" });
+          return { snapshots: {} };
+        }
+        return this.makeRequest("/crypto/us/snapshots", "GET", { symbols: symbols.join(",") }, "v1beta3");
+      }
+      /**
+       * Get the latest orderbook for requested crypto symbols
+       * @param symbols Array of crypto symbols to query
+       * @returns Latest orderbook data for each symbol
+       */
+      async getCryptoLatestOrderbooks(symbols) {
+        if (!symbols || symbols.length === 0) {
+          log2("No symbols provided to getCryptoLatestOrderbooks, returning empty response", { type: "warn" });
+          return { orderbooks: {} };
+        }
+        return this.makeRequest("/crypto/us/latest/orderbooks", "GET", { symbols: symbols.join(",") }, "v1beta3");
+      }
+      /**
+       * Analyzes an array of crypto bars and returns a summary string
+       * @param bars Array of crypto bars to analyze
+       * @returns A string summarizing the crypto price data
+       */
+      static analyzeCryptoBars(bars) {
+        if (!bars || bars.length === 0) {
+          return "No crypto price data available";
+        }
+        const firstBar = bars[0];
+        const lastBar = bars[bars.length - 1];
+        const priceChange = lastBar.c - firstBar.o;
+        const percentChange = priceChange / firstBar.o * 100;
+        const volumeChange = lastBar.v - firstBar.v;
+        const percentVolumeChange = firstBar.v > 0 ? volumeChange / firstBar.v * 100 : 0;
+        const high = Math.max(...bars.map((bar) => bar.h));
+        const low = Math.min(...bars.map((bar) => bar.l));
+        const totalVolume = bars.reduce((sum, bar) => sum + bar.v, 0);
+        const avgVolume = totalVolume / bars.length;
+        return `Crypto Price: $${firstBar.o.toFixed(6)} -> $${lastBar.c.toFixed(6)} (${percentChange.toFixed(2)}%), Volume: ${firstBar.v.toLocaleString()} -> ${lastBar.v.toLocaleString()} (${percentVolumeChange.toFixed(2)}%), High: $${high.toFixed(6)}, Low: $${low.toFixed(6)}, Avg Volume: ${avgVolume.toLocaleString()}`;
+      }
+    };
+    marketDataAPI = AlpacaMarketDataAPI.getInstance();
+  }
+});
+
+// src/alpaca-trading-api.ts
+import WebSocket2 from "ws";
+var init_alpaca_trading_api = __esm({
+  "src/alpaca-trading-api.ts"() {
+    "use strict";
+    init_logging();
+    init_alpaca_market_data_api();
+    init_market_time();
+  }
+});
+
+// src/index.ts
+init_market_time();
+
+// src/types/llm-types.ts
+var OPENAI_MODELS = [
+  "gpt-5.6",
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.6-luna",
+  "gpt-5",
+  "gpt-5-mini",
+  "gpt-5.4-mini",
+  "gpt-5.4-nano",
+  "gpt-5-nano",
+  "gpt-5.1",
+  "gpt-5.4",
+  "gpt-5.5",
+  "gpt-5.5-pro",
+  "gpt-5.2",
+  "gpt-5.2-pro",
+  "gpt-5.1-codex",
+  "gpt-5.1-codex-max"
+];
+function isOpenAIModel(model) {
+  return OPENAI_MODELS.includes(model);
+}
+var OPENROUTER_MODELS = [
+  "openai/gpt-5",
+  "openai/gpt-5-mini",
+  "openai/gpt-5.4-mini",
+  "openai/gpt-5.4-nano",
+  "openai/gpt-5-nano",
+  "openai/gpt-5.1",
+  "openai/gpt-5.4",
+  "openai/gpt-5.4-pro",
+  "openai/gpt-5.5",
+  "openai/gpt-5.5-pro",
+  "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"
+];
+function isOpenRouterModel(model) {
+  return OPENROUTER_MODELS.includes(model);
+}
+
+// src/llm-openai.ts
+import OpenAI2 from "openai";
+import { zodTextFormat } from "openai/helpers/zod";
+
+// src/llm-config.ts
+var DEFAULT_MODEL = "gpt-5.6-luna";
+var GPT_5_HIGH_CONTEXT_THRESHOLD_TOKENS = 272e3;
+var GPT_5_HIGH_CONTEXT_INPUT_MULTIPLIER = 2;
+var GPT_5_HIGH_CONTEXT_OUTPUT_MULTIPLIER = 1.5;
+var openAiModelCosts = {
+  "gpt-5.6": {
+    inputCost: 5 / 1e6,
+    cacheHitCost: 0.5 / 1e6,
+    cacheWriteCost: 6.25 / 1e6,
+    outputCost: 30 / 1e6
+  },
+  "gpt-5.6-sol": {
+    inputCost: 5 / 1e6,
+    cacheHitCost: 0.5 / 1e6,
+    cacheWriteCost: 6.25 / 1e6,
+    outputCost: 30 / 1e6
+  },
+  "gpt-5.6-terra": {
+    inputCost: 2.5 / 1e6,
+    cacheHitCost: 0.25 / 1e6,
+    cacheWriteCost: 3.125 / 1e6,
+    outputCost: 15 / 1e6
+  },
+  "gpt-5.6-luna": {
+    inputCost: 1 / 1e6,
+    cacheHitCost: 0.1 / 1e6,
+    cacheWriteCost: 1.25 / 1e6,
+    outputCost: 6 / 1e6
+  },
+  "gpt-5": {
+    inputCost: 1.25 / 1e6,
+    cacheHitCost: 0.125 / 1e6,
+    outputCost: 10 / 1e6
+  },
+  "gpt-5-mini": {
+    inputCost: 0.25 / 1e6,
+    cacheHitCost: 0.025 / 1e6,
+    outputCost: 2 / 1e6
+  },
+  "gpt-5.4-mini": {
+    inputCost: 0.75 / 1e6,
+    cacheHitCost: 0.075 / 1e6,
+    outputCost: 4.5 / 1e6
+  },
+  "gpt-5.4-nano": {
+    inputCost: 0.2 / 1e6,
+    cacheHitCost: 0.02 / 1e6,
+    outputCost: 1.25 / 1e6
+  },
+  "gpt-5-nano": {
+    inputCost: 0.05 / 1e6,
+    cacheHitCost: 5e-3 / 1e6,
+    outputCost: 0.4 / 1e6
+  },
+  "gpt-5.1": {
+    inputCost: 1.25 / 1e6,
+    cacheHitCost: 0.125 / 1e6,
+    outputCost: 10 / 1e6
+  },
+  "gpt-5.4": {
+    inputCost: 2.5 / 1e6,
+    cacheHitCost: 0.25 / 1e6,
+    outputCost: 15 / 1e6
+  },
+  "gpt-5.5": {
+    inputCost: 5 / 1e6,
+    cacheHitCost: 0.5 / 1e6,
+    outputCost: 30 / 1e6
+  },
+  "gpt-5.5-pro": {
+    inputCost: 30 / 1e6,
+    outputCost: 180 / 1e6
+  },
+  "gpt-5.2": {
+    inputCost: 1.75 / 1e6,
+    cacheHitCost: 0.175 / 1e6,
+    outputCost: 14 / 1e6
+  },
+  "gpt-5.2-pro": {
+    inputCost: 21 / 1e6,
+    outputCost: 168 / 1e6
+  },
+  "gpt-5.1-codex": {
+    inputCost: 1.25 / 1e6,
+    cacheHitCost: 0.125 / 1e6,
+    outputCost: 10 / 1e6
+  },
+  "gpt-5.1-codex-max": {
+    inputCost: 1.25 / 1e6,
+    cacheHitCost: 0.125 / 1e6,
+    outputCost: 10 / 1e6
+  }
+};
+var deepseekModelCosts = {
+  "deepseek-chat": {
+    inputCost: 0.27 / 1e6,
+    // $0.27 per 1M tokens (Cache miss price)
+    cacheHitCost: 0.07 / 1e6,
+    // $0.07 per 1M tokens (Cache hit price)
+    outputCost: 1.1 / 1e6
+    // $1.10 per 1M tokens
+  },
+  "deepseek-reasoner": {
+    inputCost: 0.55 / 1e6,
+    // $0.55 per 1M tokens (Cache miss price)
+    cacheHitCost: 0.14 / 1e6,
+    // $0.14 per 1M tokens (Cache hit price)
+    outputCost: 2.19 / 1e6
+    // $2.19 per 1M tokens
+  }
+};
+function shouldUseGPT5HighContextPricing(model, inputTokens) {
+  return (model === "gpt-5.4" || model === "gpt-5.5" || model === "gpt-5.6" || model === "gpt-5.6-sol" || model === "gpt-5.6-terra" || model === "gpt-5.6-luna") && inputTokens > GPT_5_HIGH_CONTEXT_THRESHOLD_TOKENS;
+}
+var DEFAULT_IMAGE_PRICING_QUALITY = "high";
+var DEFAULT_IMAGE_PRICING_SIZE = "1024x1024";
+var openAiImageCostByQualityAndSize = {
+  "gpt-image-2": {
+    low: {
+      "1024x1024": 6e-3,
+      "1024x1536": 5e-3,
+      "1536x1024": 5e-3
+    },
+    medium: {
+      "1024x1024": 0.053,
+      "1024x1536": 0.041,
+      "1536x1024": 0.041
+    },
+    high: {
+      "1024x1024": 0.211,
+      "1024x1536": 0.165,
+      "1536x1024": 0.165
+    }
+  },
+  "gpt-image-2-2026-04-21": {
+    low: {
+      "1024x1024": 6e-3,
+      "1024x1536": 5e-3,
+      "1536x1024": 5e-3
+    },
+    medium: {
+      "1024x1024": 0.053,
+      "1024x1536": 0.041,
+      "1536x1024": 0.041
+    },
+    high: {
+      "1024x1024": 0.211,
+      "1024x1536": 0.165,
+      "1536x1024": 0.165
+    }
+  },
+  "gpt-image-1.5": {
+    low: {
+      "1024x1024": 9e-3,
+      "1024x1536": 0.013,
+      "1536x1024": 0.013
+    },
+    medium: {
+      "1024x1024": 0.034,
+      "1024x1536": 0.05,
+      "1536x1024": 0.05
+    },
+    high: {
+      "1024x1024": 0.133,
+      "1024x1536": 0.2,
+      "1536x1024": 0.2
+    }
+  },
+  "gpt-image-1": {
+    low: {
+      "1024x1024": 0.011,
+      "1024x1536": 0.016,
+      "1536x1024": 0.016
+    },
+    medium: {
+      "1024x1024": 0.042,
+      "1024x1536": 0.063,
+      "1536x1024": 0.063
+    },
+    high: {
+      "1024x1024": 0.167,
+      "1024x1536": 0.25,
+      "1536x1024": 0.25
+    }
+  },
+  "gpt-image-1-mini": {
+    low: {
+      "1024x1024": 5e-3,
+      "1024x1536": 6e-3,
+      "1536x1024": 6e-3
+    },
+    medium: {
+      "1024x1024": 0.011,
+      "1024x1536": 0.015,
+      "1536x1024": 0.015
+    },
+    high: {
+      "1024x1024": 0.036,
+      "1024x1536": 0.052,
+      "1536x1024": 0.052
+    }
+  }
+};
+var openAiImageCosts = {
+  "gpt-image-2": openAiImageCostByQualityAndSize["gpt-image-2"][DEFAULT_IMAGE_PRICING_QUALITY][DEFAULT_IMAGE_PRICING_SIZE],
+  "gpt-image-2-2026-04-21": openAiImageCostByQualityAndSize["gpt-image-2-2026-04-21"][DEFAULT_IMAGE_PRICING_QUALITY][DEFAULT_IMAGE_PRICING_SIZE],
+  "gpt-image-1.5": openAiImageCostByQualityAndSize["gpt-image-1.5"][DEFAULT_IMAGE_PRICING_QUALITY][DEFAULT_IMAGE_PRICING_SIZE],
+  "gpt-image-1": openAiImageCostByQualityAndSize["gpt-image-1"][DEFAULT_IMAGE_PRICING_QUALITY][DEFAULT_IMAGE_PRICING_SIZE],
+  "gpt-image-1-mini": openAiImageCostByQualityAndSize["gpt-image-1-mini"][DEFAULT_IMAGE_PRICING_QUALITY][DEFAULT_IMAGE_PRICING_SIZE]
+};
+function calculateCost(provider, model, inputTokens, outputTokens, reasoningTokens, cacheHitTokens, cacheWriteTokens) {
+  if (typeof provider !== "string" || typeof model !== "string" || typeof inputTokens !== "number" || typeof outputTokens !== "number" || reasoningTokens !== void 0 && typeof reasoningTokens !== "number" || cacheHitTokens !== void 0 && typeof cacheHitTokens !== "number" || cacheWriteTokens !== void 0 && typeof cacheWriteTokens !== "number") {
+    return 0;
+  }
+  const modelCosts = provider === "deepseek" ? deepseekModelCosts[model] : openAiModelCosts[model];
+  if (!modelCosts) return 0;
+  const boundedCacheHitTokens = Math.min(Math.max(cacheHitTokens || 0, 0), inputTokens);
+  const boundedCacheWriteTokens = Math.min(Math.max(cacheWriteTokens || 0, 0), inputTokens - boundedCacheHitTokens);
+  const uncachedInputTokens = inputTokens - boundedCacheHitTokens - boundedCacheWriteTokens;
+  const inputCost = uncachedInputTokens * modelCosts.inputCost + boundedCacheHitTokens * (modelCosts.cacheHitCost || modelCosts.inputCost) + boundedCacheWriteTokens * (modelCosts.cacheWriteCost || modelCosts.inputCost);
+  let outputCost = outputTokens * modelCosts.outputCost;
+  let reasoningCost = (reasoningTokens || 0) * modelCosts.outputCost;
+  if (provider === "openai" && shouldUseGPT5HighContextPricing(model, inputTokens)) {
+    return inputCost * GPT_5_HIGH_CONTEXT_INPUT_MULTIPLIER + outputCost * GPT_5_HIGH_CONTEXT_OUTPUT_MULTIPLIER + reasoningCost * GPT_5_HIGH_CONTEXT_OUTPUT_MULTIPLIER;
+  }
+  return inputCost + outputCost + reasoningCost;
+}
+
+// src/json-tools.ts
+import OpenAI from "openai";
+
+// src/llm-images.ts
+import OpenAI3 from "openai";
+var MULTIMODAL_VISION_MODELS = new Set(OPENAI_MODELS);
+
+// src/llm-deepseek.ts
+import OpenAI4 from "openai";
+
+// src/llm-openrouter.ts
+import OpenAI5 from "openai";
+
+// src/index.ts
+init_alpaca_trading_api();
+init_alpaca_market_data_api();
+init_alpaca_trading_api();
+init_alpaca_market_data_api();
+
+// src/test.ts
+init_logging();
+init_alpaca_market_data_api();
+init_alpaca_trading_api();
+import { z } from "zod";
+var DEBUG_LOGGING2 = process.env["DEBUG"] === "true" || false;
+var log3 = (message, options = { type: "info" }) => {
+  if (!DEBUG_LOGGING2 && options.type === "debug") {
+    return;
+  }
+  log(message, { ...options, source: "Test" });
+};
+function assertNear(actual, expected, label) {
+  const tolerance = 1e-12;
+  if (Math.abs(actual - expected) > tolerance) {
+    throw new Error(`${label} expected ${expected}, received ${actual}`);
+  }
+}
+function testOpenAIModelRegistryAndPricing() {
+  const directModel = "gpt-5.6-terra";
+  const openRouterModel = "openai/gpt-5.4-nano";
+  const gpt56Models = ["gpt-5.6", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"];
+  for (const model of gpt56Models) {
+    if (!isOpenAIModel(model) || !OPENAI_MODELS.includes(model)) {
+      throw new Error(`${model} is missing from direct OpenAI model exports`);
+    }
+  }
+  if (!isOpenRouterModel(openRouterModel) || !OPENROUTER_MODELS.includes(openRouterModel)) {
+    throw new Error(`${openRouterModel} is missing from OpenRouter model exports`);
+  }
+  assertNear(calculateCost("openai", directModel, 1e5, 0), 0.25, "gpt-5.6-terra input pricing");
+  assertNear(calculateCost("openai", directModel, 1e5, 0, 0, 1e5), 0.025, "gpt-5.6-terra cached input pricing");
+  assertNear(calculateCost("openai", directModel, 0, 1e6), 15, "gpt-5.6-terra output pricing");
+  assertNear(calculateCost("openai", directModel, 1e5, 0, 0, 0, 1e5), 0.3125, "gpt-5.6-terra cache-write pricing");
+  assertNear(calculateCost("openai", "gpt-5.6-luna", 1e5, 1e5), 0.7, "gpt-5.6-luna pricing");
+  assertNear(calculateCost("openai", directModel, 1e6, 0), 5, "gpt-5.6-terra long-context input pricing");
+  assertNear(calculateCost("openai", "gpt-5.4-mini", 1e6, 1e6), 5.25, "gpt-5.4-mini pricing");
+  if (DEFAULT_MODEL !== "gpt-5.6-luna") {
+    throw new Error(`Expected gpt-5.6-luna as the default model, received ${DEFAULT_MODEL}`);
+  }
+  log3(`${directModel} registry and pricing test passed`);
+}
+testOpenAIModelRegistryAndPricing();
+//# sourceMappingURL=test.mjs.map