Fix: Credit/Debit in ComboLimitOrder (#16)

* fix: credit vs debit converting process
test:feat: validate expected PriceEffect of ComboLimitOrder

* feat: better exception msg in Send HTTP Request

* feat: GetPriceEffect extension

* refactor: use quantity by default in GetPriceEffect

Author: Romazes

QuantConnect.TastytradeBrokerage.Tests/TastytradeBrokerageTests.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -105,7 +105,7 @@ private static IEnumerable<TestCaseData> ComboOrderTestParameters
         {
             var nvda = Symbol.Create("NVDA", SecurityType.Equity, Market.USA);
             var nvdaCanonical = Symbol.CreateCanonicalOption(nvda);
-            yield return new TestCaseData(new ComboLimitOrderTestParameters(OptionStrategies.BearCallSpread(nvdaCanonical, 180m, 190m, new DateTime(2025, 10, 17)), 3.1m, 3.1m, 0.5m));
+            yield return new TestCaseData(new ComboLimitOrderTestParameters(OptionStrategies.BearCallSpread(nvdaCanonical, 210m, 220m, new DateTime(2025, 11, 21)), 3.1m, 3.1m, 1.1m));
         }
     }
 

QuantConnect.TastytradeBrokerage.Tests/TastytradeJsonConverterTests.cs

@@ -513,18 +513,18 @@ public void SerializeLegAttributes()
         Assert.AreEqual(expectedLegAttributes, actualLegAttributes);
     }
 
