@discomedia/utils 1.0.78 → 1.0.79

package/dist/test.mjs

@@ -1,3 +1,4 @@
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res, err) => function __init() {
   if (err) throw err[0];
@@ -7,6 +8,10 @@ var __esm = (fn, res, err) => function __init() {
     throw err = [e], e;
   }
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/logging.ts
 function log(message, options = { source: "App", type: "info" }) {
@@ -174,6 +179,81 @@ function fromNYTime(date) {
   const utcMillis = nyMillis - offset * 60 * 60 * 1e3;
   return new Date(utcMillis);
 }
+function formatDate(date, outputFormat = "iso") {
+  switch (outputFormat) {
+    case "unix-seconds":
+      return Math.floor(date.getTime() / 1e3);
+    case "unix-ms":
+      return date.getTime();
+    case "iso":
+    default:
+      return date.toISOString();
+  }
+}
+function formatNYLocale(date) {
+  return date.toLocaleString("en-US", { timeZone: "America/New_York" });
+}
+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();
+  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
+  };
+}
+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;
+    }
+  }
+}
 function getLastFullTradingDateImpl(currentDate = /* @__PURE__ */ new Date()) {
   const calendar = new MarketCalendar();
   const nyDate = toNYTime(currentDate);
@@ -204,9 +284,357 @@ function getLastFullTradingDateImpl(currentDate = /* @__PURE__ */ new Date()) {
   const closeMinute = marketCloseMinutes % 60;
   return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
 }
+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 };
+}
+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 * 1e3);
+      break;
+    case "1W":
+      startDate = new Date(endDate.getTime() - 7 * 24 * 60 * 60 * 1e3);
+      break;
+    case "2W":
+      startDate = new Date(endDate.getTime() - 14 * 24 * 60 * 60 * 1e3);
+      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}`);
+  }
+  while (!calendar.isMarketDay(startDate)) {
+    startDate = calendar.getNextMarketDay(startDate);
+  }
+  return startDate;
+}
+function getMarketTimePeriod(params) {
+  const { period, end = /* @__PURE__ */ 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) {
+      const lastMarketDay = calendar.getPreviousMarketDay(end);
+      const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
+      endDate = dayEnd;
+    } else if (isWithinHours) {
+      endDate = end;
+    } else {
+      const { end: dayEnd } = getDayBoundaries(end, intraday_reporting);
+      endDate = dayEnd;
+    }
+  } else {
+    const lastMarketDay = calendar.getPreviousMarketDay(end);
+    const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
+    endDate = dayEnd;
+  }
+  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)
+  };
+}
+function getMarketStatusImpl(date = /* @__PURE__ */ new Date()) {
+  const calendar = new MarketCalendar();
+  const nyDate = toNYTime(date);
+  const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+  const isMarketDay2 = 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 (!isMarketDay2) {
+    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;
+  }
+  const nextStatusTimeDifference = nextStatusTime.getTime() - date.getTime();
+  return {
+    time: date,
+    timeString: formatNYLocale(nyDate),
+    status,
+    nextStatus,
+    marketPeriod,
+    nextStatusTime,
+    nextStatusTimeDifference,
+    nextStatusTimeString: formatNYLocale(nextStatusTime)
+  };
+}
+function getMarketOpenClose(options = {}) {
+  const { date = /* @__PURE__ */ new Date() } = options;
+  return getMarketTimes(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
+  };
+}
 function getLastFullTradingDate(currentDate = /* @__PURE__ */ new Date()) {
   return getLastFullTradingDateImpl(currentDate);
 }
+function getNextMarketDay({ referenceDate } = {}) {
+  const calendar = new MarketCalendar();
+  const startDate = referenceDate ?? /* @__PURE__ */ new Date();
+  const nextDate = calendar.getNextMarketDay(startDate);
+  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()
+  };
+}
+function getPreviousMarketDay({ referenceDate } = {}) {
+  const calendar = new MarketCalendar();
+  const startDate = referenceDate || /* @__PURE__ */ new Date();
+  const prevDate = calendar.getPreviousMarketDay(startDate);
+  const nyPrev = toNYTime(prevDate);
+  const yyyymmdd = `${nyPrev.getUTCFullYear()}-${String(nyPrev.getUTCMonth() + 1).padStart(2, "0")}-${String(
+    nyPrev.getUTCDate()
+  ).padStart(2, "0")}`;
+  return {
+    date: prevDate,
+    yyyymmdd,
+    dateISOString: prevDate.toISOString()
+  };
+}
+function getTradingDate(time) {
+  const date = typeof time === "number" ? new Date(time) : typeof time === "string" ? new Date(time) : time;
+  const nyDate = toNYTime(date);
+  return `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, "0")}-${String(
+    nyDate.getUTCDate()
+  ).padStart(2, "0")}`;
+}
+function getNYTimeZone(date) {
+  const offset = getNYOffset(date || /* @__PURE__ */ new Date());
+  return offset === -4 ? "-04:00" : "-05:00";
+}
+function getOpenCloseForTradingDay(dateStr) {
+  const utcAnchor = /* @__PURE__ */ new Date(`${dateStr}T00:00:00Z`);
+  const nyOffset = getNYTimeZone(utcAnchor);
+  const nyNoon = /* @__PURE__ */ 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 };
+}
+function convertDateToMarketTimeZone(date) {
+  return toNYTime(date);
+}
+function getMarketStatus(options = {}) {
+  const { date = /* @__PURE__ */ new Date() } = options;
+  return getMarketStatusImpl(date);
+}
+function isMarketDay(date) {
+  const calendar = new MarketCalendar();
+  return calendar.isMarketDay(date);
+}
+function getTradingStartAndEndDates(options = {}) {
+  const { endDate = /* @__PURE__ */ new Date(), days = 1 } = options;
+  const calendar = new MarketCalendar();
+  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) {
+    endMarketDay = calendar.getPreviousMarketDay(endDate);
+  } else {
+    endMarketDay = endDate;
+  }
+  const endClose = getMarketOpenClose({ date: endMarketDay }).close;
+  let startMarketDay = endMarketDay;
+  let count = Math.max(1, days);
+  for (let i = 1; i < count; i++) {
+    startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
+  }
+  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 };
+}
+function countTradingDays(startDate, endDate = /* @__PURE__ */ new Date()) {
+  const calendar = new MarketCalendar();
+  if (startDate.getTime() > endDate.getTime()) {
+    throw new Error("Start date must be before end date");
+  }
+  let totalMinutes = 0;
+  const startNY = toNYTime(startDate);
+  const endNY = toNYTime(endDate);
+  const currentNY = new Date(
+    Date.UTC(startNY.getUTCFullYear(), startNY.getUTCMonth(), startNY.getUTCDate(), 0, 0, 0, 0)
+  );
+  while (currentNY.getTime() <= endNY.getTime()) {
+    const currentUTC = fromNYTime(currentNY);
+    if (calendar.isMarketDay(currentUTC)) {
+      const marketTimes = getMarketTimes(currentUTC);
+      if (marketTimes.marketOpen && marketTimes.open && marketTimes.close) {
+        const dayStart = Math.max(startDate.getTime(), marketTimes.open.getTime());
+        const dayEnd = Math.min(endDate.getTime(), marketTimes.close.getTime());
+        if (dayStart < dayEnd) {
+          totalMinutes += (dayEnd - dayStart) / (1e3 * 60);
+        }
+      }
+    }
+    currentNY.setUTCDate(currentNY.getUTCDate() + 1);
+  }
+  const MINUTES_PER_TRADING_DAY = 390;
+  const days = totalMinutes / MINUTES_PER_TRADING_DAY;
+  const hours = totalMinutes / 60;
+  const minutes = totalMinutes;
+  return {
+    days: Math.round(days * 1e3) / 1e3,
+    // Round to 3 decimal places
+    hours: Math.round(hours * 100) / 100,
+    // Round to 2 decimal places
+    minutes: Math.round(minutes)
+  };
+}
+function getTradingDaysBack(options) {
+  const calendar = new MarketCalendar();
+  const { referenceDate, days, includeMostRecentFullDay = true } = options;
+  const refDate = referenceDate || /* @__PURE__ */ new Date();
+  const daysBack = days;
+  if (!Number.isInteger(daysBack) || daysBack < 1) {
+    throw new Error("days must be an integer >= 1");
+  }
+  let targetDate = getLastFullTradingDateImpl(refDate);
+  if (!includeMostRecentFullDay) {
+    targetDate = calendar.getPreviousMarketDay(targetDate);
+  }
+  for (let i = 1; i < daysBack; i++) {
+    targetDate = calendar.getPreviousMarketDay(targetDate);
+  }
+  const marketTimes = getMarketTimes(targetDate);
+  if (!marketTimes.open) {
+    throw new Error(`No market open time for target date`);
+  }
+  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() / 1e3);
+  return {
+    date: dateStr,
+    marketOpenISO,
+    unixTimestamp
+  };
+}
 var MARKET_CONFIG, MarketCalendar, MARKET_TIMES;
 var init_market_time = __esm({
   "src/market-time.ts"() {
@@ -1617,189 +2045,2059 @@ var init_alpaca_market_data_api = __esm({
 
 // src/alpaca-trading-api.ts
 import WebSocket2 from "ws";
+var limitPriceSlippagePercent100, AlpacaRequestError, AlpacaTradingAPI;
 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
-  }
+    limitPriceSlippagePercent100 = 0.1;
+    AlpacaRequestError = class extends Error {
+      method;
+      status;
+      url;
+      responseCode;
+      responseDetails;
+      rawResponse;
+      symbol;
+      constructor(params) {
+        super(params.message);
+        this.name = "AlpacaRequestError";
+        this.method = params.method;
+        this.status = params.status ?? null;
+        this.url = params.url;
+        this.responseCode = params.responseCode ?? null;
+        this.responseDetails = params.responseDetails ?? null;
+        this.rawResponse = params.rawResponse ?? null;
+        this.symbol = params.symbol;
+      }
+    };
+    AlpacaTradingAPI = class _AlpacaTradingAPI {
+      static new(credentials) {
+        return new _AlpacaTradingAPI(credentials);
+      }
+      static getInstance(credentials) {
+        return new _AlpacaTradingAPI(credentials);
+      }
+      ws = null;
+      headers;
+      tradeUpdateCallback = null;
+      credentials;
+      apiBaseUrl;
+      wsUrl;
+      authenticated = false;
+      connecting = false;
+      reconnectDelay = 1e4;
+      // 10 seconds between reconnection attempts
+      reconnectTimeout = null;
+      messageHandlers = /* @__PURE__ */ new Map();
+      debugLogging = false;
+      manualDisconnect = false;
+      /**
+       * Constructor for AlpacaTradingAPI
+       * @param credentials - Alpaca credentials,
+       *   accountName: string; // The account identifier used inthis.logs and tracking
+       *   apiKey: string; // Alpaca API key
+       *   apiSecret: string; // Alpaca API secret
+       *   type: AlpacaAccountType;
+       *   orderType: AlpacaOrderType;
+       * @param options - Optional options
+       *   debugLogging: boolean; // Whether to log messages of type 'debug'
+       */
+      constructor(credentials, options) {
+        this.credentials = credentials;
+        this.apiBaseUrl = credentials.type === "PAPER" ? "https://paper-api.alpaca.markets/v2" : "https://api.alpaca.markets/v2";
+        this.wsUrl = credentials.type === "PAPER" ? "wss://paper-api.alpaca.markets/stream" : "wss://api.alpaca.markets/stream";
+        this.headers = {
+          "APCA-API-KEY-ID": credentials.apiKey,
+          "APCA-API-SECRET-KEY": credentials.apiSecret,
+          "Content-Type": "application/json"
+        };
+        this.messageHandlers.set("authorization", this.handleAuthMessage.bind(this));
+        this.messageHandlers.set("listening", this.handleListenMessage.bind(this));
+        this.messageHandlers.set("trade_updates", this.handleTradeUpdate.bind(this));
+        this.debugLogging = options?.debugLogging || false;
+      }
+      log(message, options = { type: "info" }) {
+        if (this.debugLogging && options.type === "debug") {
+          return;
+        }
+        log(message, { ...options, source: "AlpacaTradingAPI", account: this.credentials.accountName });
+      }
+      /**
+       * Round a price to the nearest 2 decimal places for Alpaca, or 4 decimal places for prices less than $1
+       * @param price - The price to round
+       * @returns The rounded price
+       */
+      roundPriceForAlpaca = (price) => {
+        return price >= 1 ? Math.round(price * 100) / 100 : Math.round(price * 1e4) / 1e4;
+      };
+      isJsonObject(value) {
+        return value !== null && !Array.isArray(value) && typeof value === "object";
+      }
+      parseAlpacaAPIErrorResponse(rawResponse) {
+        if (rawResponse.trim() === "") {
+          return null;
+        }
+        try {
+          const parsedValue = JSON.parse(rawResponse);
+          if (!this.isJsonObject(parsedValue)) {
+            return null;
+          }
+          const code = parsedValue["code"];
+          const message = parsedValue["message"];
+          const symbol = parsedValue["symbol"];
+          if (typeof code !== "number" || typeof message !== "string") {
+            return null;
+          }
+          if (symbol !== void 0 && typeof symbol !== "string") {
+            return null;
+          }
+          return parsedValue;
+        } catch {
+          return null;
+        }
+      }
+      formatJsonValueForLog(value) {
+        if (value === void 0) {
+          return "undefined";
+        }
+        if (Array.isArray(value)) {
+          return value.map((entry) => this.formatJsonValueForLog(entry)).join(", ");
+        }
+        if (value === null) {
+          return "null";
+        }
+        if (typeof value === "object") {
+          return JSON.stringify(value);
+        }
+        return `${value}`;
+      }
+      formatAlpacaAPIErrorDetails(errorResponse) {
+        return Object.entries(errorResponse).filter(([key]) => key !== "code" && key !== "message" && key !== "symbol").map(([key, value]) => `${key}=${this.formatJsonValueForLog(value)}`).join(", ");
+      }
+      formatRequestAction(requestContext) {
+        return requestContext?.action ? `${requestContext.action} failed` : "Alpaca request failed";
+      }
+      buildAlpacaAPIErrorMessage(params) {
+        const { requestContext, status, url, errorResponse, rawResponse } = params;
+        const action = this.formatRequestAction(requestContext);
+        const message = errorResponse?.message ?? (rawResponse || "No error body returned");
+        const responseCode = errorResponse?.code ? ` (code ${errorResponse.code})` : "";
+        const detailSummary = errorResponse ? this.formatAlpacaAPIErrorDetails(errorResponse) : "";
+        const detailText = detailSummary !== "" ? ` Details: ${detailSummary}.` : rawResponse.trim() !== "" && errorResponse === null ? ` Response: ${rawResponse}.` : "";
+        return `${action}: Alpaca API ${status}${responseCode}: ${message}.${detailText} Url: ${url}`;
+      }
+      buildRequestExecutionErrorMessage(params) {
+        const { requestContext, url, errorMessage } = params;
+        const action = this.formatRequestAction(requestContext);
+        return `${action}: ${errorMessage}. Url: ${url}`;
+      }
+      handleAuthMessage(data) {
+        if (data.status === "authorized") {
+          this.authenticated = true;
+          this.log("WebSocket authenticated");
+        } else {
+          this.log(`Authentication failed: ${data.message || "Unknown error"}`, {
+            type: "error"
+          });
+        }
+      }
+      handleListenMessage(data) {
+        if (data.streams?.includes("trade_updates")) {
+          this.log("Successfully subscribed to trade updates");
+        }
+      }
+      handleTradeUpdate(data) {
+        if (this.tradeUpdateCallback) {
+          this.log(
+            `Trade update: ${data.event} to ${data.order.side} ${data.order.qty} shares${data.event === "partial_fill" ? ` (filled shares: ${data.order.filled_qty})` : ""}, type ${data.order.type}`,
+            {
+              symbol: data.order.symbol,
+              type: "debug"
+            }
+          );
+          this.tradeUpdateCallback(data);
+        }
+      }
+      handleMessage(message) {
+        try {
+          const data = JSON.parse(message);
+          const handler = this.messageHandlers.get(data.stream);
+          if (handler) {
+            handler(data.data);
+          } else {
+            this.log(`Received message for unknown stream: ${data.stream}`, {
+              type: "warn"
+            });
+          }
+        } catch (error) {
+          this.log("Failed to parse WebSocket message", {
+            type: "error",
+            metadata: { error: error instanceof Error ? error.message : "Unknown error" }
+          });
+        }
+      }
+      connectWebsocket() {
+        this.manualDisconnect = false;
+        if (this.connecting) {
+          this.log("Connection attempt skipped - already connecting");
+          return;
+        }
+        if (this.ws?.readyState === WebSocket2.OPEN) {
+          this.log("Connection attempt skipped - already connected");
+          return;
+        }
+        this.connecting = true;
+        if (this.ws) {
+          this.ws.removeAllListeners();
+          this.ws.terminate();
+          this.ws = null;
+        }
+        this.log(`Connecting to WebSocket at ${this.wsUrl}...`);
+        this.ws = new WebSocket2(this.wsUrl);
+        this.ws.on("open", async () => {
+          try {
+            this.log("WebSocket connected");
+            await this.authenticate();
+            await this.subscribeToTradeUpdates();
+            this.connecting = false;
+          } catch (error) {
+            this.log("Failed to setup WebSocket connection", {
+              type: "error",
+              metadata: { error: error instanceof Error ? error.message : "Unknown error" }
+            });
+            this.ws?.close();
+          }
+        });
+        this.ws.on("message", (data) => {
+          this.handleMessage(data.toString());
+        });
+        this.ws.on("error", (error) => {
+          this.log("WebSocket error", {
+            type: "error",
+            metadata: { error: error instanceof Error ? error.message : "Unknown error" }
+          });
+          this.connecting = false;
+        });
+        this.ws.on("close", () => {
+          this.log("WebSocket connection closed");
+          this.authenticated = false;
+          this.connecting = false;
+          if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+          }
+          if (!this.manualDisconnect) {
+            this.reconnectTimeout = setTimeout(() => {
+              this.log("Attempting to reconnect...");
+              this.connectWebsocket();
+            }, this.reconnectDelay);
+          }
+        });
+      }
+      /**
+       * Cleanly disconnect from the WebSocket and stop auto-reconnects
+       */
+      disconnect() {
+        this.manualDisconnect = true;
+        if (this.reconnectTimeout) {
+          clearTimeout(this.reconnectTimeout);
+          this.reconnectTimeout = null;
+        }
+        if (this.ws) {
+          this.log("Disconnecting WebSocket...");
+          this.ws.removeAllListeners();
+          try {
+            if (this.ws.readyState === WebSocket2.OPEN || this.ws.readyState === WebSocket2.CONNECTING) {
+              this.ws.close(1e3, "Client disconnect");
+            } else {
+              this.ws.terminate();
+            }
+          } catch {
+            try {
+              this.ws.terminate();
+            } catch {
+            }
+          }
+          this.ws = null;
+        }
+        this.authenticated = false;
+        this.connecting = false;
+        this.log("WebSocket disconnected");
+      }
+      async authenticate() {
+        if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) {
+          throw new Error("WebSocket not ready for authentication");
+        }
+        const authMessage = {
+          action: "auth",
+          key: this.credentials.apiKey,
+          secret: this.credentials.apiSecret
+        };
+        this.ws.send(JSON.stringify(authMessage));
+        return new Promise((resolve, reject) => {
+          const authTimeout = setTimeout(() => {
+            this.log("Authentication timeout", { type: "error" });
+            reject(new Error("Authentication timed out"));
+          }, 1e4);
+          const handleAuthResponse = (data) => {
+            try {
+              const message = JSON.parse(data.toString());
+              if (message.stream === "authorization") {
+                this.ws?.removeListener("message", handleAuthResponse);
+                clearTimeout(authTimeout);
+                if (message.data?.status === "authorized") {
+                  this.authenticated = true;
+                  resolve();
+                } else {
+                  const error = `Authentication failed: ${message.data?.message || "Unknown error"}`;
+                  this.log(error, { type: "error" });
+                  reject(new Error(error));
+                }
+              }
+            } catch (error) {
+              this.log("Failed to parse auth response", {
+                type: "error",
+                metadata: { error: error instanceof Error ? error.message : "Unknown error" }
+              });
+            }
+          };
+          this.ws?.on("message", handleAuthResponse);
+        });
+      }
+      async subscribeToTradeUpdates() {
+        if (!this.ws || this.ws.readyState !== WebSocket2.OPEN || !this.authenticated) {
+          throw new Error("WebSocket not ready for subscription");
+        }
+        const listenMessage = {
+          action: "listen",
+          data: {
+            streams: ["trade_updates"]
+          }
+        };
+        this.ws.send(JSON.stringify(listenMessage));
+        return new Promise((resolve, reject) => {
+          const listenTimeout = setTimeout(() => {
+            reject(new Error("Subscribe timeout"));
+          }, 1e4);
+          const handleListenResponse = (data) => {
+            try {
+              const message = JSON.parse(data.toString());
+              if (message.stream === "listening") {
+                this.ws?.removeListener("message", handleListenResponse);
+                clearTimeout(listenTimeout);
+                if (message.data?.streams?.includes("trade_updates")) {
+                  resolve();
+                } else {
+                  reject(new Error("Failed to subscribe to trade updates"));
+                }
+              }
+            } catch (error) {
+              this.log("Failed to parse listen response", {
+                type: "error",
+                metadata: { error: error instanceof Error ? error.message : "Unknown error" }
+              });
+            }
+          };
+          this.ws?.on("message", handleListenResponse);
+        });
+      }
+      async makeRequest(endpoint, method = "GET", body, queryString = "", requestContext) {
+        const url = `${this.apiBaseUrl}${endpoint}${queryString}`;
+        try {
+          const response = await fetch(url, {
+            method,
+            headers: this.headers,
+            body: body ? JSON.stringify(body) : void 0
+          });
+          if (!response.ok) {
+            const rawResponse = await response.text();
+            const errorResponse = this.parseAlpacaAPIErrorResponse(rawResponse);
+            const symbol = requestContext?.symbol ?? errorResponse?.symbol;
+            const error = new AlpacaRequestError({
+              message: this.buildAlpacaAPIErrorMessage({
+                requestContext,
+                status: response.status,
+                url,
+                errorResponse,
+                rawResponse
+              }),
+              method,
+              status: response.status,
+              url,
+              responseCode: errorResponse?.code ?? null,
+              responseDetails: errorResponse,
+              rawResponse,
+              symbol
+            });
+            this.log(error.message, { symbol, type: "error" });
+            throw error;
+          }
+          if (response.status === 204 || response.headers.get("content-length") === "0") {
+            return null;
+          }
+          const contentType = response.headers.get("content-type");
+          if (contentType && contentType.includes("application/json")) {
+            return await response.json();
+          }
+          const textContent = await response.text();
+          return textContent || null;
+        } catch (error) {
+          if (error instanceof AlpacaRequestError) {
+            throw error;
+          }
+          const normalizedError = error instanceof Error ? error : new Error(`${error}`);
+          const symbol = requestContext?.symbol;
+          const requestError = new AlpacaRequestError({
+            message: this.buildRequestExecutionErrorMessage({
+              requestContext,
+              url,
+              errorMessage: normalizedError.message
+            }),
+            method,
+            url,
+            rawResponse: null,
+            symbol
+          });
+          this.log(requestError.message, { symbol, type: "error" });
+          throw requestError;
+        }
+      }
+      async getPositions(assetClass) {
+        const positions = await this.makeRequest("/positions", "GET", void 0, "", {
+          action: "Get positions"
+        });
+        if (assetClass) {
+          return positions.filter((position) => position.asset_class === assetClass);
+        }
+        return positions;
+      }
+      /**
+       * Get all orders
+       * @param params (GetOrdersParams) - optional parameters to filter the orders
+       * - status: 'open' | 'closed' | 'all'
+       * - limit: number
+       * - after: string
+       * - until: string
+       * - direction: 'asc' | 'desc'
+       * - nested: boolean
+       * - symbols: string[], an array of all the symbols
+       * - side: 'buy' | 'sell'
+       * @returns all orders
+       */
+      async getOrders(params = {}) {
+        const queryParams = new URLSearchParams();
+        if (params.status) queryParams.append("status", params.status);
+        if (params.limit) queryParams.append("limit", params.limit.toString());
+        if (params.after) queryParams.append("after", params.after);
+        if (params.until) queryParams.append("until", params.until);
+        if (params.direction) queryParams.append("direction", params.direction);
+        if (params.nested) queryParams.append("nested", params.nested.toString());
+        if (params.symbols) queryParams.append("symbols", params.symbols.join(","));
+        if (params.side) queryParams.append("side", params.side);
+        const endpoint = `/orders${queryParams.toString() ? `?${queryParams.toString()}` : ""}`;
+        return this.makeRequest(endpoint, "GET", void 0, "", {
+          action: "Get orders",
+          symbol: params.symbols?.join(",")
+        });
+      }
+      async getAccountDetails() {
+        return this.makeRequest("/account", "GET", void 0, "", {
+          action: "Get account details"
+        });
+      }
+      /**
+       * Create a trailing stop order
+       * @param symbol (string) - the symbol of the order
+       * @param qty (number) - the quantity of the order
+       * @param side (string) - the side of the order
+       * @param trailPercent100 (number) - the trail percent of the order (scale 100, i.e. 0.5 = 0.5%)
+       * @param position_intent (string) - the position intent of the order
+       * @param client_order_id (string) - optional client order id
+       * @returns The created trailing stop order
+       */
+      async createTrailingStop(symbol, qty, side, trailPercent100, position_intent, client_order_id) {
+        this.log(
+          `Creating trailing stop ${side.toUpperCase()} ${qty} shares for ${symbol} with trail percent ${trailPercent100}%`,
+          {
+            symbol
+          }
+        );
+        const body = {
+          symbol,
+          qty: Math.abs(qty).toString(),
+          side,
+          position_intent,
+          order_class: "simple",
+          type: "trailing_stop",
+          trail_percent: trailPercent100.toString(),
+          time_in_force: "gtc"
+        };
+        if (client_order_id !== void 0) {
+          body.client_order_id = client_order_id;
+        }
+        return this.makeRequest("/orders", "POST", body, "", {
+          action: "Create trailing stop order",
+          symbol
+        });
+      }
+      /**
+       * Create a stop order (stop or stop-limit)
+       * @param symbol (string) - the symbol of the order
+       * @param qty (number) - the quantity of the order
+       * @param side (string) - the side of the order
+       * @param stopPrice (number) - the stop price that triggers the order
+       * @param position_intent (string) - the position intent of the order
+       * @param limitPrice (number) - optional limit price (if provided, creates a stop-limit order)
+       * @param client_order_id (string) - optional client order id
+       * @returns The created stop order
+       */
+      async createStopOrder(symbol, qty, side, stopPrice, position_intent, limitPrice, client_order_id) {
+        const isStopLimit = limitPrice !== void 0;
+        const orderType = isStopLimit ? "stop-limit" : "stop";
+        this.log(
+          `Creating ${orderType} ${side.toUpperCase()} ${qty} shares for ${symbol} with stop price ${stopPrice}${isStopLimit ? ` and limit price ${limitPrice}` : ""}`,
+          {
+            symbol
+          }
+        );
+        const body = {
+          symbol,
+          qty: Math.abs(qty).toString(),
+          side,
+          position_intent,
+          order_class: "simple",
+          type: isStopLimit ? "stop_limit" : "stop",
+          stop_price: this.roundPriceForAlpaca(stopPrice).toString(),
+          time_in_force: "gtc"
+        };
+        if (limitPrice !== void 0) {
+          body.limit_price = this.roundPriceForAlpaca(limitPrice).toString();
+        }
+        if (client_order_id !== void 0) {
+          body.client_order_id = client_order_id;
+        }
+        return this.makeRequest("/orders", "POST", body, "", {
+          action: `Create ${orderType} order`,
+          symbol
+        });
+      }
+      /**
+       * Create a market order
+       * @param symbol (string) - the symbol of the order
+       * @param qty (number) - the quantity of the order
+       * @param side (string) - the side of the order
+       * @param position_intent (string) - the position intent of the order. Important for knowing if a position needs a trailing stop.
+       * @param client_order_id (string) - optional client order id
+       */
+      async createMarketOrder(symbol, qty, side, position_intent, client_order_id) {
+        this.log(`Creating market order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
+          symbol
+        });
+        const body = {
+          symbol,
+          qty: Math.abs(qty).toString(),
+          side,
+          position_intent,
+          type: "market",
+          time_in_force: "day",
+          order_class: "simple"
+        };
+        if (client_order_id !== void 0) {
+          body.client_order_id = client_order_id;
+        }
+        return this.makeRequest("/orders", "POST", body, "", {
+          action: "Create market order",
+          symbol
+        });
+      }
+      /**
+       * 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 !== void 0) {
+          body.client_order_id = client_order_id;
+        }
+        return this.makeRequest("/orders", "POST", body, "", {
+          action: "Create market on open order",
+          symbol
+        });
+      }
+      /**
+       * 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 !== void 0) {
+          body.client_order_id = client_order_id;
+        }
+        return this.makeRequest("/orders", "POST", body, "", {
+          action: "Create market on close order",
+          symbol
+        });
+      }
+      /**
+       * Create an OCO (One-Cancels-Other) order with take profit and stop loss
+       * @param symbol (string) - the symbol of the order
+       * @param qty (number) - the quantity of the order
+       * @param side (string) - the side of the order (buy or sell)
+       * @param position_intent (string) - the position intent of the order
+       * @param limitPrice (number) - the limit price for the entry order (OCO orders must be limit orders)
+       * @param takeProfitPrice (number) - the take profit price
+       * @param stopLossPrice (number) - the stop loss price
+       * @param stopLossLimitPrice (number) - optional limit price for stop loss (creates stop-limit instead of stop)
+       * @param client_order_id (string) - optional client order id
+       * @returns The created OCO order
+       */
+      async createOCOOrder(symbol, qty, side, position_intent, limitPrice, takeProfitPrice, stopLossPrice, stopLossLimitPrice, client_order_id) {
+        this.log(
+          `Creating OCO order ${side.toUpperCase()} ${qty} shares for ${symbol} at limit ${limitPrice} with take profit ${takeProfitPrice} and stop loss ${stopLossPrice}`,
+          {
+            symbol
+          }
+        );
+        const body = {
+          symbol,
+          qty: Math.abs(qty).toString(),
+          side,
+          position_intent,
+          order_class: "oco",
+          type: "limit",
+          limit_price: this.roundPriceForAlpaca(limitPrice).toString(),
+          time_in_force: "gtc",
+          take_profit: {
+            limit_price: this.roundPriceForAlpaca(takeProfitPrice).toString()
+          },
+          stop_loss: {
+            stop_price: this.roundPriceForAlpaca(stopLossPrice).toString()
+          }
+        };
+        if (stopLossLimitPrice !== void 0) {
+          body.stop_loss = {
+            stop_price: this.roundPriceForAlpaca(stopLossPrice).toString(),
+            limit_price: this.roundPriceForAlpaca(stopLossLimitPrice).toString()
+          };
+        }
+        if (client_order_id !== void 0) {
+          body.client_order_id = client_order_id;
+        }
+        return this.makeRequest("/orders", "POST", body, "", {
+          action: "Create OCO order",
+          symbol
+        });
+      }
+      /**
+       * Get the current trail percent for a symbol, assuming that it has an open position and a trailing stop order to close it. Because this relies on an orders request for one symbol, you can't do it too often.
+       * @param symbol (string) - the symbol of the order
+       * @returns the current trail percent
+       */
+      async getCurrentTrailPercent(symbol) {
+        const orders = await this.getOrders({
+          status: "open",
+          symbols: [symbol]
+        });
+        const trailingStopOrder = orders.find(
+          (order) => order.type === "trailing_stop" && (order.position_intent === "sell_to_close" || order.position_intent === "buy_to_close")
+        );
+        if (!trailingStopOrder) {
+          this.log(`No closing trailing stop order found for ${symbol}`, {
+            symbol
+          });
+          return null;
+        }
+        if (!trailingStopOrder.trail_percent) {
+          this.log(`Trailing stop order found for ${symbol} but no trail_percent value`, {
+            symbol
+          });
+          return null;
+        }
+        const trailPercent = parseFloat(trailingStopOrder.trail_percent);
+        return trailPercent;
+      }
+      /**
+       * Update the trail percent for a trailing stop order
+       * @param symbol (string) - the symbol of the order
+       * @param trailPercent100 (number) - the trail percent of the order (scale 100, i.e. 0.5 = 0.5%)
+       */
+      async updateTrailingStop(symbol, trailPercent100) {
+        const orders = await this.getOrders({
+          status: "open",
+          symbols: [symbol]
+        });
+        const trailingStopOrder = orders.find((order) => order.type === "trailing_stop");
+        if (!trailingStopOrder) {
+          this.log(`No open trailing stop order found for ${symbol}`, { type: "error", symbol });
+          return;
+        }
+        const currentTrailPercent = trailingStopOrder.trail_percent ? parseFloat(trailingStopOrder.trail_percent) : null;
+        const epsilon = 1e-4;
+        if (currentTrailPercent !== null && Math.abs(currentTrailPercent - trailPercent100) < epsilon) {
+          this.log(
+            `Trailing stop for ${symbol} already set to ${trailPercent100}% (current: ${currentTrailPercent}%), skipping update`,
+            {
+              symbol
+            }
+          );
+          return;
+        }
+        this.log(`Updating trailing stop for ${symbol} from ${currentTrailPercent}% to ${trailPercent100}%`, {
+          symbol
+        });
+        await this.makeRequest(
+          `/orders/${trailingStopOrder.id}`,
+          "PATCH",
+          { trail: trailPercent100.toString() },
+          "",
+          {
+            action: "Update trailing stop order",
+            symbol
+          }
+        );
+      }
+      /**
+       * Cancel all open orders
+       */
+      async cancelAllOrders() {
+        this.log(`Canceling all open orders`);
+        try {
+          await this.makeRequest("/orders", "DELETE", void 0, "", {
+            action: "Cancel all open orders"
+          });
+        } catch (error) {
+          if (!(error instanceof AlpacaRequestError)) {
+            this.log(`Error canceling all orders: ${error instanceof Error ? error.message : `${error}`}`, {
+              type: "error"
+            });
+          }
+        }
+      }
+      /**
+       * Cancel a specific order by its ID
+       * @param orderId The id of the order to cancel
+       * @throws Error if the order is not cancelable (status 422) or if the order doesn't exist
+       * @returns Promise that resolves when the order is successfully canceled
+       */
+      async cancelOrder(orderId) {
+        this.log(`Attempting to cancel order ${orderId}`);
+        try {
+          await this.makeRequest(`/orders/${orderId}`, "DELETE", void 0, "", {
+            action: `Cancel order ${orderId}`
+          });
+          this.log(`Successfully canceled order ${orderId}`);
+        } catch (error) {
+          if (error instanceof AlpacaRequestError && error.status === 422) {
+            throw new Error(`Order ${orderId} is not cancelable`);
+          }
+          throw error;
+        }
+      }
+      /**
+       * Create a limit order
+       * @param symbol (string) - the symbol of the order
+       * @param qty (number) - the quantity of the order
+       * @param side (string) - the side of the order
+       * @param limitPrice (number) - the limit price of the order
+       * @param position_intent (string) - the position intent of the order
+       * @param extended_hours (boolean) - whether the order is in extended hours
+       * @param client_order_id (string) - the client order id of the order
+       */
+      async createLimitOrder(symbol, qty, side, limitPrice, position_intent, extended_hours = false, client_order_id) {
+        this.log(
+          `Creating limit order for ${symbol}: ${side} ${qty} shares at $${limitPrice.toFixed(2)} (${position_intent})`,
+          {
+            symbol
+          }
+        );
+        const body = {
+          symbol,
+          qty: Math.abs(qty).toString(),
+          side,
+          position_intent,
+          type: "limit",
+          limit_price: this.roundPriceForAlpaca(limitPrice).toString(),
+          time_in_force: "day",
+          order_class: "simple",
+          extended_hours
+        };
+        if (client_order_id !== void 0) {
+          body.client_order_id = client_order_id;
+        }
+        return this.makeRequest("/orders", "POST", body, "", {
+          action: "Create limit order",
+          symbol
+        });
+      }
+      /**
+       * Close all equities positions
+       * @param options (object) - the options for closing the positions
+       * - cancel_orders (boolean) - whether to cancel related orders
+       * - useLimitOrders (boolean) - whether to use limit orders to close the positions
+       */
+      async closeAllPositions(options = { cancel_orders: true, useLimitOrders: false }) {
+        this.log(
+          `Closing all positions${options.useLimitOrders ? " using limit orders" : ""}${options.cancel_orders ? " and canceling open orders" : ""}`
+        );
+        if (options.useLimitOrders) {
+          const positions = await this.getPositions("us_equity");
+          if (positions.length === 0) {
+            this.log("No positions to close");
+            return;
+          }
+          this.log(`Found ${positions.length} positions to close`);
+          const symbols = positions.map((position) => position.symbol);
+          const quotesResponse = await marketDataAPI.getLatestQuotes(symbols);
+          const lengthOfQuotes = Object.keys(quotesResponse.quotes).length;
+          if (lengthOfQuotes === 0) {
+            this.log("No quotes available for positions, received 0 quotes", {
+              type: "error"
+            });
+            return;
+          }
+          if (lengthOfQuotes !== positions.length) {
+            this.log(
+              `Received ${lengthOfQuotes} quotes for ${positions.length} positions, expected ${positions.length} quotes`,
+              { type: "warn" }
+            );
+            return;
+          }
+          for (const position of positions) {
+            const quote = quotesResponse.quotes[position.symbol];
+            if (!quote) {
+              this.log(`No quote available for ${position.symbol}, skipping limit order`, {
+                symbol: position.symbol,
+                type: "warn"
+              });
+              continue;
+            }
+            const qty = Math.abs(parseFloat(position.qty));
+            const side = position.side === "long" ? "sell" : "buy";
+            const positionIntent = side === "sell" ? "sell_to_close" : "buy_to_close";
+            const currentPrice = side === "sell" ? quote.bp : quote.ap;
+            if (!currentPrice) {
+              this.log(`No valid price available for ${position.symbol}, skipping limit order`, {
+                symbol: position.symbol,
+                type: "warn"
+              });
+              continue;
+            }
+            const limitSlippagePercent1 = limitPriceSlippagePercent100 / 100;
+            const limitPrice = side === "sell" ? this.roundPriceForAlpaca(currentPrice * (1 - limitSlippagePercent1)) : this.roundPriceForAlpaca(currentPrice * (1 + limitSlippagePercent1));
+            this.log(
+              `Creating limit order to close ${position.symbol} position: ${side} ${qty} shares at $${limitPrice.toFixed(
+                2
+              )}`,
+              {
+                symbol: position.symbol
+              }
+            );
+            await this.createLimitOrder(position.symbol, qty, side, limitPrice, positionIntent);
+          }
+        } else {
+          await this.makeRequest("/positions", "DELETE", void 0, options.cancel_orders ? "?cancel_orders=true" : "", {
+            action: "Close all positions"
+          });
+        }
+      }
+      /**
+       * Close all equities positions using limit orders during extended hours trading
+       * @param cancelOrders Whether to cancel related orders (default: true)
+       * @returns Promise that resolves when all positions are closed
+       */
+      async closeAllPositionsAfterHours() {
+        this.log("Closing all positions using limit orders during extended hours trading");
+        const positions = await this.getPositions();
+        this.log(`Found ${positions.length} positions to close`);
+        if (positions.length === 0) {
+          this.log("No positions to close");
+          return;
+        }
+        await this.cancelAllOrders();
+        this.log(`Cancelled all open orders`);
+        const symbols = positions.map((position) => position.symbol);
+        const quotesResponse = await marketDataAPI.getLatestQuotes(symbols);
+        for (const position of positions) {
+          const quote = quotesResponse.quotes[position.symbol];
+          if (!quote) {
+            this.log(`No quote available for ${position.symbol}, skipping limit order`, {
+              symbol: position.symbol,
+              type: "warn"
+            });
+            continue;
+          }
+          const qty = Math.abs(parseFloat(position.qty));
+          const side = position.side === "long" ? "sell" : "buy";
+          const positionIntent = side === "sell" ? "sell_to_close" : "buy_to_close";
+          const currentPrice = side === "sell" ? quote.bp : quote.ap;
+          if (!currentPrice) {
+            this.log(`No valid price available for ${position.symbol}, skipping limit order`, {
+              symbol: position.symbol,
+              type: "warn"
+            });
+            continue;
+          }
+          const limitSlippagePercent1 = limitPriceSlippagePercent100 / 100;
+          const limitPrice = side === "sell" ? this.roundPriceForAlpaca(currentPrice * (1 - limitSlippagePercent1)) : this.roundPriceForAlpaca(currentPrice * (1 + limitSlippagePercent1));
+          this.log(
+            `Creating extended hours limit order to close ${position.symbol} position: ${side} ${qty} shares at $${limitPrice.toFixed(2)}`,
+            {
+              symbol: position.symbol
+            }
+          );
+          await this.createLimitOrder(
+            position.symbol,
+            qty,
+            side,
+            limitPrice,
+            positionIntent,
+            true
+            // Enable extended hours trading
+          );
+        }
+        this.log(`All positions closed: ${positions.map((p) => p.symbol).join(", ")}`);
+      }
+      onTradeUpdate(callback) {
+        this.tradeUpdateCallback = callback;
+      }
+      /**
+       * Get portfolio history for the account
+       * @param params Parameters for the portfolio history request
+       * @returns Portfolio history data
+       */
+      async getPortfolioHistory(params) {
+        const queryParams = new URLSearchParams();
+        if (params.timeframe) queryParams.append("timeframe", params.timeframe);
+        if (params.period) queryParams.append("period", params.period);
+        if (params.extended_hours !== void 0) queryParams.append("extended_hours", params.extended_hours.toString());
+        if (params.start) queryParams.append("start", params.start);
+        if (params.end) queryParams.append("end", params.end);
+        if (params.date_end) queryParams.append("date_end", params.date_end);
+        const response = await this.makeRequest(
+          `/account/portfolio/history?${queryParams.toString()}`,
+          "GET",
+          void 0,
+          "",
+          {
+            action: "Get portfolio history"
+          }
+        );
+        return response;
+      }
+      /**
+       * Get portfolio daily history for the account, ensuring the most recent day is included
+       * by combining daily and hourly history if needed.
+       *
+       * This function performs two API calls:
+       * 1. Retrieves daily portfolio history
+       * 2. Retrieves hourly portfolio history to check for more recent data
+       *
+       * If hourly history has timestamps more recent than the last timestamp in daily history,
+       * it appends one additional day to the daily history using the most recent hourly values.
+       *
+       * @param params Parameters for the portfolio history request (same as getPortfolioHistory except timeframe is forced to '1D')
+       * @returns Portfolio history data with daily timeframe, including the most recent day if available from hourly data
+       */
+      async getPortfolioDailyHistory(params) {
+        const dailyParams = { ...params, timeframe: "1D" };
+        const hourlyParams = { timeframe: "1Min", period: "1D" };
+        const [dailyHistory, hourlyHistory] = await Promise.all([
+          this.getPortfolioHistory(dailyParams),
+          this.getPortfolioHistory(hourlyParams)
+        ]);
+        if (!hourlyHistory.timestamp || hourlyHistory.timestamp.length === 0) {
+          return dailyHistory;
+        }
+        const lastDailyTimestamp = dailyHistory.timestamp[dailyHistory.timestamp.length - 1];
+        const recentHourlyData = hourlyHistory.timestamp.map((timestamp, index) => ({ timestamp, index })).filter(({ timestamp }) => timestamp > lastDailyTimestamp);
+        if (recentHourlyData.length === 0) {
+          return dailyHistory;
+        }
+        const mostRecentHourly = recentHourlyData[recentHourlyData.length - 1];
+        const mostRecentIndex = mostRecentHourly.index;
+        const mostRecentMs = mostRecentHourly.timestamp * 1e3;
+        const tradingDateStr = getTradingDate(new Date(mostRecentMs));
+        const [yearStr, monthStr, dayStr] = tradingDateStr.split("-");
+        const year = Number(yearStr);
+        const month = Number(monthStr);
+        const day = Number(dayStr);
+        const newDailyTimestamp = Math.floor(Date.UTC(year, month - 1, day + 1, 0, 0, 0, 0) / 1e3);
+        const updatedDailyHistory = {
+          ...dailyHistory,
+          timestamp: [...dailyHistory.timestamp, newDailyTimestamp],
+          equity: [...dailyHistory.equity, hourlyHistory.equity[mostRecentIndex]],
+          profit_loss: [...dailyHistory.profit_loss, hourlyHistory.profit_loss[mostRecentIndex]],
+          profit_loss_pct: [...dailyHistory.profit_loss_pct, hourlyHistory.profit_loss_pct[mostRecentIndex]]
+        };
+        return updatedDailyHistory;
+      }
+      /**
+       * Get option contracts based on specified parameters
+       * @param params Parameters to filter option contracts
+       * @returns Option contracts matching the criteria
+       */
+      async getOptionContracts(params) {
+        const queryParams = new URLSearchParams();
+        queryParams.append("underlying_symbols", params.underlying_symbols.join(","));
+        if (params.expiration_date_gte) queryParams.append("expiration_date_gte", params.expiration_date_gte);
+        if (params.expiration_date_lte) queryParams.append("expiration_date_lte", params.expiration_date_lte);
+        if (params.strike_price_gte) queryParams.append("strike_price_gte", params.strike_price_gte);
+        if (params.strike_price_lte) queryParams.append("strike_price_lte", params.strike_price_lte);
+        if (params.type) queryParams.append("type", params.type);
+        if (params.status) queryParams.append("status", params.status);
+        if (params.limit) queryParams.append("limit", params.limit.toString());
+        if (params.page_token) queryParams.append("page_token", params.page_token);
+        this.log(`Fetching option contracts for ${params.underlying_symbols.join(", ")}`, {
+          symbol: params.underlying_symbols.join(", ")
+        });
+        const response = await this.makeRequest(
+          `/options/contracts?${queryParams.toString()}`,
+          "GET",
+          void 0,
+          "",
+          {
+            action: "Get option contracts",
+            symbol: params.underlying_symbols.join(", ")
+          }
+        );
+        this.log(`Found ${response.option_contracts.length} option contracts`, {
+          symbol: params.underlying_symbols.join(", ")
+        });
+        return response;
+      }
+      /**
+       * Get a specific option contract by symbol or ID
+       * @param symbolOrId The symbol or ID of the option contract
+       * @returns The option contract details
+       */
+      async getOptionContract(symbolOrId) {
+        this.log(`Fetching option contract details for ${symbolOrId}`, {
+          symbol: symbolOrId
+        });
+        const response = await this.makeRequest(`/options/contracts/${symbolOrId}`, "GET", void 0, "", {
+          action: "Get option contract details",
+          symbol: symbolOrId
+        });
+        this.log(`Found option contract details for ${symbolOrId}: ${response.name}`, {
+          symbol: symbolOrId
+        });
+        return response;
+      }
+      /**
+       * Create a simple option order (market or limit)
+       * @param symbol Option contract symbol
+       * @param qty Quantity of contracts (must be a whole number)
+       * @param side Buy or sell
+       * @param position_intent Position intent (buy_to_open, buy_to_close, sell_to_open, sell_to_close)
+       * @param type Order type (market or limit)
+       * @param limitPrice Limit price (required for limit orders)
+       * @returns The created order
+       */
+      async createOptionOrder(symbol, qty, side, position_intent, type, limitPrice) {
+        if (!Number.isInteger(qty) || qty <= 0) {
+          this.log("Quantity must be a positive whole number for option orders", { symbol, type: "error" });
+        }
+        if (type === "limit" && limitPrice === void 0) {
+          this.log("Limit price is required for limit orders", { symbol, type: "error" });
+        }
+        this.log(
+          `Creating ${type} option order for ${symbol}: ${side} ${qty} contracts (${position_intent})${type === "limit" ? ` at $${limitPrice?.toFixed(2)}` : ""}`,
+          {
+            symbol
+          }
+        );
+        const orderData = {
+          symbol,
+          qty: qty.toString(),
+          side,
+          position_intent,
+          type,
+          time_in_force: "day",
+          order_class: "simple",
+          extended_hours: false
+        };
+        if (type === "limit" && limitPrice !== void 0) {
+          orderData.limit_price = this.roundPriceForAlpaca(limitPrice).toString();
+        }
+        return this.makeRequest("/orders", "POST", orderData, "", {
+          action: "Create option order",
+          symbol
+        });
+      }
+      /**
+       * Create a multi-leg option order
+       * @param legs Array of order legs
+       * @param qty Quantity of the multi-leg order (must be a whole number)
+       * @param type Order type (market or limit)
+       * @param limitPrice Limit price (required for limit orders)
+       * @returns The created multi-leg order
+       */
+      async createMultiLegOptionOrder(legs, qty, type, limitPrice) {
+        const legSymbols = legs.map((leg) => leg.symbol).join(", ");
+        if (!Number.isInteger(qty) || qty <= 0) {
+          this.log("Quantity must be a positive whole number for option orders", {
+            symbol: legSymbols,
+            type: "error"
+          });
+        }
+        if (type === "limit" && limitPrice === void 0) {
+          this.log("Limit price is required for limit orders", { symbol: legSymbols, type: "error" });
+        }
+        if (legs.length < 2) {
+          this.log("Multi-leg orders require at least 2 legs", { symbol: legSymbols, type: "error" });
+        }
+        this.log(
+          `Creating multi-leg ${type} option order with ${legs.length} legs (${legSymbols})${type === "limit" ? ` at $${limitPrice?.toFixed(2)}` : ""}`,
+          {
+            symbol: legSymbols
+          }
+        );
+        const orderData = {
+          order_class: "mleg",
+          qty: qty.toString(),
+          type,
+          time_in_force: "day",
+          legs
+        };
+        if (type === "limit" && limitPrice !== void 0) {
+          orderData.limit_price = this.roundPriceForAlpaca(limitPrice).toString();
+        }
+        return this.makeRequest("/orders", "POST", orderData, "", {
+          action: "Create multi-leg option order",
+          symbol: legSymbols
+        });
+      }
+      /**
+       * Exercise an option contract
+       * @param symbolOrContractId The symbol or ID of the option contract to exercise
+       * @returns Response from the exercise request
+       */
+      async exerciseOption(symbolOrContractId) {
+        this.log(`Exercising option contract ${symbolOrContractId}`, {
+          symbol: symbolOrContractId
+        });
+        return this.makeRequest(`/positions/${symbolOrContractId}/exercise`, "POST", void 0, "", {
+          action: "Exercise option contract",
+          symbol: symbolOrContractId
+        });
+      }
+      /**
+       * Get option positions
+       * @returns Array of option positions
+       */
+      async getOptionPositions() {
+        this.log("Fetching option positions");
+        const positions = await this.getPositions("us_option");
+        return positions;
+      }
+      async getOptionsOpenSpreadTrades() {
+        this.log("Fetching option open trades");
+      }
+      /**
+       * Get option account activities (exercises, assignments, expirations)
+       * @param activityType Type of option activity to filter by
+       * @param date Date to filter activities (YYYY-MM-DD format)
+       * @returns Array of option account activities
+       */
+      async getOptionActivities(activityType, date) {
+        const queryParams = new URLSearchParams();
+        if (activityType) {
+          queryParams.append("activity_types", activityType);
+        } else {
+          queryParams.append("activity_types", "OPEXC,OPASN,OPEXP");
+        }
+        if (date) {
+          queryParams.append("date", date);
+        }
+        this.log(
+          `Fetching option activities${activityType ? ` of type ${activityType}` : ""}${date ? ` for date ${date}` : ""}`
+        );
+        return this.makeRequest(`/account/activities?${queryParams.toString()}`, "GET", void 0, "", {
+          action: "Get option activities"
+        });
+      }
+      /**
+       * Create a long call spread (buy lower strike call, sell higher strike call)
+       * @param lowerStrikeCallSymbol Symbol of the lower strike call option
+       * @param higherStrikeCallSymbol Symbol of the higher strike call option
+       * @param qty Quantity of spreads to create (must be a whole number)
+       * @param limitPrice Limit price for the spread
+       * @returns The created multi-leg order
+       */
+      async createLongCallSpread(lowerStrikeCallSymbol, higherStrikeCallSymbol, qty, limitPrice) {
+        this.log(
+          `Creating long call spread: Buy ${lowerStrikeCallSymbol}, Sell ${higherStrikeCallSymbol}, Qty: ${qty}, Price: $${limitPrice.toFixed(
+            2
+          )}`,
+          {
+            symbol: `${lowerStrikeCallSymbol},${higherStrikeCallSymbol}`
+          }
+        );
+        const legs = [
+          {
+            symbol: lowerStrikeCallSymbol,
+            ratio_qty: "1",
+            side: "buy",
+            position_intent: "buy_to_open"
+          },
+          {
+            symbol: higherStrikeCallSymbol,
+            ratio_qty: "1",
+            side: "sell",
+            position_intent: "sell_to_open"
+          }
+        ];
+        return this.createMultiLegOptionOrder(legs, qty, "limit", limitPrice);
+      }
+      /**
+       * Create a long put spread (buy higher strike put, sell lower strike put)
+       * @param higherStrikePutSymbol Symbol of the higher strike put option
+       * @param lowerStrikePutSymbol Symbol of the lower strike put option
+       * @param qty Quantity of spreads to create (must be a whole number)
+       * @param limitPrice Limit price for the spread
+       * @returns The created multi-leg order
+       */
+      async createLongPutSpread(higherStrikePutSymbol, lowerStrikePutSymbol, qty, limitPrice) {
+        this.log(
+          `Creating long put spread: Buy ${higherStrikePutSymbol}, Sell ${lowerStrikePutSymbol}, Qty: ${qty}, Price: $${limitPrice.toFixed(
+            2
+          )}`,
+          {
+            symbol: `${higherStrikePutSymbol},${lowerStrikePutSymbol}`
+          }
+        );
+        const legs = [
+          {
+            symbol: higherStrikePutSymbol,
+            ratio_qty: "1",
+            side: "buy",
+            position_intent: "buy_to_open"
+          },
+          {
+            symbol: lowerStrikePutSymbol,
+            ratio_qty: "1",
+            side: "sell",
+            position_intent: "sell_to_open"
+          }
+        ];
+        return this.createMultiLegOptionOrder(legs, qty, "limit", limitPrice);
+      }
+      /**
+       * Create an iron condor (sell call spread and put spread)
+       * @param longPutSymbol Symbol of the lower strike put (long)
+       * @param shortPutSymbol Symbol of the higher strike put (short)
+       * @param shortCallSymbol Symbol of the lower strike call (short)
+       * @param longCallSymbol Symbol of the higher strike call (long)
+       * @param qty Quantity of iron condors to create (must be a whole number)
+       * @param limitPrice Limit price for the iron condor (credit)
+       * @returns The created multi-leg order
+       */
+      async createIronCondor(longPutSymbol, shortPutSymbol, shortCallSymbol, longCallSymbol, qty, limitPrice) {
+        this.log(`Creating iron condor with ${qty} contracts at $${limitPrice.toFixed(2)}`, {
+          symbol: `${longPutSymbol},${shortPutSymbol},${shortCallSymbol},${longCallSymbol}`
+        });
+        const legs = [
+          {
+            symbol: longPutSymbol,
+            ratio_qty: "1",
+            side: "buy",
+            position_intent: "buy_to_open"
+          },
+          {
+            symbol: shortPutSymbol,
+            ratio_qty: "1",
+            side: "sell",
+            position_intent: "sell_to_open"
+          },
+          {
+            symbol: shortCallSymbol,
+            ratio_qty: "1",
+            side: "sell",
+            position_intent: "sell_to_open"
+          },
+          {
+            symbol: longCallSymbol,
+            ratio_qty: "1",
+            side: "buy",
+            position_intent: "buy_to_open"
+          }
+        ];
+        return this.createMultiLegOptionOrder(legs, qty, "limit", limitPrice);
+      }
+      /**
+       * Create a covered call (sell call option against owned stock)
+       * @param stockSymbol Symbol of the underlying stock
+       * @param callOptionSymbol Symbol of the call option to sell
+       * @param qty Quantity of covered calls to create (must be a whole number)
+       * @param limitPrice Limit price for the call option
+       * @returns The created order
+       */
+      async createCoveredCall(stockSymbol, callOptionSymbol, qty, limitPrice) {
+        this.log(
+          `Creating covered call: Sell ${callOptionSymbol} against ${stockSymbol}, Qty: ${qty}, Price: $${limitPrice.toFixed(
+            2
+          )}`,
+          {
+            symbol: `${stockSymbol},${callOptionSymbol}`
+          }
+        );
+        return this.createOptionOrder(callOptionSymbol, qty, "sell", "sell_to_open", "limit", limitPrice);
+      }
+      /**
+       * Roll an option position to a new expiration or strike
+       * @param currentOptionSymbol Symbol of the current option position
+       * @param newOptionSymbol Symbol of the new option to roll to
+       * @param qty Quantity of options to roll (must be a whole number)
+       * @param currentPositionSide Side of the current position ('buy' or 'sell')
+       * @param limitPrice Net limit price for the roll
+       * @returns The created multi-leg order
+       */
+      async rollOptionPosition(currentOptionSymbol, newOptionSymbol, qty, currentPositionSide, limitPrice) {
+        this.log(`Rolling ${qty} ${currentOptionSymbol} to ${newOptionSymbol} at net price $${limitPrice.toFixed(2)}`, {
+          symbol: `${currentOptionSymbol},${newOptionSymbol}`
+        });
+        const closePositionSide = currentPositionSide === "buy" ? "sell" : "buy";
+        const openPositionSide = currentPositionSide;
+        const closePositionIntent = closePositionSide === "buy" ? "buy_to_close" : "sell_to_close";
+        const openPositionIntent = openPositionSide === "buy" ? "buy_to_open" : "sell_to_open";
+        const legs = [
+          {
+            symbol: currentOptionSymbol,
+            ratio_qty: "1",
+            side: closePositionSide,
+            position_intent: closePositionIntent
+          },
+          {
+            symbol: newOptionSymbol,
+            ratio_qty: "1",
+            side: openPositionSide,
+            position_intent: openPositionIntent
+          }
+        ];
+        return this.createMultiLegOptionOrder(legs, qty, "limit", limitPrice);
+      }
+      /**
+       * Get option chain for a specific underlying symbol and expiration date
+       * @param underlyingSymbol The underlying stock symbol
+       * @param expirationDate The expiration date (YYYY-MM-DD format)
+       * @returns Option contracts for the specified symbol and expiration date
+       */
+      async getOptionChain(underlyingSymbol, expirationDate) {
+        this.log(`Fetching option chain for ${underlyingSymbol} with expiration date ${expirationDate}`, {
+          symbol: underlyingSymbol
+        });
+        try {
+          const params = {
+            underlying_symbols: [underlyingSymbol],
+            expiration_date_gte: expirationDate,
+            expiration_date_lte: expirationDate,
+            status: "active",
+            limit: 500
+            // Get a large number to ensure we get all strikes
+          };
+          const response = await this.getOptionContracts(params);
+          return response.option_contracts || [];
+        } catch (error) {
+          if (!(error instanceof AlpacaRequestError)) {
+            this.log(
+              `Failed to fetch option chain for ${underlyingSymbol}: ${error instanceof Error ? error.message : `${error}`}`,
+              {
+                type: "error",
+                symbol: underlyingSymbol
+              }
+            );
+          }
+          return [];
+        }
+      }
+      /**
+       * Get all available expiration dates for a specific underlying symbol
+       * @param underlyingSymbol The underlying stock symbol
+       * @returns Array of available expiration dates
+       */
+      async getOptionExpirationDates(underlyingSymbol) {
+        this.log(`Fetching available expiration dates for ${underlyingSymbol}`, {
+          symbol: underlyingSymbol
+        });
+        try {
+          const params = {
+            underlying_symbols: [underlyingSymbol],
+            status: "active",
+            limit: 1e3
+            // Get a large number to ensure we get contracts with all expiration dates
+          };
+          const response = await this.getOptionContracts(params);
+          const expirationDates = /* @__PURE__ */ new Set();
+          if (response.option_contracts) {
+            response.option_contracts.forEach((contract) => {
+              expirationDates.add(contract.expiration_date);
+            });
+          }
+          return Array.from(expirationDates).sort();
+        } catch (error) {
+          if (!(error instanceof AlpacaRequestError)) {
+            this.log(
+              `Failed to fetch expiration dates for ${underlyingSymbol}: ${error instanceof Error ? error.message : `${error}`}`,
+              {
+                type: "error",
+                symbol: underlyingSymbol
+              }
+            );
+          }
+          return [];
+        }
+      }
+      /**
+       * Get the current options trading level for the account
+       * @returns The options trading level (0-3)
+       */
+      async getOptionsTradingLevel() {
+        this.log("Fetching options trading level");
+        const accountDetails = await this.getAccountDetails();
+        return accountDetails.options_trading_level || 0;
+      }
+      /**
+       * Check if the account has options trading enabled
+       * @returns Boolean indicating if options trading is enabled
+       */
+      async isOptionsEnabled() {
+        this.log("Checking if options trading is enabled");
+        const accountDetails = await this.getAccountDetails();
+        const optionsLevel = accountDetails.options_trading_level || 0;
+        const isEnabled = optionsLevel >= 2;
+        this.log(`Options trading level: ${optionsLevel}, enabled: ${isEnabled}`);
+        return isEnabled;
+      }
+      /**
+       * Close all option positions
+       * @param cancelOrders Whether to cancel related orders (default: true)
+       * @returns Response from the close positions request
+       */
+      async closeAllOptionPositions(cancelOrders = true) {
+        this.log(`Closing all option positions${cancelOrders ? " and canceling related orders" : ""}`);
+        const optionPositions = await this.getOptionPositions();
+        if (optionPositions.length === 0) {
+          this.log("No option positions to close");
+          return;
+        }
+        for (const position of optionPositions) {
+          const side = position.side === "long" ? "sell" : "buy";
+          const positionIntent = side === "sell" ? "sell_to_close" : "buy_to_close";
+          this.log(`Closing ${position.side} position of ${position.qty} contracts for ${position.symbol}`, {
+            symbol: position.symbol
+          });
+          await this.createOptionOrder(position.symbol, parseInt(position.qty), side, positionIntent, "market");
+        }
+        if (cancelOrders) {
+          const orders = await this.getOrders({ status: "open" });
+          const optionOrders = orders.filter((order) => order.asset_class === "us_option");
+          for (const order of optionOrders) {
+            this.log(`Canceling open order for ${order.symbol}`, {
+              symbol: order.symbol
+            });
+            await this.makeRequest(`/orders/${order.id}`, "DELETE", void 0, "", {
+              action: `Cancel option order ${order.id}`,
+              symbol: order.symbol
+            });
+          }
+        }
+      }
+      /**
+       * Close a specific option position
+       * @param symbol The option contract symbol
+       * @param qty Optional quantity to close (defaults to entire position)
+       * @returns The created order
+       */
+      async closeOptionPosition(symbol, qty) {
+        this.log(`Closing option position for ${symbol}${qty ? ` (${qty} contracts)` : ""}`, {
+          symbol
+        });
+        const positions = await this.getOptionPositions();
+        const position = positions.find((p) => p.symbol === symbol);
+        if (!position) {
+          throw new Error(`No position found for option contract ${symbol}`);
+        }
+        const quantityToClose = qty || parseInt(position.qty);
+        const side = position.side === "long" ? "sell" : "buy";
+        const positionIntent = side === "sell" ? "sell_to_close" : "buy_to_close";
+        return this.createOptionOrder(symbol, quantityToClose, side, positionIntent, "market");
+      }
+      /**
+       * Create a complete equities trade with optional stop loss and take profit
+       * @param params Trade parameters including symbol, qty, side, and optional referencePrice
+       * @param options Trade options including order type, extended hours, stop loss, and take profit settings
+       * @returns The created order
+       */
+      async createEquitiesTrade(params, options) {
+        const { symbol, qty, side, referencePrice } = params;
+        const {
+          type = "market",
+          limitPrice,
+          extendedHours = false,
+          useStopLoss = false,
+          stopPrice,
+          stopPercent100,
+          useTakeProfit = false,
+          takeProfitPrice,
+          takeProfitPercent100,
+          clientOrderId
+        } = options || {};
+        if (extendedHours && type === "market") {
+          this.log("Cannot create market order with extended hours enabled", {
+            symbol,
+            type: "error"
+          });
+          throw new Error("Cannot create market order with extended hours enabled");
+        }
+        if (type === "limit" && limitPrice === void 0) {
+          this.log("Limit price is required for limit orders", {
+            symbol,
+            type: "error"
+          });
+          throw new Error("Limit price is required for limit orders");
+        }
+        let calculatedStopPrice;
+        let calculatedTakeProfitPrice;
+        if (useStopLoss) {
+          if (stopPrice === void 0 && stopPercent100 === void 0) {
+            this.log("Either stopPrice or stopPercent100 must be provided when useStopLoss is true", {
+              symbol,
+              type: "error"
+            });
+            throw new Error("Either stopPrice or stopPercent100 must be provided when useStopLoss is true");
+          }
+          if (stopPercent100 !== void 0) {
+            if (referencePrice === void 0) {
+              this.log("referencePrice is required when using stopPercent100", {
+                symbol,
+                type: "error"
+              });
+              throw new Error("referencePrice is required when using stopPercent100");
+            }
+            const stopPercentDecimal = stopPercent100 / 100;
+            if (side === "buy") {
+              calculatedStopPrice = referencePrice * (1 - stopPercentDecimal);
+            } else {
+              calculatedStopPrice = referencePrice * (1 + stopPercentDecimal);
+            }
+          } else {
+            calculatedStopPrice = stopPrice;
+          }
+        }
+        if (useTakeProfit) {
+          if (takeProfitPrice === void 0 && takeProfitPercent100 === void 0) {
+            this.log("Either takeProfitPrice or takeProfitPercent100 must be provided when useTakeProfit is true", {
+              symbol,
+              type: "error"
+            });
+            throw new Error("Either takeProfitPrice or takeProfitPercent100 must be provided when useTakeProfit is true");
+          }
+          if (takeProfitPercent100 !== void 0) {
+            if (referencePrice === void 0) {
+              this.log("referencePrice is required when using takeProfitPercent100", {
+                symbol,
+                type: "error"
+              });
+              throw new Error("referencePrice is required when using takeProfitPercent100");
+            }
+            const takeProfitPercentDecimal = takeProfitPercent100 / 100;
+            if (side === "buy") {
+              calculatedTakeProfitPrice = referencePrice * (1 + takeProfitPercentDecimal);
+            } else {
+              calculatedTakeProfitPrice = referencePrice * (1 - takeProfitPercentDecimal);
+            }
+          } else {
+            calculatedTakeProfitPrice = takeProfitPrice;
+          }
+        }
+        let orderClass = "simple";
+        if (useStopLoss && useTakeProfit) {
+          orderClass = "bracket";
+        } else if (useStopLoss || useTakeProfit) {
+          orderClass = "oto";
+        }
+        const orderData = {
+          symbol,
+          qty: Math.abs(qty).toString(),
+          side,
+          type,
+          time_in_force: "day",
+          order_class: orderClass,
+          extended_hours: extendedHours,
+          position_intent: side === "buy" ? "buy_to_open" : "sell_to_open"
+        };
+        if (clientOrderId) {
+          orderData.client_order_id = clientOrderId;
+        }
+        if (type === "limit" && limitPrice !== void 0) {
+          orderData.limit_price = this.roundPriceForAlpaca(limitPrice).toString();
+        }
+        if (useStopLoss && calculatedStopPrice !== void 0) {
+          orderData.stop_loss = {
+            stop_price: this.roundPriceForAlpaca(calculatedStopPrice).toString()
+          };
+        }
+        if (useTakeProfit && calculatedTakeProfitPrice !== void 0) {
+          orderData.take_profit = {
+            limit_price: this.roundPriceForAlpaca(calculatedTakeProfitPrice).toString()
+          };
+        }
+        const logMessage = `Creating ${orderClass} ${type} ${side} order for ${symbol}: ${qty} shares${type === "limit" ? ` at $${limitPrice?.toFixed(2)}` : ""}${useStopLoss ? ` with stop loss at $${calculatedStopPrice?.toFixed(2)}` : ""}${useTakeProfit ? ` with take profit at $${calculatedTakeProfitPrice?.toFixed(2)}` : ""}${extendedHours ? " (extended hours)" : ""}`;
+        this.log(logMessage, {
+          symbol
+        });
+        return this.makeRequest("/orders", "POST", orderData, "", {
+          action: "Create equities trade",
+          symbol
+        });
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_market_time();
+
+// src/format-tools.ts
+function capFirstLetter(str) {
+  if (!str || typeof str !== "string") return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function formatCurrency(value) {
+  if (isNaN(value)) {
+    return "$0.00";
+  }
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD"
+  }).format(value);
+}
+function formatNumber(value) {
+  if (isNaN(value)) {
+    return "0";
+  }
+  return new Intl.NumberFormat("en-US").format(value);
+}
+function formatPercentage(value, decimalPlaces = 2) {
+  if (isNaN(value)) {
+    return "0%";
+  }
+  return new Intl.NumberFormat("en-US", {
+    style: "percent",
+    minimumFractionDigits: decimalPlaces
+  }).format(value);
+}
+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, "/");
+}
+
+// src/types/index.ts
+var types_exports = {};
+__export(types_exports, {
+  OPENAI_IMAGE_MODELS: () => OPENAI_IMAGE_MODELS,
+  OPENAI_MODELS: () => OPENAI_MODELS,
+  OPENROUTER_MODELS: () => OPENROUTER_MODELS,
+  isOpenAIImageModel: () => isOpenAIImageModel,
+  isOpenAIModel: () => isOpenAIModel,
+  isOpenRouterModel: () => isOpenRouterModel
+});
+
+// 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 OPENAI_IMAGE_MODELS = [
+  "gpt-image-2",
+  "gpt-image-2-2026-04-21",
+  "gpt-image-1.5",
+  "gpt-image-1",
+  "gpt-image-1-mini",
+  "chatgpt-image-latest",
+  "dall-e-2",
+  "dall-e-3"
+];
+function isOpenAIImageModel(model) {
+  return OPENAI_IMAGE_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/misc-utils.ts
+var logIfDebug = (message, data, type = "info") => {
+  const prefix = `[DEBUG][${type.toUpperCase()}]`;
+  const formattedData = data !== void 0 ? 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);
+  }
+};
+function maskApiKey(keyValue) {
+  if (keyValue.length <= 4) {
+    return keyValue;
+  }
+  const firstTwo = keyValue.slice(0, 2);
+  const lastTwo = keyValue.slice(-2);
+  return `${firstTwo}****${lastTwo}`;
+}
+function hideApiKeyFromurl(url) {
+  try {
+    const parsedUrl = new URL(url);
+    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 {
+    return url;
+  }
+}
+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]) : void 0;
+    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 };
+}
+async function fetchWithRetry(url, options = {}, retries = 3, initialBackoff = 1e3) {
+  let backoff = initialBackoff;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const response = await fetch(url, options);
+      if (!response.ok) {
+        if (response.status === 429) {
+          const retryAfter = response.headers.get("Retry-After");
+          const retryDelay = retryAfter ? parseInt(retryAfter) * 1e3 : 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) {
+          throw new Error(`CLIENT_ERROR: ${response.status}`);
+        }
+        throw new Error(`HTTP_ERROR: ${response.status}`);
+      }
+      return response;
+    } catch (error) {
+      if (attempt === retries) {
+        throw error;
+      }
+      const errorDetails = extractErrorDetails(error);
+      let adaptiveBackoff = backoff;
+      if (errorDetails.type === "RATE_LIMIT") {
+        if (errorDetails.retryAfter) {
+          adaptiveBackoff = errorDetails.retryAfter;
+        } else {
+          adaptiveBackoff = Math.max(backoff, 5e3);
+        }
+      } else if (errorDetails.type === "AUTH_ERROR") {
+        console.error(`Authentication error for ${hideApiKeyFromurl(url)}: ${errorDetails.reason}`, {
+          attemptNumber: attempt,
+          errorType: errorDetails.type,
+          httpStatus: errorDetails.status,
+          url: hideApiKeyFromurl(url),
+          source: "fetchWithRetry",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        throw error;
+      } else if (errorDetails.type === "CLIENT_ERROR") {
+        console.error(`Client error for ${hideApiKeyFromurl(url)}: ${errorDetails.reason}`, {
+          attemptNumber: attempt,
+          errorType: errorDetails.type,
+          httpStatus: errorDetails.status,
+          url: hideApiKeyFromurl(url),
+          source: "fetchWithRetry",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        throw error;
+      }
+      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: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      );
+      await new Promise((resolve) => setTimeout(resolve, adaptiveBackoff));
+      backoff = Math.min(backoff * 2, 3e4);
+    }
+  }
+  throw new Error("Failed to fetch after multiple attempts");
+}
+
+// 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 PRICED_OPENAI_IMAGE_MODELS = [
+  "gpt-image-2",
+  "gpt-image-2-2026-04-21",
+  "gpt-image-1.5",
+  "gpt-image-1",
+  "gpt-image-1-mini"
+];
+var OPENAI_IMAGE_PRICING_SIZES = ["1024x1024", "1024x1536", "1536x1024"];
 var openAiImageCostByQualityAndSize = {
   "gpt-image-2": {
     low: {
@@ -1851,85 +4149,1482 @@ var openAiImageCostByQualityAndSize = {
       "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
+  },
+  "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 isPricedOpenAIImageModel(model) {
+  return PRICED_OPENAI_IMAGE_MODELS.includes(model);
+}
+function isOpenAIImagePricingSize(size) {
+  return OPENAI_IMAGE_PRICING_SIZES.includes(size);
+}
+function resolveImagePricingQuality(quality) {
+  if (quality === "low" || quality === "medium" || quality === "high") {
+    return quality;
+  }
+  return DEFAULT_IMAGE_PRICING_QUALITY;
+}
+function resolveImagePricingSize(size) {
+  if (typeof size === "string" && isOpenAIImagePricingSize(size)) {
+    return size;
+  }
+  return DEFAULT_IMAGE_PRICING_SIZE;
+}
+function calculateImageCost(model, imageCount, quality, size) {
+  if (typeof model !== "string" || typeof imageCount !== "number" || imageCount <= 0) {
+    return 0;
+  }
+  if (!isPricedOpenAIImageModel(model)) return 0;
+  const pricingQuality = resolveImagePricingQuality(quality);
+  const pricingSize = resolveImagePricingSize(size);
+  const costPerImage = openAiImageCostByQualityAndSize[model][pricingQuality][pricingSize];
+  return imageCount * costPerImage;
+}
+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";
+function fixBrokenJson(jsonStr) {
+  jsonStr = jsonStr.replace(/\\\$/g, "$");
+  let index = 0;
+  function parse() {
+    const results = [];
+    while (index < jsonStr.length) {
+      skipWhitespace();
+      const value = parseValue();
+      if (value !== void 0) {
+        results.push(value);
+      } else {
+        index++;
+      }
+    }
+    return results.length === 1 ? results[0] : results;
+  }
+  function parseValue() {
+    skipWhitespace();
+    const char = getChar();
+    if (!char) return void 0;
+    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();
+    if (char === "-" || char === "." || /\d/.test(char)) return parseNumber();
+    return void 0;
+  }
+  function parseObject() {
+    const obj = {};
+    index++;
+    skipWhitespace();
+    while (index < jsonStr.length && getChar() !== "}") {
+      skipWhitespace();
+      const key = parseString();
+      if (key === void 0) {
+        console.warn(`Expected key at position ${index}`);
+        index++;
+        continue;
+      }
+      skipWhitespace();
+      if (getChar() === ":") {
+        index++;
+      } else {
+        console.warn(`Missing colon after key "${key}" at position ${index}`);
+      }
+      skipWhitespace();
+      const value = parseValue();
+      if (value === void 0) {
+        console.warn(`Expected value for key "${key}" at position ${index}`);
+        index++;
+        continue;
+      }
+      obj[key] = value;
+      skipWhitespace();
+      if (getChar() === ",") {
+        index++;
+      } else {
+        break;
+      }
+      skipWhitespace();
+    }
+    if (getChar() === "}") {
+      index++;
+    } else {
+      jsonStr += "}";
+    }
+    return obj;
+  }
+  function parseArray() {
+    const arr = [];
+    index++;
+    skipWhitespace();
+    while (index < jsonStr.length && getChar() !== "]") {
+      const value = parseValue();
+      if (value === void 0) {
+        console.warn(`Expected value at position ${index}`);
+        index++;
+      } else {
+        arr.push(value);
+      }
+      skipWhitespace();
+      if (getChar() === ",") {
+        index++;
+      } else {
+        break;
+      }
+      skipWhitespace();
+    }
+    if (getChar() === "]") {
+      index++;
+    } 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++;
+    }
+    while (index < jsonStr.length) {
+      const char = getChar();
+      if (isQuoted) {
+        if (char === delimiter) {
+          index++;
+          return result;
+        } else if (char === "\\") {
+          index++;
+          const escapeChar = getChar();
+          const escapeSequences = {
+            n: "\n",
+            r: "\r",
+            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 void 0;
+    }
+  }
+  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;
+  }
+}
+function isValidJson(jsonString) {
+  try {
+    JSON.parse(jsonString);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var openai;
+function initializeOpenAI(apiKey) {
+  const key = apiKey || 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)" }
+  });
+}
+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:
+${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}`);
+  }
+}
+
+// src/llm-utils.ts
+function normalizeModelName(model) {
+  return model.replace(/_/g, "-").toLowerCase();
+}
+var CODE_BLOCK_TYPES = ["javascript", "js", "graphql", "json", "typescript", "python", "markdown", "yaml"];
+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;
+    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}`);
+      }
+    }
+    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);
+      }
+    ];
+    for (const strategy of jsonParsingStrategies) {
+      const result = await strategy();
+      if (result !== null) {
+        return result;
+      }
+    }
+    console.error(`Failed to parse JSON from content: ${cleanedContent}. Original JSON: ${content}`);
+    throw new Error("Unable to parse JSON response");
+  } else {
+    return content;
+  }
+}
+
+// src/llm-openai.ts
+var DEFAULT_IMAGE_MIME_TYPE = "image/webp";
+function supportsTemperature(_model) {
+  return false;
+}
+function isZodSchema(schema) {
+  return typeof schema === "object" && schema !== null && "safeParse" in schema;
+}
+function buildJsonSchemaFormat(schema, schemaName, schemaDescription, schemaStrict) {
+  if (isZodSchema(schema)) {
+    const zodFormat = zodTextFormat(
+      schema,
+      schemaName,
+      schemaDescription ? {
+        description: schemaDescription
+      } : void 0
+    );
+    return {
+      type: "json_schema",
+      name: zodFormat.name,
+      schema: zodFormat.schema,
+      ...zodFormat.description ? { description: zodFormat.description } : {},
+      ...schemaStrict !== void 0 ? { strict: schemaStrict } : { strict: zodFormat.strict }
+    };
+  }
+  return {
+    type: "json_schema",
+    name: schemaName,
+    schema,
+    ...schemaDescription ? { description: schemaDescription } : {},
+    ...schemaStrict !== void 0 ? { strict: schemaStrict } : {}
+  };
+}
+function resolveOpenAIApiKey(apiKey) {
+  const resolvedApiKey = apiKey || process.env.OPENAI_API_KEY;
+  if (!resolvedApiKey) {
+    throw new Error("OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set");
+  }
+  return resolvedApiKey;
+}
+function createOpenAIClient(apiKey) {
+  return new OpenAI2({
+    apiKey
+  });
+}
+function normalizeImageDataUrl(imageData, mimeType = DEFAULT_IMAGE_MIME_TYPE) {
+  return imageData.startsWith("data:") ? imageData : `data:${mimeType};base64,${imageData}`;
+}
+function getFilenameFromPath(filePath) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const pathSegments = normalizedPath.split("/");
+  const filename = pathSegments[pathSegments.length - 1];
+  if (!filename) {
+    throw new Error(`Could not determine a filename from file path: ${filePath}`);
+  }
+  return filename;
+}
+function inferImageMimeType(filePath) {
+  const normalizedPath = filePath.toLowerCase();
+  if (normalizedPath.endsWith(".png")) {
+    return "image/png";
+  }
+  if (normalizedPath.endsWith(".jpg") || normalizedPath.endsWith(".jpeg")) {
+    return "image/jpeg";
+  }
+  if (normalizedPath.endsWith(".webp")) {
+    return "image/webp";
+  }
+  if (normalizedPath.endsWith(".gif")) {
+    return "image/gif";
+  }
+  return void 0;
+}
+async function readLocalFileBytes(filePath) {
+  try {
+    const dynamicImport = new Function("specifier", "return import(specifier);");
+    const { readFile } = await dynamicImport("node:fs/promises");
+    return await readFile(filePath);
+  } catch {
+    throw new Error("Local image file uploads require a Node.js runtime with access to node:fs/promises");
+  }
+}
+async function uploadVisionFileFromPath(openai2, filePath, filename, mimeType) {
+  const fileBytes = await readLocalFileBytes(filePath);
+  const resolvedFilename = filename || getFilenameFromPath(filePath);
+  const resolvedMimeType = mimeType || inferImageMimeType(filePath);
+  const uploadableFile = await OpenAI2.toFile(
+    fileBytes,
+    resolvedFilename,
+    resolvedMimeType ? { type: resolvedMimeType } : void 0
+  );
+  const uploadedFile = await openai2.files.create({
+    file: uploadableFile,
+    purpose: "vision"
+  });
+  return uploadedFile.id;
+}
+function collectImageInputs(image, images, imageBase64) {
+  const collectedImages = [];
+  if (image) {
+    collectedImages.push(image);
+  }
+  if (images && images.length > 0) {
+    collectedImages.push(...images);
+  }
+  if (imageBase64) {
+    collectedImages.push({ base64: imageBase64 });
+  }
+  return collectedImages;
+}
+function hasLocalFileImage(images) {
+  return images.some((image) => "filePath" in image);
+}
+async function buildImageContentPart(image, defaultDetail, openai2) {
+  const detail = image.detail ?? defaultDetail;
+  if ("url" in image) {
+    return {
+      type: "input_image",
+      detail,
+      image_url: image.url
+    };
+  }
+  if ("dataUrl" in image) {
+    return {
+      type: "input_image",
+      detail,
+      image_url: image.dataUrl
+    };
+  }
+  if ("base64" in image) {
+    return {
+      type: "input_image",
+      detail,
+      image_url: normalizeImageDataUrl(image.base64, image.mimeType)
+    };
+  }
+  if ("fileId" in image) {
+    return {
+      type: "input_image",
+      detail,
+      file_id: image.fileId
+    };
+  }
+  if (!openai2) {
+    throw new Error("A local image file path was provided, but no OpenAI client is available to upload it");
+  }
+  const fileId = await uploadVisionFileFromPath(openai2, image.filePath, image.filename, image.mimeType);
+  return {
+    type: "input_image",
+    detail,
+    file_id: fileId
+  };
+}
+async function buildPromptContent(input, imageInputs, imageDetail, openai2) {
+  if (imageInputs.length === 0) {
+    return input;
+  }
+  const imageContent = await Promise.all(imageInputs.map((image) => buildImageContentPart(image, imageDetail, openai2)));
+  return [{ type: "input_text", text: input }, ...imageContent];
+}
+async function uploadVisionFile(filePath, options = {}) {
+  const resolvedApiKey = resolveOpenAIApiKey(options.apiKey);
+  const openai2 = createOpenAIClient(resolvedApiKey);
+  return await uploadVisionFileFromPath(openai2, filePath, options.filename, options.mimeType);
+}
+var makeResponsesAPICall = async (input, options = {}) => {
+  const normalizedModel = normalizeModelName(options.model || DEFAULT_MODEL);
+  if (!isOpenAIModel(normalizedModel)) {
+    throw new Error(`Unsupported OpenAI model: ${normalizedModel}. Please use a supported GPT-5 model.`);
+  }
+  const apiKey = resolveOpenAIApiKey(options.apiKey);
+  const openai2 = createOpenAIClient(apiKey);
+  const { apiKey: _, model: __, ...cleanOptions } = options;
+  const requestBody = {
+    model: normalizedModel,
+    input,
+    ...cleanOptions
+  };
+  const response = await openai2.responses.create(requestBody);
+  const cacheHitTokens = response.usage?.input_tokens_details?.cached_tokens || 0;
+  const cacheWriteTokens = response.usage?.input_tokens_details?.cache_write_tokens || 0;
+  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
+    }
+  }));
+  const codeInterpreterCalls = response.output?.filter(
+    (item) => item.type === "code_interpreter_call"
+  );
+  let codeInterpreterOutputs = void 0;
+  if (codeInterpreterCalls && codeInterpreterCalls.length > 0) {
+    codeInterpreterOutputs = codeInterpreterCalls.flatMap((ci) => {
+      if (ci.outputs) return ci.outputs;
+      return [];
+    });
+  }
+  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,
+        cache_hit_tokens: cacheHitTokens,
+        cache_write_tokens: cacheWriteTokens,
+        cost: calculateCost(
+          "openai",
+          normalizedModel,
+          response.usage?.input_tokens || 0,
+          response.usage?.output_tokens || 0,
+          response.usage?.output_tokens_details?.reasoning_tokens || 0,
+          cacheHitTokens,
+          cacheWriteTokens
+        )
+      },
+      tool_calls: toolCalls,
+      ...codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}
+    };
+  }
+  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("") || "";
+  let parsingFormat = "text";
+  const requestedFormat = requestBody.text?.format;
+  if (requestedFormat?.type === "json_object") {
+    parsingFormat = "json";
+  } else if (requestedFormat?.type === "json_schema") {
+    parsingFormat = requestedFormat;
+  }
+  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,
+      cache_hit_tokens: cacheHitTokens,
+      cache_write_tokens: cacheWriteTokens,
+      cost: calculateCost(
+        "openai",
+        normalizedModel,
+        response.usage?.input_tokens || 0,
+        response.usage?.output_tokens || 0,
+        response.usage?.output_tokens_details?.reasoning_tokens || 0,
+        cacheHitTokens,
+        cacheWriteTokens
+      )
     },
