Schwab Stop Loss/Take Profit submission results in brokerage error

from AlgorithmImports import *
import math
class OCOLimitStopAlgorithm(QCAlgorithm):
    """
    Manual OCO (one-cancels-other) bracket that works around Schwab’s restriction
    that the SUM of open exit-order quantities must never exceed the current
    position size.  After the entry fills it submits a take-profit Limit order
    and a stop-loss StopMarket order whose combined quantity equals (not
    exceeds) the position size.  As soon as either exit order fills, the other
    is cancelled in OnOrderEvent.  A tiny race window remains where both legs
    could fill before the cancel request is acknowledged, but the risk is
    minimal and unavoidable without native OCO support.
    """

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100_000)

        # Asset
        self._symbol: Symbol = self.add_equity("SPY", Resolution.MINUTE).symbol

        # Order-tracking state
        self._entry_ticket: OrderTicket | None = None
        self._limit_ticket: OrderTicket | None = None   # take-profit
        self._stop_ticket: OrderTicket | None = None    # stop-loss
        self._entry_filled_quantity: int = 0

        # Risk parameters
        self._take_profit_pct: float = 0.02  # +2 %
        self._stop_loss_pct: float = 0.01    # −1 %

        # Demo: enter once per day one minute after the open
        self.schedule.on(
            self.date_rules.every_day(self._symbol),
            self.time_rules.after_market_open(self._symbol, 1),
            self._open_position,
        )

    # ---------------------------------------------------------------------- #
    # Entry logic                                                             #
    # ---------------------------------------------------------------------- #
    def _open_position(self) -> None:
        """Submit a market entry if flat."""
        if self.portfolio[self._symbol].invested:
            return

        # Don’t send a new entry while a previous one is working
        if self._entry_ticket and self._entry_ticket.status not in (
            OrderStatus.CANCELED, OrderStatus.INVALID, OrderStatus.FILLED
        ):
            return

        quantity: int = self.calculate_order_quantity(self._symbol, 0.25)
        if quantity == 0:
            quantity = 1  # guarantee at least one share

        # Reset state
        self._entry_filled_quantity = 0
        self._limit_ticket = None
        self._stop_ticket = None

        # Synchronous market order
        self._entry_ticket = self.market_order(self._symbol, quantity, tag="Entry")

    # ---------------------------------------------------------------------- #
    # Order-event handler                                                    #
    # ---------------------------------------------------------------------- #
    def on_order_event(self, order_event: OrderEvent) -> None:
        # 1) Track ENTRY fills
        if self._entry_ticket and order_event.order_id == self._entry_ticket.order_id:
            if order_event.status == OrderStatus.FILLED:
                # Accumulate filled shares (handles partial fills)
                self._entry_filled_quantity += abs(order_event.fill_quantity)

                # Once the entry is completely filled, create exit orders
                if self._entry_filled_quantity == abs(self._entry_ticket.quantity):
                    self._submit_exit_orders(
                        self._entry_filled_quantity, order_event.fill_price
                    )
            elif order_event.status == OrderStatus.PARTIALLY_FILLED:
                self._entry_filled_quantity += abs(order_event.fill_quantity)

        # 2) Manual OCO behaviour
        #    • If the take-profit fills → cancel stop-loss
        if (
            self._limit_ticket
            and order_event.order_id == self._limit_ticket.order_id
            and order_event.status == OrderStatus.FILLED
        ):
            if self._stop_ticket and self._stop_ticket.status in (
                OrderStatus.SUBMITTED, OrderStatus.NEW, OrderStatus.PARTIALLY_FILLED
            ):
                self._stop_ticket.cancel("Take-profit filled → cancel stop-loss (OCO)")

        #    • If the stop-loss fills → cancel take-profit
        if (
            self._stop_ticket
            and order_event.order_id == self._stop_ticket.order_id
            and order_event.status == OrderStatus.FILLED
        ):
            if self._limit_ticket and self._limit_ticket.status in (
                OrderStatus.SUBMITTED, OrderStatus.NEW, OrderStatus.PARTIALLY_FILLED
            ):
                self._limit_ticket.cancel("Stop-loss filled → cancel take-profit (OCO)")

    # ---------------------------------------------------------------------- #
    # Exit-order creation                                                    #
    # ---------------------------------------------------------------------- #
    def _submit_exit_orders(self, qty: int, avg_price: float) -> None:
        """
        Create paired Limit (take-profit) and StopMarket (stop-loss) orders.

        To satisfy Schwab rules, the combined quantity of BOTH orders is split
        so their sum == position size (never > size).  Any odd share is
        assigned to the take-profit leg.
        """
        if qty <= 0 or self._limit_ticket or self._stop_ticket:
            return

        # Split size so limit_qty + stop_qty == qty
        limit_qty: int = int(math.ceil(qty / 2))
        stop_qty: int = qty - limit_qty  # remainder

        take_profit_price: float = round(avg_price * (1 + self._take_profit_pct), 2)
        stop_loss_price: float = round(avg_price * (1 - self._stop_loss_pct), 2)

        if limit_qty > 0:
            self._limit_ticket = self.limit_order(
                self._symbol, -limit_qty, take_profit_price, tag="Take-Profit"
            )

        if stop_qty > 0:
            self._stop_ticket = self.stop_market_order(
                self._symbol, -stop_qty, stop_loss_price, tag="Stop-Loss"
            )

How this addresses Schwab's limitations:

• After the entry is completely filled, two exit orders are submitted, but their combined (absolute) quantities never exceed the filled position size. For example, if you buy 5 shares, you get a take-profit limit sell for 3 and a stop market sell for 2 (or vice versa).
• As soon as one exit order fills, the other is immediately canceled—this manually enforces OCO behavior.
• This avoids Schwab's error about overbought/oversold conditions since you're never trying to close out more than you own.
• There's a very narrow race condition where both exit orders could fill at the same time, but this is unlikely and hard to avoid without native OCO support at the brokerage/API level.

If Schwab or QuantConnect adds native OCO support in the future, this logic can be simplified. For now, this is the most reliable workaround to avoid the error and maintain OCO logic as much as possible.

Sources: Stop Limit Order Regression Algorithm, Other Order Types - QuantConnect.com, Stop Limit Orders - QuantConnect.com, docs writing algorithms trading and orders order management order tickets, Limit If Touched Regression Algorithm