-    [TestCase(OrderType.Market, InstrumentType.Equity, OrderAction.BuyToOpen, TimeInForce.Day, null, null, null, null)]
-    [TestCase(OrderType.Market, InstrumentType.EquityOption, OrderAction.Sell, TimeInForce.Day, null, null, null, null)]
-    [TestCase(OrderType.Limit, InstrumentType.Future, OrderAction.BuyToOpen, TimeInForce.GoodTillCancel, null, 100, null, Orders.OrderDirection.Buy)]
-    [TestCase(OrderType.Limit, InstrumentType.FutureOption, OrderAction.SellToClose, TimeInForce.GoodTillCancel, null, 200, null, Orders.OrderDirection.Sell)]
-    [TestCase(OrderType.Stop, InstrumentType.Equity, OrderAction.BuyToOpen, TimeInForce.GoodTilDate, "2025/05/30", null, 210, null)]
-    [TestCase(OrderType.Stop, InstrumentType.EquityOption, OrderAction.SellToOpen, TimeInForce.GoodTillCancel, null, null, 190, null)]
-    [TestCase(OrderType.Stop, InstrumentType.Equity, OrderAction.Buy, TimeInForce.Day, null, null, 190, null)]
-    [TestCase(OrderType.StopLimit, InstrumentType.Equity, OrderAction.Buy, TimeInForce.GoodTilDate, "2025/05/30", 180, 190, Orders.OrderDirection.Buy)]
-    [TestCase(OrderType.StopLimit, InstrumentType.EquityOption, OrderAction.SellToOpen, TimeInForce.Day, null, 200, 190, Orders.OrderDirection.Sell)]
-    public void SerializeVariousOrderTypeRequestMessage(OrderType orderType, InstrumentType instrumentType, OrderAction legOrderAction, TimeInForce timeInForce, DateTime? expiryDateTime, decimal? limitPrice, decimal? stopPrice, Orders.OrderDirection? leanOrderDirection)
-    {
-        var legAttributes = new List<LegAttributes> { new LegAttributes(legOrderAction, instrumentType, 1m, "AAPL  230818C00197500") };
+    [TestCase(OrderType.Market, InstrumentType.Equity, OrderAction.BuyToOpen, TimeInForce.Day, null, null, null, 1, null)]
+    [TestCase(OrderType.Market, InstrumentType.EquityOption, OrderAction.Sell, TimeInForce.Day, null, null, null, 1, null)]
+    [TestCase(OrderType.Limit, InstrumentType.Future, OrderAction.BuyToOpen, TimeInForce.GoodTillCancel, null, 100, null, 1, PriceEffect.Debit)]
+    [TestCase(OrderType.Limit, InstrumentType.FutureOption, OrderAction.SellToClose, TimeInForce.GoodTillCancel, null, 200, null, -1, PriceEffect.Credit)]
+    [TestCase(OrderType.Stop, InstrumentType.Equity, OrderAction.BuyToOpen, TimeInForce.GoodTilDate, "2025/05/30", null, 210, 1, null)]
+    [TestCase(OrderType.Stop, InstrumentType.EquityOption, OrderAction.SellToOpen, TimeInForce.GoodTillCancel, null, null, 190, 1, null)]
+    [TestCase(OrderType.Stop, InstrumentType.Equity, OrderAction.Buy, TimeInForce.Day, null, null, 190, 1, null)]
+    [TestCase(OrderType.StopLimit, InstrumentType.Equity, OrderAction.Buy, TimeInForce.GoodTilDate, "2025/05/30", 180, 190, 1, PriceEffect.Debit)]
+    [TestCase(OrderType.StopLimit, InstrumentType.EquityOption, OrderAction.SellToOpen, TimeInForce.Day, null, 200, 190, -1, PriceEffect.Credit)]
+    public void SerializeVariousOrderTypeRequestMessage(OrderType orderType, InstrumentType instrumentType, OrderAction legOrderAction, TimeInForce timeInForce, DateTime? expiryDateTime, decimal? limitPrice, decimal? stopPrice, decimal quantity, PriceEffect? expectedPriceEffect)
+    {
+        var legAttributes = new List<LegAttributes> { new LegAttributes(legOrderAction, instrumentType, quantity, "AAPL  230818C00197500") };
 
         var order = default(OrderBaseRequest);
         switch (orderType)
@@ -533,18 +533,60 @@ public void SerializeVariousOrderTypeRequestMessage(OrderType orderType, Instrum
                 order = new MarketOrderRequest(legAttributes);
                 break;
             case OrderType.Limit:
-                order = new LimitOrderRequest(timeInForce, expiryDateTime, legAttributes, limitPrice.Value, leanOrderDirection.Value);
+                var lo = new Orders.LimitOrder(default, quantity, limitPrice.Value, default);
+                order = new LimitOrderRequest(timeInForce, expiryDateTime, legAttributes, limitPrice.Value, lo.GetPriceEffect());
                 break;
             case OrderType.Stop:
                 order = new StopMarketOrderRequest(timeInForce, expiryDateTime, legAttributes, stopPrice.Value, instrumentType);
                 break;
             case OrderType.StopLimit:
-                order = new StopLimitOrderRequest(timeInForce, expiryDateTime, legAttributes, limitPrice.Value, stopPrice.Value, leanOrderDirection.Value);
+                var slo = new Orders.StopLimitOrder(default, quantity, default, default, default);
+                order = new StopLimitOrderRequest(timeInForce, expiryDateTime, legAttributes, limitPrice.Value, stopPrice.Value, slo.GetPriceEffect());
                 break;
             default:
                 throw new NotSupportedException();
         }
 
+        if (expectedPriceEffect != null)
+        {
+            Assert.AreEqual(expectedPriceEffect.Value, order.PriceEffect.Value);
+        }
+
+        var orderJson = order.ToJson();
+
+        AssertIsNotNullAndIsNotEmpty(orderJson);
+    }
+
+    [TestCase(true, 0.65, PriceEffect.Debit)]
+    [TestCase(false, -0.65, PriceEffect.Credit)]
+    public void SerializeComboLimitOrderTypeRequestMessage(bool isLong, decimal limitPrice, PriceEffect expectedPriceEffect)
+    {
+        var buyToOpen = new LegAttributes(OrderAction.BuyToOpen, InstrumentType.EquityOption, 1m, "AAPL  251107C00275000");
+        var sellToOpen = new LegAttributes(OrderAction.SellToOpen, InstrumentType.EquityOption, 1m, "AAPL  251107C00270000");
+
+        var legs = default(List<LegAttributes>);
+        var groupOrderManager = default(Orders.GroupOrderManager);
+        if (isLong)
+        {
+            // Vertical: Long
+            legs = [buyToOpen, sellToOpen];
+            groupOrderManager = new Orders.GroupOrderManager(legs.Count, quantity: 1, limitPrice);
+        }
+        else
+        {
+            // Vertical: Short
+            legs = [sellToOpen, buyToOpen];
+            groupOrderManager = new Orders.GroupOrderManager(legs.Count, quantity: 1, limitPrice);
+        }
+
+        var clo = new Orders.ComboLimitOrder(default, 1, limitPrice, default, groupOrderManager);
+
+        var order = new LimitOrderRequest(TimeInForce.GoodTillCancel, default, legs, groupOrderManager.LimitPrice, clo.GetPriceEffect());
+
+        Assert.AreEqual(expectedPriceEffect, order.PriceEffect);
+        Assert.True(order.Price.HasValue);
+        Assert.False(decimal.IsNegative(order.Price.Value));
+
         var orderJson = order.ToJson();
 
         AssertIsNotNullAndIsNotEmpty(orderJson);

QuantConnect.TastytradeBrokerage/Api/TastytradeApiClient.cs

@@ -253,13 +253,15 @@ private BaseResponse<T> SendRequest<T>(HttpMethod httpMethod, string endpoint, s
                 requestMessage.Content = new StringContent(jsonBody, Encoding.UTF8, "application/json");
             }
 
+            var response = default(string);
             try
             {
                 var responseMessage = _httpClient.Send(requestMessage);
 
-                responseMessage.EnsureSuccessStatusCode(requestMessage, jsonBody);
+                // Reads response content safely; returns empty string if response or content is null.
+                response = responseMessage.ReadContentAsString();
 
-                var response = responseMessage.ReadContentAsString();
+                responseMessage.EnsureSuccessStatusCode(requestMessage, jsonBody);
 
                 if (logResponse || Log.DebuggingEnabled)
                 {
@@ -270,7 +272,7 @@ private BaseResponse<T> SendRequest<T>(HttpMethod httpMethod, string endpoint, s
             }
             catch (Exception ex)
             {
-                throw new Exception($"{nameof(TastytradeApiClient)}.{nameof(SendRequest)}: Unexpected error while sending request - {ex.Message}", ex);
+                throw new Exception($"{nameof(TastytradeApiClient)}.{nameof(SendRequest)}: Unexpected error while sending request - {ex.Message}. Response: {response}.", ex);
             }
         }
     }

QuantConnect.TastytradeBrokerage/Extensions.cs

@@ -208,6 +208,37 @@ public static InstrumentType ConvertLeanSecurityTypeToBrokerageInstrumentType(th
         _ => throw new NotSupportedException($"The price effect '{priceEffect}' is not supported.")
     };
 
+    /// <summary>
+    /// Determines the <see cref="PriceEffect"/> (debit or credit) for a given <see cref="Order"/>
+    /// based on its signed quantity or equivalent value.
+    /// </summary>
+    /// <param name="order">The order instance to evaluate.</param>
+    /// <returns>
+    /// <see cref="PriceEffect.Debit"/> if the order represents a buy-side intent (positive quantity),
+    /// <see cref="PriceEffect.Credit"/> if it represents a sell-side intent (negative quantity).
+    /// </returns>
+    /// <exception cref="NotSupportedException">
+    /// Thrown when the order type or its quantity is not supported for conversion to <see cref="PriceEffect"/>.
+    /// </exception>
+    public static PriceEffect GetPriceEffect(this Order order)
+    {
+        var quantity = order.Quantity;
+        if (order is ComboLimitOrder clo)
+        {
+            quantity = clo.GroupOrderManager.LimitPrice * clo.GroupOrderManager.Quantity;
+        }
+
+        switch (quantity)
+        {
+            case > 0:
+                return PriceEffect.Debit;
+            case < 0:
+                return PriceEffect.Credit;
+            default:
+                throw new NotSupportedException($"Cannot determine PriceEffect: order quantity is zero (order type '{order.GetType().Name}').");
+        }
+    }
+
     /// <summary>
     /// Encodes special characters in a symbol to make it URL-safe.
     /// Specifically replaces slashes (/) with their URL-encoded form (%2f).

QuantConnect.TastytradeBrokerage/Models/Orders/LimitOrderRequest.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -37,10 +37,12 @@ public class LimitOrderRequest : OrderBaseRequest
     /// <param name="expiryDateTime">Expiration date if <paramref name="timeInForce"/> is GTC.</param>
     /// <param name="legs">The order legs to execute.</param>
     /// <param name="price">The limit price for the order.</param>
-    /// <param name="leanOrderDirection">Direction of the order (Buy/Sell).</param>
-    public LimitOrderRequest(TimeInForce timeInForce, DateTime? expiryDateTime, IReadOnlyCollection<LegAttributes> legs, decimal price, LeanOrderDirection leanOrderDirection)
-        : base(timeInForce, expiryDateTime, legs, leanOrderDirection)
+    /// <param name="priceEffect">
+    /// Indicates whether the order will debit or credit funds — typically
+    /// <see cref="PriceEffect.Debit"/> for buy-side orders and <see cref="PriceEffect.Credit"/> for sell-side orders.
+    /// </param>
+    public LimitOrderRequest(TimeInForce timeInForce, DateTime? expiryDateTime, IReadOnlyCollection<LegAttributes> legs, decimal price, PriceEffect priceEffect)
+        : base(timeInForce, expiryDateTime, legs, priceEffect, price)
     {
-        Price = price;
     }
 }

QuantConnect.TastytradeBrokerage/Models/Orders/OrderBaseRequest.cs

@@ -110,25 +110,26 @@ protected OrderBaseRequest(TimeInForce timeInForce, DateTime? expiryDateTime, IR
     /// <param name="legs">
     /// A collection of <see cref="LegAttributes"/> defining the individual legs of the order (e.g., quantity, symbol, action).
     /// </param>
-    /// <param name="leanOrderDirection">
-    /// The directional intent of the order from the LEAN engine (<see cref="LeanOrderDirection.Buy"/> or <see cref="LeanOrderDirection.Sell"/>).
-    /// Determines whether the <see cref="PriceEffect"/> is <see cref="PriceEffect.Debit"/> or <see cref="PriceEffect.Credit"/>.
+    /// <param name="priceEffect">
+    /// Indicates whether the order will debit or credit funds — typically
+    /// <see cref="PriceEffect.Debit"/> for buy-side orders and <see cref="PriceEffect.Credit"/> for sell-side orders.
+    /// </param>
+    /// <param name="price">
+    /// The absolute price associated with the order (e.g., limit, stop, or trigger price).
+    /// Negative values are automatically converted to their absolute value for consistency.
     /// </param>
     /// <exception cref="NotSupportedException">
     /// Thrown when <paramref name="leanOrderDirection"/> is not a supported direction (Buy/Sell).
     /// </exception>
     /// <exception cref="ArgumentNullException">
     /// Thrown when <paramref name="timeInForce"/> is <see cref="TimeInForce.GoodTilDate"/> and <paramref name="expiryDateTime"/> is null.
     /// </exception>
-    protected OrderBaseRequest(TimeInForce timeInForce, DateTime? expiryDateTime, IReadOnlyCollection<LegAttributes> legs, LeanOrderDirection leanOrderDirection)
+    protected OrderBaseRequest(TimeInForce timeInForce, DateTime? expiryDateTime, IReadOnlyCollection<LegAttributes> legs, PriceEffect priceEffect, decimal price)
         : this(timeInForce, expiryDateTime, legs)
     {
-        PriceEffect = leanOrderDirection switch
-        {
-            LeanOrderDirection.Buy => Enum.PriceEffect.Debit,
-            LeanOrderDirection.Sell => Enum.PriceEffect.Credit,
-            _ => throw new NotSupportedException($"The order direction '{leanOrderDirection}' is not supported for conversion to PriceEffect.")
-        };
+        // Ensure positive price for TastyTrade API
+        Price = Math.Abs(price);
+        PriceEffect = priceEffect;
     }
 
     /// <summary>

QuantConnect.TastytradeBrokerage/Models/Orders/StopLimitOrderRequest.cs

@@ -38,11 +38,13 @@ public class StopLimitOrderRequest : OrderBaseRequest
     /// <param name="legs">The order legs to execute.</param>
     /// <param name="price">The limit price for the order.</param>
     /// <param name="stopPrice">The stop trigger price for the order.</param>
-    /// <param name="leanOrderDirection">Direction of the order (Buy/Sell).</param>
-    public StopLimitOrderRequest(TimeInForce timeInForce, DateTime? expiryDateTime, IReadOnlyCollection<LegAttributes> legs, decimal price, decimal stopPrice, LeanOrderDirection leanOrderDirection)
-    : base(timeInForce, expiryDateTime, legs, leanOrderDirection)
+    /// <param name="priceEffect">
+    /// Indicates whether the order will debit or credit funds — typically
+    /// <see cref="PriceEffect.Debit"/> for buy-side orders and <see cref="PriceEffect.Credit"/> for sell-side orders.
+    /// </param>
+    public StopLimitOrderRequest(TimeInForce timeInForce, DateTime? expiryDateTime, IReadOnlyCollection<LegAttributes> legs, decimal price, decimal stopPrice, PriceEffect priceEffect)
+    : base(timeInForce, expiryDateTime, legs, priceEffect, price)
     {
-        Price = price;
         StopPrice = stopPrice;
     }
 }

QuantConnect.TastytradeBrokerage/TastytradeBrokerage.Brokerage.cs

@@ -776,16 +776,16 @@ private OrderBaseRequest ConvertLeanOrderToBrokerageOrder(LeanOrder order, IRead
                 brokerageOrder = new MarketOrderRequest(legs);
                 break;
             case LimitOrder lo:
-                brokerageOrder = new LimitOrderRequest(timeInForce, expiryDateTime, legs, lo.LimitPrice, order.Direction);
+                brokerageOrder = new LimitOrderRequest(timeInForce, expiryDateTime, legs, lo.LimitPrice, lo.GetPriceEffect());
                 break;
             case ComboLimitOrder clo:
-                brokerageOrder = new LimitOrderRequest(timeInForce, expiryDateTime, legs, clo.GroupOrderManager.LimitPrice, clo.GroupOrderManager.Direction);
+                brokerageOrder = new LimitOrderRequest(timeInForce, expiryDateTime, legs, clo.GroupOrderManager.LimitPrice, clo.GetPriceEffect());
                 break;
             case StopMarketOrder smo:
                 brokerageOrder = new StopMarketOrderRequest(timeInForce, expiryDateTime, legs, smo.StopPrice, legs[0].InstrumentType);
                 break;
             case StopLimitOrder slo:
-                brokerageOrder = new StopLimitOrderRequest(timeInForce, expiryDateTime, legs, slo.LimitPrice, slo.StopPrice, order.Direction);
+                brokerageOrder = new StopLimitOrderRequest(timeInForce, expiryDateTime, legs, slo.LimitPrice, slo.StopPrice, slo.GetPriceEffect());
                 break;
             default:
                 throw new NotSupportedException($"{nameof(TastytradeBrokerage)}.{nameof(ConvertLeanOrderToBrokerageOrder)}: The order type '{order.GetType().Name}' is not supported for brokerage conversion.");