-    high: {
-      "1024x1024": 0.167,
-      "1024x1536": 0.25,
-      "1536x1024": 0.25
+    tool_calls: toolCalls,
+    ...codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}
+  };
+};
+async function makeLLMCall(input, options = {}) {
+  const {
+    apiKey,
+    model = DEFAULT_MODEL,
+    responseFormat = "text",
+    schema,
+    schemaName = "response",
+    schemaDescription,
+    schemaStrict,
+    tools,
+    useCodeInterpreter = false,
+    useWebSearch = false,
+    image,
+    images,
+    imageBase64,
+    imageDetail = "high",
+    context,
+    reasoningEffort,
+    reasoningMode,
+    reasoningContext
+  } = options;
+  const normalizedModel = normalizeModelName(model);
+  if (!isOpenAIModel(normalizedModel)) {
+    throw new Error(`Unsupported OpenAI model: ${normalizedModel}. Please use a supported GPT-5 model.`);
+  }
+  const resolvedApiKey = resolveOpenAIApiKey(apiKey);
+  const imageInputs = collectImageInputs(image, images, imageBase64);
+  const openai2 = hasLocalFileImage(imageInputs) ? createOpenAIClient(resolvedApiKey) : void 0;
+  const promptContent = await buildPromptContent(input, imageInputs, imageDetail, openai2);
+  let processedInput;
+  if (context && context.length > 0) {
+    const conversationMessages = [];
+    for (const contextMsg of context) {
+      conversationMessages.push({
+        role: contextMsg.role,
+        content: contextMsg.content,
+        type: "message"
+      });
     }
-  },
-  "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
+    if (imageInputs.length > 0) {
+      conversationMessages.push({
+        role: "user",
+        content: promptContent,
+        type: "message"
+      });
+    } else {
+      conversationMessages.push({
+        role: "user",
+        content: input,
+        type: "message"
+      });
     }
+    processedInput = conversationMessages;
+  } else if (imageInputs.length > 0) {
+    processedInput = [
+      {
+        role: "user",
+        content: promptContent,
+        type: "message"
+      }
+    ];
+  } else {
+    processedInput = input;
   }
