@adaptic/utils 0.0.941 → 0.0.943

package/dist/index.mjs

@@ -4954,9 +4954,11 @@ async function createLimitOrder(auth, params = {
     position_intent: "buy_to_open",
     extended_hours: false,
     client_order_id: undefined,
+    time_in_force: undefined,
 }) {
-    const { symbol, qty, side, limitPrice, position_intent, extended_hours, client_order_id, } = params;
-    getLogger().info(`Creating limit order for ${symbol}: ${side} ${qty} shares at ${limitPrice.toFixed(2)} (${position_intent})`, {
+    const { symbol, qty, side, limitPrice, position_intent, extended_hours, client_order_id, time_in_force, } = params;
+    const effectiveTimeInForce = time_in_force ?? "day";
+    getLogger().info(`Creating limit order for ${symbol}: ${side} ${qty} shares at ${limitPrice.toFixed(2)} (${position_intent}, tif=${effectiveTimeInForce})`, {
         account: auth.adapticAccountId || "direct",
         symbol,
     });
@@ -4967,7 +4969,7 @@ async function createLimitOrder(auth, params = {
         position_intent,
         type: "limit",
         limit_price: limitPrice.toString(),
-        time_in_force: "day",
+        time_in_force: effectiveTimeInForce,
         order_class: "simple",
         extended_hours,
     };
@@ -5451,17 +5453,17 @@ const DEFAULT_FEED = "sip";
  * Known quote currencies that signal a crypto pair when found as a suffix.
  * E.g. "BTCUSD" → crypto, "AAPL" → equity.
  */
-const CRYPTO_QUOTE_CURRENCIES = ["USD", "USDT", "USDC", "BTC"];
+const CRYPTO_QUOTE_CURRENCIES$1 = ["USD", "USDT", "USDC", "BTC"];
 /**
  * Detect whether a symbol looks like a crypto pair (e.g. "BTCUSD", "DOGEUSD",
  * "BTC/USD"). Equity tickers never end with these suffixes because Alpaca
  * equity symbols are plain tickers without a quote currency.
  */
-function isCryptoSymbol(symbol) {
+function isCryptoSymbol$1(symbol) {
     if (symbol.includes("/"))
         return true;
     const upper = symbol.toUpperCase();
-    return CRYPTO_QUOTE_CURRENCIES.some((qc) => {
+    return CRYPTO_QUOTE_CURRENCIES$1.some((qc) => {
         if (!upper.endsWith(qc))
             return false;
         const base = upper.slice(0, -qc.length);
@@ -5477,7 +5479,7 @@ function normalizeCryptoSymbolForApi(symbol) {
     if (symbol.includes("/"))
         return symbol.toUpperCase();
     const upper = symbol.toUpperCase();
-    for (const qc of CRYPTO_QUOTE_CURRENCIES) {
+    for (const qc of CRYPTO_QUOTE_CURRENCIES$1) {
         if (upper.endsWith(qc)) {
             const base = upper.slice(0, -qc.length);
             if (base.length >= 2)
@@ -5511,7 +5513,7 @@ async function getLatestQuotes$1(auth, params) {
     const equitySymbols = [];
     const cryptoSymbols = [];
     for (const sym of symbols) {
-        if (isCryptoSymbol(sym)) {
+        if (isCryptoSymbol$1(sym)) {
             cryptoSymbols.push(sym);
         }
         else {
@@ -5687,6 +5689,24 @@ async function fetchNews$1(symbols, params) {
     }
 }
 
+/** Known quote currencies that signal a crypto pair when found as a suffix */
+const CRYPTO_QUOTE_CURRENCIES = ["USD", "USDT", "USDC", "BTC"];
+/**
+ * Detect whether a symbol looks like a crypto pair (e.g. "BTCUSD", "DOGEUSD",
+ * "BTC/USD"). Equity tickers never end with these suffixes because Alpaca
+ * equity symbols are plain tickers without a quote currency.
+ */
+function isCryptoSymbol(symbol) {
+    if (symbol.includes("/"))
+        return true;
+    const upper = symbol.toUpperCase();
+    return CRYPTO_QUOTE_CURRENCIES.some((qc) => {
+        if (!upper.endsWith(qc))
+            return false;
+        const base = upper.slice(0, -qc.length);
+        return base.length >= 2;
+    });
+}
 /**
  * Fetches all positions for an Alpaca trading account.
  * @param auth - The authentication details for Alpaca
@@ -5787,7 +5807,9 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
                 }
             }
         }
-        if (useLimitOrder) {
+        // Crypto positions cannot use limit orders with SIP quotes or time_in_force="day".
+        // Use direct DELETE (market order) for crypto regardless of useLimitOrder flag.
+        if (useLimitOrder && !isCryptoSymbol(symbolOrAssetId)) {
             const { position } = await fetchPosition(auth, symbolOrAssetId);
             if (!position) {
                 throw new Error(`Position not found for ${symbolOrAssetId}`);
@@ -5837,6 +5859,9 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
             });
         }
         else {
+            if (isCryptoSymbol(symbolOrAssetId)) {
+                getLogger().info(`Closing crypto position ${symbolOrAssetId} via market order (DELETE endpoint)`, { account: auth.adapticAccountId || "direct", symbol: symbolOrAssetId });
+            }
             const queryParams = new URLSearchParams();
             if (params?.qty !== undefined) {
                 queryParams.append("qty", params.qty.toString());
@@ -5895,37 +5920,68 @@ async function closeAllPositions$1(auth, params = { cancel_orders: true, useLimi
                 // Continue with closure attempt even if cancel failed
             }
         }
-        const positions = await fetchAllPositions(auth);
-        if (positions.length === 0) {
+        const allPositions = await fetchAllPositions(auth);
+        if (allPositions.length === 0) {
             getLogger().info("No positions to close", {
                 account: auth.adapticAccountId || "direct",
             });
             return [];
         }
-        getLogger().info(`Found ${positions.length} positions to close`, {
-            account: auth.adapticAccountId || "direct",
-        });
+        // Separate crypto and equity positions — crypto cannot use SIP quotes or time_in_force="day"
+        const equityPositions = allPositions.filter((p) => !isCryptoSymbol(p.symbol));
+        const cryptoPositions = allPositions.filter((p) => isCryptoSymbol(p.symbol));
+        getLogger().info(`Found ${allPositions.length} positions to close (${equityPositions.length} equity, ${cryptoPositions.length} crypto)`, { account: auth.adapticAccountId || "direct" });
+        // Close crypto positions via direct DELETE (market order) — no SIP quotes needed
+        for (const position of cryptoPositions) {
+            try {
+                const { APIKey, APISecret, type } = await validateAuth(auth);
+                const apiBaseUrl = getTradingApiUrl(type);
+                const url = `${apiBaseUrl}/positions/${encodeURIComponent(position.symbol)}`;
+                const response = await fetch(url, {
+                    method: "DELETE",
+                    headers: {
+                        "APCA-API-KEY-ID": APIKey,
+                        "APCA-API-SECRET-KEY": APISecret,
+                    },
+                });
+                if (response.ok) {
+                    getLogger().info(`Closed crypto position ${position.symbol} via market order`, {
+                        account: auth.adapticAccountId || "direct",
+                        symbol: position.symbol,
+                    });
+                }
+                else {
+                    const errorText = await response.text();
+                    getLogger().warn(`Failed to close crypto position ${position.symbol}: ${response.status} ${errorText}`, { account: auth.adapticAccountId || "direct", symbol: position.symbol });
+                }
+            }
+            catch (cryptoError) {
+                getLogger().warn(`Error closing crypto position ${position.symbol}: ${cryptoError instanceof Error ? cryptoError.message : String(cryptoError)}`, { account: auth.adapticAccountId || "direct", symbol: position.symbol });
+            }
+        }
+        // Close equity positions via limit orders with SIP quotes
+        if (equityPositions.length === 0) {
+            return [];
+        }
         // 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 symbols = equityPositions.map((position) => position.symbol);
         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", {
+            getLogger().error("No quotes available for equity positions, received 0 quotes", {
                 account: auth.adapticAccountId || "direct",
                 type: "error",
             });
             return [];
         }
-        if (lengthOfQuotes !== positions.length) {
-            getLogger().warn(`Received ${lengthOfQuotes} quotes for ${positions.length} positions (expected ${positions.length}), proceeding with available quotes`, {
+        if (lengthOfQuotes !== equityPositions.length) {
+            getLogger().warn(`Received ${lengthOfQuotes} quotes for ${equityPositions.length} equity positions, proceeding with available quotes`, {
                 account: auth.adapticAccountId || "direct",
                 type: "warn",
             });
-            // 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) {
+        for (const position of equityPositions) {
             const quote = quotesResponse.quotes[position.symbol];
             if (!quote) {
                 getLogger().warn(`No quote available for ${position.symbol}, skipping limit order`, {
@@ -5985,31 +6041,63 @@ async function closeAllPositionsAfterHours$1(auth, params = { cancel_orders: tru
         account: auth.adapticAccountId || "direct",
     });
     const { cancel_orders, slippagePercent1 = 0.1 } = params;
-    const positions = await fetchAllPositions(auth);
-    if (positions.length === 0) {
+    const allPositions = await fetchAllPositions(auth);
+    if (allPositions.length === 0) {
         getLogger().info("No positions to close", {
             account: auth.adapticAccountId || "direct",
         });
         return;
     }
-    getLogger().info(`Found ${positions.length} positions to close`, {
-        account: auth.adapticAccountId || "direct",
-    });
+    // Separate crypto and equity positions
+    const equityPositions = allPositions.filter((p) => !isCryptoSymbol(p.symbol));
+    const cryptoPositions = allPositions.filter((p) => isCryptoSymbol(p.symbol));
+    getLogger().info(`Found ${allPositions.length} positions to close after hours (${equityPositions.length} equity, ${cryptoPositions.length} crypto)`, { account: auth.adapticAccountId || "direct" });
     if (cancel_orders) {
         await cancelAllOrders$1(auth);
         getLogger().info("Cancelled all open orders", {
             account: auth.adapticAccountId || "direct",
         });
     }
+    // Close crypto positions via direct DELETE (market order)
+    for (const position of cryptoPositions) {
+        try {
+            const { APIKey, APISecret, type } = await validateAuth(auth);
+            const apiBaseUrl = getTradingApiUrl(type);
+            const url = `${apiBaseUrl}/positions/${encodeURIComponent(position.symbol)}`;
+            const response = await fetch(url, {
+                method: "DELETE",
+                headers: {
+                    "APCA-API-KEY-ID": APIKey,
+                    "APCA-API-SECRET-KEY": APISecret,
+                },
+            });
+            if (response.ok) {
+                getLogger().info(`Closed crypto position ${position.symbol} via market order`, {
+                    account: auth.adapticAccountId || "direct",
+                    symbol: position.symbol,
+                });
+            }
+            else {
+                const errorText = await response.text();
+                getLogger().warn(`Failed to close crypto position ${position.symbol}: ${response.status} ${errorText}`, { account: auth.adapticAccountId || "direct", symbol: position.symbol });
+            }
+        }
+        catch (cryptoError) {
+            getLogger().warn(`Error closing crypto position ${position.symbol}: ${cryptoError instanceof Error ? cryptoError.message : String(cryptoError)}`, { account: auth.adapticAccountId || "direct", symbol: position.symbol });
+        }
+    }
+    if (equityPositions.length === 0) {
+        return;
+    }
     const alpacaAuthObj = {
         type: "LIVE",
         alpacaApiKey: process.env.ALPACA_API_KEY,
         alpacaApiSecret: process.env.ALPACA_SECRET_KEY,
     };
     const alpacaAuth = alpacaAuthObj;
-    const symbols = positions.map((position) => position.symbol);
+    const symbols = equityPositions.map((position) => position.symbol);
     const quotesResponse = await getLatestQuotes$1(alpacaAuth, { symbols });
-    for (const position of positions) {
+    for (const position of equityPositions) {
         const quote = quotesResponse.quotes[position.symbol];
         if (!quote) {
             getLogger().warn(`No quote available for ${position.symbol}, skipping limit order`, {
@@ -6048,7 +6136,7 @@ async function closeAllPositionsAfterHours$1(auth, params = { cancel_orders: tru
             extended_hours: true,
         });
     }
-    getLogger().info(`All positions closed: ${positions.map((p) => p.symbol).join(", ")}`, {
+    getLogger().info(`All positions closed: ${allPositions.map((p) => p.symbol).join(", ")}`, {
         account: auth.adapticAccountId || "direct",
     });
 }