@adaptic/utils 0.0.914 → 0.0.916

package/dist/index.cjs

@@ -5789,6 +5789,24 @@ async function closeAllPositions$1(auth, params = { cancel_orders: true, useLimi
         account: auth.adapticAccountId || "direct",
     });
     if (useLimitOrders) {
+        // Cancel all existing orders first when requested, to free up qty_available
+        // for the limit close orders. Without this, existing trailing stops and
+        // pending orders reduce qty_available, causing "insufficient qty" errors.
+        if (cancel_orders) {
+            try {
+                await cancelAllOrders$1(auth);
+                getLogger().info("Canceled all open orders before placing limit close orders", {
+                    account: auth.adapticAccountId || "direct",
+                });
+            }
+            catch (cancelError) {
+                getLogger().warn(`Failed to cancel orders before limit closure: ${cancelError instanceof Error ? cancelError.message : String(cancelError)}`, {
+                    account: auth.adapticAccountId || "direct",
+                    type: "warn",
+                });
+                // Continue with closure attempt even if cancel failed
+            }
+        }
         const positions = await fetchAllPositions(auth);
         if (positions.length === 0) {
             getLogger().info("No positions to close", {
@@ -5799,13 +5817,10 @@ async function closeAllPositions$1(auth, params = { cancel_orders: true, useLimi
         getLogger().info(`Found ${positions.length} positions to close`, {
             account: auth.adapticAccountId || "direct",
         });
-        const alpacaAuth = {
-            type: "LIVE",
-            alpacaApiKey: process.env.ALPACA_API_KEY,
-            alpacaApiSecret: process.env.ALPACA_API_SECRET || process.env.ALPACA_SECRET_KEY,
-        };
+        // Use the passed auth for quote fetching (not hardcoded env vars)
+        // so multi-account setups use the correct credentials per account
         const symbols = positions.map((position) => position.symbol);
-        const quotesResponse = await getLatestQuotes$1(alpacaAuth, { symbols });
+        const quotesResponse = await getLatestQuotes$1(auth, { symbols });
         const lengthOfQuotes = Object.keys(quotesResponse.quotes).length;
         if (lengthOfQuotes === 0) {
             getLogger().error("No quotes available for positions, received 0 quotes", {
@@ -5815,11 +5830,12 @@ async function closeAllPositions$1(auth, params = { cancel_orders: true, useLimi
             return [];
         }
         if (lengthOfQuotes !== positions.length) {
-            getLogger().warn(`Received ${lengthOfQuotes} quotes for ${positions.length} positions, expected ${positions.length} quotes`, {
+            getLogger().warn(`Received ${lengthOfQuotes} quotes for ${positions.length} positions (expected ${positions.length}), proceeding with available quotes`, {
                 account: auth.adapticAccountId || "direct",
                 type: "warn",
             });
-            return [];
+            // Continue with available quotes instead of aborting — some symbols may
+            // lack quotes (halted, delisted) but other positions should still close
         }
         for (const position of positions) {
             const quote = quotesResponse.quotes[position.symbol];
@@ -7161,18 +7177,29 @@ const fetchLastTrade = async (symbol, options) => {
     }
     const apiKey = options?.apiKey || MASSIVE_API_KEY;
     validateMassiveApiKey$1(apiKey);
-    const baseUrl = `https://api.massive.com/v2/last/trade/${encodeURIComponent(symbol)}`;
+    const baseUrl = `https://api.massive.com/v3/trades/${encodeURIComponent(symbol)}`;
     const params = new URLSearchParams({
         apiKey,
+        limit: "1",
+        sort: "timestamp",
+        order: "desc",
     });
     return massiveLimit(async () => {
         try {
             const response = await fetchWithRetry(`${baseUrl}?${params.toString()}`, {}, 3, 1000);
-            const data = await response.json();
-            if (!MASSIVE_VALID_STATUSES.has(data.status) || !data.results) {
-                throw new Error(`Massive.com API error: ${data.status || "No results"} ${data.error || ""}`);
+            const data = (await response.json());
+            if ("message" in data) {
+                throw new Error(`Massive.com API error: ${data.message}`);
             }
-            const { p: price, s: vol, t: timestamp } = data.results;
+            if (!data.results ||
+                !Array.isArray(data.results) ||
+                data.results.length === 0) {
+                throw new Error(`Massive.com API error: No trade results for ${symbol}`);
+            }
+            const latestTrade = data.results[0];
+            const price = latestTrade.price;
+            const vol = latestTrade.size;
+            const timestamp = latestTrade.sip_timestamp;
             if (typeof price !== "number" ||
                 typeof vol !== "number" ||
                 typeof timestamp !== "number") {
@@ -7205,6 +7232,77 @@ const fetchLastTrade = async (symbol, options) => {
         }
     });
 };
+/**
+ * Fetches the latest NBBO quote for a given stock ticker using the Massive v3 API.
+ * Returns processed spread information including bid, ask, spread, and mid price.
+ *
+ * @param symbol - The stock ticker symbol.
+ * @param options - Optional parameters including API key override.
+ * @returns Processed quote data with spread metrics.
+ */
+const fetchLastQuote = async (symbol, options) => {
+    if (!options?.apiKey && !MASSIVE_API_KEY) {
+        throw new Error("Massive API key is missing");
+    }
+    const apiKey = options?.apiKey || MASSIVE_API_KEY;
+    validateMassiveApiKey$1(apiKey);
+    const baseUrl = `https://api.massive.com/v3/quotes/${encodeURIComponent(symbol)}`;
+    const params = new URLSearchParams({
+        apiKey,
+        limit: "1",
+        sort: "timestamp",
+        order: "desc",
+    });
+    return massiveLimit(async () => {
+        try {
+            const response = await fetchWithRetry(`${baseUrl}?${params.toString()}`, {}, 3, 1000);
+            const data = (await response.json());
+            if ("message" in data) {
+                throw new Error(`Massive.com API error: ${data.message}`);
+            }
+            const results = data.results;
+            if (!Array.isArray(results) || results.length === 0) {
+                throw new Error(`Massive.com API error: No quote results for ${symbol}`);
+            }
+            const quote = results[0];
+            if (typeof quote.bid_price !== "number" ||
+                typeof quote.ask_price !== "number") {
+                throw new Error("Invalid quote data received from Massive.com API");
+            }
+            const midPrice = (quote.bid_price + quote.ask_price) / 2;
+            const spread = quote.ask_price - quote.bid_price;
+            return {
+                bid: quote.bid_price,
+                ask: quote.ask_price,
+                spread,
+                spreadPercent: midPrice > 0 ? (spread / midPrice) * 100 : 0,
+                midPrice,
+                bidSize: quote.bid_size,
+                askSize: quote.ask_size,
+                time: new Date(Math.floor(quote.sip_timestamp / 1000000)),
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            const contextualMessage = `Error fetching last quote for ${symbol}`;
+            getLogger().error(`${contextualMessage}: ${errorMessage}`, {
+                symbol,
+                errorType: error instanceof Error && error.message.includes("AUTH_ERROR")
+                    ? "AUTH_ERROR"
+                    : error instanceof Error && error.message.includes("RATE_LIMIT")
+                        ? "RATE_LIMIT"
+                        : error instanceof Error &&
+                            error.message.includes("NETWORK_ERROR")
+                            ? "NETWORK_ERROR"
+                            : "UNKNOWN",
+                url: hideApiKeyFromurl(`${baseUrl}?${params.toString()}`),
+                source: "MassiveAPI.fetchLastQuote",
+                timestamp: new Date().toISOString(),
+            });
+            throw new Error(`${contextualMessage}: ${errorMessage}`);
+        }
+    });
+};
 // use Massive for all price data fetching
 /**
  * Fetches price data for a given stock ticker.
@@ -66228,22 +66326,25 @@ const MassiveTradesResponseSchema = objectType({
     results: arrayType(MassiveTradeSchema),
 });
 // ===== Last Trade Schemas =====
-/** Schema for Massive last trade response */
+/** Schema for Massive last trade response (v3 format - returns array of trades) */
 const MassiveLastTradeResponseSchema = objectType({
     status: stringType(),
     request_id: stringType(),
-    results: objectType({
-        T: stringType(),
-        p: numberType(),
-        s: numberType(),
-        t: numberType(),
-        c: arrayType(numberType()).optional(),
-        e: numberType().optional(),
-        i: stringType().optional(),
-        q: numberType().optional(),
-        x: numberType().optional(),
-        z: numberType().optional(),
-    }),
+    results: arrayType(objectType({
+        conditions: arrayType(numberType()).optional(),
+        correction: numberType().optional(),
+        exchange: numberType(),
+        id: stringType(),
+        participant_timestamp: numberType(),
+        price: numberType(),
+        sequence_number: numberType(),
+        sip_timestamp: numberType(),
+        size: numberType(),
+        tape: numberType().optional(),
+        trf_id: numberType().optional(),
+        trf_timestamp: numberType().optional(),
+    }))
+        .min(1),
 });
 // ===== Aggregates (Bars) Schemas =====
 /** Schema for Massive aggregates (bars) response */
@@ -67419,6 +67520,7 @@ const adaptic = {
         fetchTickerInfo: fetchTickerInfo,
         fetchGroupedDaily: fetchGroupedDaily,
         fetchLastTrade: fetchLastTrade,
+        fetchLastQuote: fetchLastQuote,
         fetchTrades: fetchTrades,
         fetchPrices: fetchPrices,
         analyseMassivePriceData: analyseMassivePriceData,