-};
-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;
+  let responsesOptions = {
+    apiKey: resolvedApiKey,
+    model: normalizedModel,
+    parallel_tool_calls: false,
+    tools
+  };
+  if (supportsTemperature(normalizedModel)) {
+    responsesOptions.temperature = 0.2;
   }
-  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;
+  if (reasoningEffort || reasoningMode || reasoningContext) {
+    responsesOptions.reasoning = {
+      ...reasoningEffort ? { effort: reasoningEffort } : {},
+      ...reasoningMode ? { mode: reasoningMode } : {},
+      ...reasoningContext ? { context: reasoningContext } : {}
+    };
   }
-  return inputCost + outputCost + reasoningCost;
+  if (schema) {
+    responsesOptions.text = {
+      format: buildJsonSchemaFormat(schema, schemaName, schemaDescription, schemaStrict)
+    };
+  } else if (responseFormat === "json") {
+    responsesOptions.text = { format: { type: "json_object" } };
+  } else if (typeof responseFormat === "object" && responseFormat.type === "json_schema") {
+    responsesOptions.text = { format: responseFormat };
+  }
+  if (useCodeInterpreter) {
+    responsesOptions.tools = [{ type: "code_interpreter", container: { type: "auto" } }];
+    responsesOptions.include = ["code_interpreter_call.outputs"];
+  }
+  if (useWebSearch) {
+    responsesOptions.tools = [{ type: "web_search_preview" }];
+  }
+  return await makeResponsesAPICall(processedInput, responsesOptions);
 }
 
