Yes it does - I think you need to adjust your options filter to include all contracts.

Yes, this is how I access it for live trading, not sure about research

def OptionsFilterqqqcoveredcall(self, data):
        callcontractsqqq = self.OptionChainProvider.GetOptionContractList(self.symbolqqq, data.Time)
        self.underlyingPriceqqq = self.Securities[self.symbolqqq].Price
        qqqotm_calls = [i for i in callcontractsqqq if i.ID.OptionRight == OptionRight.Call and
                                            i.ID.StrikePrice > self.qqqCoveredCallOTM * self.underlyingPriceqqq and
                                            (i.ID.Date - data.Time).days == -1]
                                            
        if len(qqqotm_calls) > 0:
            callqqqcontract = sorted(sorted(qqqotm_calls, key = lambda x: abs(x.ID.StrikePrice - self.underlyingPriceqqq)))[0]
            if callqqqcontract not in self.coveredcallcontractsAddedqqq:
                self.coveredcallcontractsAddedqqq.add(callqqqcontract)
                self.AddOptionContract(callqqqcontract, Resolution.Minute)
            contractarray = sorted(sorted(qqqotm_calls, key = lambda x: abs(x.ID.StrikePrice - self.underlyingPriceqqq)))
            strikes = [x.ID.StrikePrice for x in contractarray]
            self.qqqdtezerostrike[0] = strikes[0]
            self.Log("QQQ Opt filter Call contract {0}".format(callqqqcontract))
            self.Log("contract strike price: {0}".format(self.qqqdtezerostrike[0]))
            return callqqqcontract
        else:
            return str()
+ Expand
- Collapse

this is the code i use for both backtesting and live trading. there's a more detailed discussion of 0DTE on their discord. couldn't find much of anything on the forums as it's still so new. 

underlying = self.algorithm.AddIndex("SPX", Resolution.Minute)
options = self.algorithm.AddIndexOption(underlying.Symbol, "SPXW", Resolution.Minute)
options.SetFilter(lambda u: u.WeeklysOnly().Strikes(-1, 1).Expiration(0, 0))
self.algorithm.symbol = options.Symbol

This took me a second to figure out too. I was trying to request a long stretch of minute resolution data in the research environment and was running into memory issues, so the function breaks down the history requests into chunks. You may not need this feature if the start date and end date are close together, but I don't think it'll hurt. Debug statements are left in for you to check if the returning data frames match your expectations easily. 

def get_historical_options(start_date, end_date, qb, res, batch_size=10):
    equity_symbol = qb.AddEquity("SPY", dataNormalizationMode=DataNormalizationMode.Raw).Symbol
    option = qb.AddOption(equity_symbol)
    option_chain_provider = qb.OptionChainProvider
    # Get trading days
    trading_days = [day for day in qb.TradingCalendar.GetTradingDays(start_date, end_date) if day.BusinessDay]
    trading_days.sort(key=lambda day: day.Date)
    print(f'trading_days: {len(trading_days)}')
    all_options_data = []
    for i in range(0, len(trading_days), batch_size):
        # Get trading days for batch
        batch_days = trading_days[i:i+batch_size]
        # Get option symbols for each day in the batch
        for j in range(len(batch_days) - 1):
            
            b_days_counter += len(batch_days)
            
            # Get option symbols for batch
            expiration_date = batch_days[j].Date.date()
            options_symbols = qb.OptionChainProvider.GetOptionContractList(equity_symbol, expiration_date)
            sample_symbol = options_symbols[0]
            # Filter 0DTE options
            zero_dte_symbols = [symbol for symbol in options_symbols if symbol.ID.Date.date() == expiration_date]
            print(f'experiation date: {expiration_date} has {len(zero_dte_symbols)} 0DTE options_symbols')
            # Get historical data for batch
            batch_options_data = []
            if len(zero_dte_symbols) > 0:
                qb.SetStartDate(expiration_date)
                for option in zero_dte_symbols:
                    qb.AddOptionContract(option, fillForward = False)
                    contract_history = qb.History(option, timedelta(days=1))
                    print(f'contract_history: {contract_history.shape[0]} / {contract_history.index.names}')
                    batch_options_data.append(contract_history)
            
                batch_options_data = pd.concat(batch_options_data)
                print(f'batch_options_data: {batch_options_data.shape[0]} / {batch_options_data.index.names}')
            
            # Append batch data to list
            if len(batch_options_data) > 0:
                all_options_data.append(batch_options_data)
    
    # Concatenate all batch data into a single DataFrame
    all_options_data = pd.concat(all_options_data, ignore_index=False)
    print(f'all_options_data: {all_options_data.shape[0]} / {all_options_data.index.names}')
    
    return all_options_data
+ Expand
- Collapse