-// src/json-tools.ts
-import OpenAI from "openai";
-
 // src/llm-images.ts
 import OpenAI3 from "openai";
+var DEFAULT_IMAGE_MODEL = "gpt-image-2";
+var resolveImageModel = (model) => model ?? DEFAULT_IMAGE_MODEL;
 var MULTIMODAL_VISION_MODELS = new Set(OPENAI_MODELS);
+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 : void 0;
+  if (visionModel && !supportedVisionModel) {
+    console.warn(
+      `Vision model ${visionModel} is not recognized as a multimodal OpenAI model. Ignoring for image usage metadata.`
+    );
+  }
+  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");
+  }
+  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 openai2 = new OpenAI3({
+    apiKey: effectiveApiKey
+  });
+  const requestParams = {
+    model: imageModel,
+    prompt,
+    n: count || 1,
+    size: size || "auto",
+    quality: quality || "auto",
+    background: background || "auto",
+    moderation: moderation || "auto"
+  };
+  if (outputFormat) {
+    requestParams.output_format = outputFormat;
+  }
+  if (compression !== void 0) {
+    requestParams.output_compression = compression;
+  }
+  try {
+    const response = await openai2.images.generate(requestParams);
+    if (!response.data || response.data.length === 0) {
+      throw new Error("No images returned from OpenAI Images API");
+    }
+    const cost = calculateImageCost(imageModel, count || 1, quality, size);
+    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}`);
+  }
+}
 
 // src/llm-deepseek.ts
 import OpenAI4 from "openai";
+var DEFAULT_DEEPSEEK_OPTIONS = {
+  defaultModel: "deepseek-chat"
+};
+var isSupportedDeepseekModel = (model) => {
+  return ["deepseek-chat", "deepseek-reasoner"].includes(model);
+};
+var supportsJsonOutput = (model) => {
+  return model === "deepseek-chat";
+};
+var supportsToolCalling = (model) => {
+  return model === "deepseek-chat";
+};
+function getDeepseekResponseFormatOption(responseFormat, model) {
+  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" };
+}
+async function createDeepseekCompletion(content, responseFormat, options = {}) {
+  const modelOption = options.model || DEFAULT_DEEPSEEK_OPTIONS.defaultModel;
+  const normalizedModel = normalizeModelName(modelOption);
+  if (!isSupportedDeepseekModel(normalizedModel)) {
+    throw new Error(`Unsupported Deepseek model: ${normalizedModel}. Please use 'deepseek-chat' or 'deepseek-reasoner'.`);
+  }
+  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");
+  }
+  const openai2 = new OpenAI4({
+    apiKey,
+    baseURL: "https://api.deepseek.com"
+  });
+  const messages = [];
+  if (options.developerPrompt) {
+    messages.push({
+      role: "system",
+      content: options.developerPrompt
+    });
+  }
+  if (options.context) {
+    messages.push(...options.context);
+  }
+  if (typeof content === "string") {
+    messages.push({
+      role: "user",
+      content
+    });
+  } else {
+    messages.push({
+      role: "user",
+      content
+    });
+  }
+  if ((responseFormat === "json" || typeof responseFormat === "object" && responseFormat.type === "json_schema") && supportsJsonOutput(normalizedModel)) {
+    if (!messages.some((m) => m.role === "system")) {
+      messages.unshift({
+        role: "system",
+        content: "Please respond in valid JSON format."
+      });
+    } else {
+      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
+  };
+  if (options.tools && supportsToolCalling(normalizedModel)) {
+    queryOptions.tools = options.tools;
+  }
+  try {
+    const completion = await openai2.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;
+  }
+}
+var makeDeepseekCall = async (content, responseFormat = "json", options = {}) => {
+  const mergedOptions = {
+    ...options
+  };
+  if (!mergedOptions.model) {
+    mergedOptions.model = DEFAULT_DEEPSEEK_OPTIONS.defaultModel;
+  }
+  const modelName = normalizeModelName(mergedOptions.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: void 0
+    };
+  }
+  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: void 0
+    };
+  }
+  try {
+    const completion = await createDeepseekCompletion(content, responseFormat, mergedOptions);
+    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
+      };
+    }
+    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) {
+    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: void 0
+    };
+  }
+};
 
 // src/llm-openrouter.ts
 import OpenAI5 from "openai";
+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}`;
+}
+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 };
+}
+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 OpenAI5({
+    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 });
+  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] : void 0;
+  const message = choice && "message" in choice ? choice.message : void 0;
+  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);
+  const hasToolCalls = Array.isArray(message?.tool_calls) && message.tool_calls.length > 0;
+  if (hasToolCalls) {
+    const usageModel2 = isOpenRouterModel(modelId) ? modelId : DEFAULT_MODEL;
+    return {
+      response: "",
+      usage: {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        provider: "openrouter",
+        model: usageModel2,
+        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");
+  }
+  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 } : {}
+  };
+}
+
+// src/performance-timer.ts
+var PerformanceTimer = class {
+  startTime;
+  checkpoints;
+  totalTime;
+  constructor() {
+    this.startTime = performance.now();
+    this.checkpoints = /* @__PURE__ */ 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 / 1e3).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;
+    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;
+    }
+    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();
+    const formatNumber2 = (num) => num.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+    const maxLabelLength = Math.max(...report.phases.map((p) => p.label.length), 30);
+    const maxDurationLength = Math.max(...report.phases.map((p) => formatNumber2(p.duration).length), 10);
+    let output = `\u2554${"\u2550".repeat(maxLabelLength + 2)}\u2566${"\u2550".repeat(maxDurationLength + 2)}\u2557
+`;
+    output += `\u2551 ${"Phase".padEnd(maxLabelLength)} \u2551 ${"Time (ms)".padEnd(maxDurationLength)} \u2551
+`;
+    output += `\u2560${"\u2550".repeat(maxLabelLength + 2)}\u256C${"\u2550".repeat(maxDurationLength + 2)}\u2563
+`;
+    report.phases.forEach((phase) => {
+      output += `\u2551 ${phase.label.padEnd(maxLabelLength)} \u2551 ${formatNumber2(phase.duration).padStart(maxDurationLength)} \u2551
+`;
+    });
+    output += `\u2560${"\u2550".repeat(maxLabelLength + 2)}\u256C${"\u2550".repeat(maxDurationLength + 2)}\u2563
+`;
+    output += `\u2551 ${"Total".padEnd(maxLabelLength)} \u2551 ${formatNumber2(report.totalTime).padStart(maxDurationLength)} \u2551
+`;
+    output += `\u255A${"\u2550".repeat(maxLabelLength + 2)}\u2569${"\u2550".repeat(maxDurationLength + 2)}\u255D
+`;
+    return output;
+  }
+};
+
+// src/disco-mail.ts
+var DEFAULT_DISCO_MAIL_BASE_URL = "https://mail.discomedia.co/api/v1";
+var DiscoMailApiError = class extends Error {
+  code;
+  status;
+  constructor(code, message, status) {
+    super(`Disco Mail API error: ${code} ${message}`);
+    this.name = "DiscoMailApiError";
+    this.code = code;
+    this.status = status;
+  }
+};
+var DiscoMailAPI = class {
+  constructor(clientOptions = {}) {
+    this.clientOptions = clientOptions;
+  }
+  clientOptions;
+  async send(payload, options = {}) {
+    this.validateSendRequest(payload);
+    const headers = new Headers();
+    if (options.idempotencyKey) {
+      headers.set("Idempotency-Key", options.idempotencyKey);
+    }
+    return this.request("/emails", "POST", options, payload, headers);
+  }
+  async listDomains(options = {}) {
+    return this.request("/domains", "GET", options);
+  }
+  async getDomain(domainId, options = {}) {
+    this.validateDomainId(domainId);
+    return this.request(`/domains/${domainId}`, "GET", options);
+  }
+  async createDomain(payload, options = {}) {
+    if (!payload.name.trim()) {
+      throw new Error("Disco Mail domain name must be a non-empty string");
+    }
+    if (!payload.region.trim()) {
+      throw new Error("Disco Mail domain region must be a non-empty string");
+    }
+    return this.request("/domains", "POST", options, payload);
+  }
+  async verifyDomain(domainId, options = {}) {
+    this.validateDomainId(domainId);
+    return this.request(`/domains/${domainId}/verify`, "PUT", options);
+  }
+  async request(path, method, options, body, additionalHeaders = new Headers()) {
+    const apiKey = this.resolveApiKey(options);
+    const headers = new Headers(additionalHeaders);
+    headers.set("Authorization", `Bearer ${apiKey}`);
+    headers.set("Content-Type", "application/json");
+    const response = await fetch(`${this.resolveBaseUrl(options)}${path}`, {
+      method,
+      headers,
+      ...body ? { body: JSON.stringify(body) } : {}
+    });
+    if (!response.ok) {
+      throw await this.createApiError(response);
+    }
+    return await response.json();
+  }
+  resolveApiKey(options) {
+    const apiKey = options.apiKey || this.clientOptions.apiKey || process.env.DISCO_MAIL_API_KEY || process.env.DISCOMAIL_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "Disco Mail API key is not provided. Pass options.apiKey or set DISCO_MAIL_API_KEY or DISCOMAIL_API_KEY."
+      );
+    }
+    return apiKey;
+  }
+  resolveBaseUrl(options) {
+    const baseUrl = options.baseUrl || this.clientOptions.baseUrl || DEFAULT_DISCO_MAIL_BASE_URL;
+    return baseUrl.replace(/\/+$/, "");
+  }
+  validateSendRequest(payload) {
+    const recipients = Array.isArray(payload.to) ? payload.to : [payload.to];
+    if (recipients.length === 0 || recipients.some((recipient) => !recipient.trim())) {
+      throw new Error("Disco Mail send requests require at least one non-empty recipient");
+    }
+    if (!payload.from.trim()) {
+      throw new Error("Disco Mail send requests require a non-empty from address");
+    }
+    if (!payload.subject?.trim() && !payload.templateId?.trim()) {
+      throw new Error("Disco Mail send requests require a non-empty subject or templateId");
+    }
+    if (!payload.html?.trim() && !payload.text?.trim()) {
+      throw new Error("Disco Mail send requests require a non-empty html or text body");
+    }
+    if (payload.attachments && payload.attachments.length > 10) {
+      throw new Error("Disco Mail send requests support a maximum of 10 attachments");
+    }
+  }
+  validateDomainId(domainId) {
+    if (!Number.isInteger(domainId) || domainId <= 0) {
+      throw new Error("Disco Mail domainId must be a positive integer");
+    }
+  }
+  async createApiError(response) {
+    let body = null;
+    try {
+      body = await response.json();
+    } catch {
+      body = null;
+    }
+    const apiError = body?.error ?? body;
+    return new DiscoMailApiError(
+      apiError?.code || `HTTP_${response.status}`,
+      apiError?.message || response.statusText || "Request failed",
+      response.status
+    );
+  }
+};
 
 // src/index.ts
 init_alpaca_trading_api();
 init_alpaca_market_data_api();
 init_alpaca_trading_api();
 init_alpaca_market_data_api();
+var disco = {
+  types: types_exports,
+  alpaca: {
+    TradingAPI: AlpacaTradingAPI,
+    MarketDataAPI: AlpacaMarketDataAPI
+  },
+  format: {
+    capFirstLetter,
+    currency: formatCurrency,
+    number: formatNumber,
+    pct: formatPercentage,
+    dateTimeForGS
+  },
+  llm: {
+    call: makeLLMCall,
+    uploadVisionFile,
+    seek: makeDeepseekCall,
+    images: makeImagesCall,
+    open: makeOpenRouterCall
+  },
+  mail: new DiscoMailAPI(),
+  time: {
+    convertDateToMarketTimeZone,
+    getStartAndEndDates,
+    getMarketOpenClose,
+    getOpenCloseForTradingDay,
+    getLastFullTradingDate,
+    getNextMarketDay,
+    getPreviousMarketDay,
+    getMarketTimePeriod,
+    getMarketStatus,
+    getNYTimeZone,
+    getTradingDate,
+    getTradingStartAndEndDates,
+    getTradingDaysBack,
+    isMarketDay,
+    isWithinMarketHours,
+    countTradingDays,
+    MARKET_TIMES
+  },
+  utils: {
+    logIfDebug,
+    fetchWithRetry,
+    Timer: PerformanceTimer
+  }
+};
 
 // src/test.ts
 init_logging();
@@ -1973,5 +5668,147 @@ function testOpenAIModelRegistryAndPricing() {
   }
   log3(`${directModel} registry and pricing test passed`);
 }
-testOpenAIModelRegistryAndPricing();
+function restoreEnvironmentVariable(name, value) {
+  if (value === void 0) {
+    delete process.env[name];
+    return;
+  }
+  process.env[name] = value;
+}
+async function testDiscoMailAPI() {
+  const originalFetch = globalThis.fetch;
+  const originalDiscoMailApiKey = process.env.DISCO_MAIL_API_KEY;
+  const originalDiscoMailLegacyApiKey = process.env.DISCOMAIL_API_KEY;
+  const calls = [];
+  const responses = [
+    new Response(JSON.stringify({ emailId: "email_123" }), { status: 200 }),
+    new Response(JSON.stringify([]), { status: 200 }),
+    new Response(JSON.stringify([]), { status: 200 })
+  ];
+  globalThis.fetch = async (input, init) => {
+    calls.push({ input, init });
+    const response = responses.shift();
+    if (!response) {
+      throw new Error("Unexpected Disco Mail fetch call");
+    }
+    return response;
+  };
+  try {
+    process.env.DISCO_MAIL_API_KEY = "disco-primary-key";
+    process.env.DISCOMAIL_API_KEY = "disco-legacy-key";
+    const client = new DiscoMailAPI();
+    const sendResult = await client.send(
+      {
+        to: "recipient@example.net",
+        from: "Disco Media <hello@discomedia.co>",
+        subject: "Test message",
+        text: "Test body"
+      },
+      {
+        apiKey: "disco-explicit-key",
+        baseUrl: "https://mail-test.example/api/v1/",
+        idempotencyKey: "mail-test-123"
+      }
+    );
+    if (sendResult.emailId !== "email_123") {
+      throw new Error(`Expected Disco Mail emailId email_123, received ${sendResult.emailId}`);
+    }
+    if (calls[0]?.input !== "https://mail-test.example/api/v1/emails") {
+      throw new Error(`Unexpected Disco Mail send URL: ${String(calls[0]?.input)}`);
+    }
+    const sendHeaders = new Headers(calls[0]?.init?.headers);
+    if (sendHeaders.get("Authorization") !== "Bearer disco-explicit-key") {
+      throw new Error("Disco Mail explicit API key did not take precedence");
+    }
+    if (sendHeaders.get("Idempotency-Key") !== "mail-test-123") {
+      throw new Error("Disco Mail idempotency key was not sent");
+    }
+    if (calls[0]?.init?.body !== JSON.stringify({
+      to: "recipient@example.net",
+      from: "Disco Media <hello@discomedia.co>",
+      subject: "Test message",
+      text: "Test body"
+    })) {
+      throw new Error("Disco Mail send payload was not serialized as expected");
+    }
+    await client.listDomains({ baseUrl: "https://mail-test.example/api/v1" });
+    const primaryEnvironmentHeaders = new Headers(calls[1]?.init?.headers);
+    if (primaryEnvironmentHeaders.get("Authorization") !== "Bearer disco-primary-key") {
+      throw new Error("DISCO_MAIL_API_KEY was not used when no explicit key was passed");
+    }
+    delete process.env.DISCO_MAIL_API_KEY;
+    await client.listDomains({ baseUrl: "https://mail-test.example/api/v1" });
+    const legacyEnvironmentHeaders = new Headers(calls[2]?.init?.headers);
+    if (legacyEnvironmentHeaders.get("Authorization") !== "Bearer disco-legacy-key") {
+      throw new Error("DISCOMAIL_API_KEY was not used as the fallback key");
+    }
+    globalThis.fetch = async () => new Response(JSON.stringify({ error: { code: "BAD_REQUEST", message: "Sender is invalid" } }), {
+      status: 400,
+      statusText: "Bad Request"
+    });
+    try {
+      await client.listDomains({ apiKey: "disco-explicit-key" });
+      throw new Error("Expected Disco Mail API error");
+    } catch (error) {
+      if (!(error instanceof DiscoMailApiError)) {
+        throw error;
+      }
+      if (error.code !== "BAD_REQUEST" || error.status !== 400 || !error.message.includes("Sender is invalid")) {
+        throw new Error(`Unexpected Disco Mail API error: ${error.message}`);
+      }
+    }
+    delete process.env.DISCOMAIL_API_KEY;
+    try {
+      await client.listDomains();
+      throw new Error("Expected missing Disco Mail API key error");
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.includes("DISCO_MAIL_API_KEY")) {
+        throw error;
+      }
+    }
+    try {
+      await client.send(
+        {
+          to: "",
+          from: "Disco Media <hello@discomedia.co>",
+          subject: "Invalid message",
+          text: "Test body"
+        },
+        { apiKey: "disco-explicit-key" }
+      );
+      throw new Error("Expected invalid Disco Mail payload error");
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.includes("non-empty recipient")) {
+        throw error;
+      }
+    }
+    log3("Disco Mail mocked API tests passed");
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreEnvironmentVariable("DISCO_MAIL_API_KEY", originalDiscoMailApiKey);
+    restoreEnvironmentVariable("DISCOMAIL_API_KEY", originalDiscoMailLegacyApiKey);
+  }
+}
+async function testLiveDiscoMailDomainLookup() {
+  if (!process.env.DISCO_MAIL_API_KEY && !process.env.DISCOMAIL_API_KEY) {
+    log3("Skipping live Disco Mail domain lookup: no Disco Mail API key is configured");
+    return;
+  }
+  const domains = await disco.mail.listDomains();
+  const discomediaDomain = domains.find((domain) => domain.name === "discomedia.co");
+  if (!discomediaDomain) {
+    throw new Error("Live Disco Mail API lookup did not return discomedia.co");
+  }
+  log3(`Live Disco Mail domain lookup passed: discomedia.co is ${discomediaDomain.status}`);
+}
+async function runActiveTests() {
+  testOpenAIModelRegistryAndPricing();
+  await testDiscoMailAPI();
+  await testLiveDiscoMailDomainLookup();
+}
+void runActiveTests().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Test run failed: ${message}`);
+  process.exitCode = 1;
+});
 //# sourceMappingURL=test.mjs.map