const HTTP_PARENT_HANDLER = new InjectionToken<HttpHandler>('HTTP_PARENT_HANDLER');

// withRequestsMadeViaParent()
[
 {
   provide: HTTP_PARENT_HANDLER,
   useFactory: () => inject(HttpHandler, {skipSelf: true}),
 },
 {
   provide: HttpBackend,
   useExisting: HTTP_PARENT_HANDLER,
 },
];

// HttpInterceptorHandler
private readonly parentHandler = inject(HTTP_PARENT_HANDLER, {
 self: true,
 optional: true,
});

const rootInterceptorFns = this.injector.get(
 HTTP_ROOT_INTERCEPTOR_FNS,
 [],
 this.backend === this.parentHandler ? {self: true} : undefined,
);

export const ɵHTTP_CLIENT_IS_DELEGATING = new InjectionToken<boolean>('ɵHTTP_CLIENT_IS_DELEGATING');

// packages/common/http/src/provider.ts
export function withRequestsMadeViaParent(): HttpFeature<HttpFeatureKind.RequestsMadeViaParent> {
  return makeHttpFeature(HttpFeatureKind.RequestsMadeViaParent, [
    {
      provide: HttpBackend,
      useFactory: () => {
        const handlerFromParent = inject(HttpHandler, {skipSelf: true, optional: true});
        // ... error handling ...
        return handlerFromParent; // Return directly
      },
    },
    {
      provide: ɵHTTP_CLIENT_IS_DELEGATING,
      useValue: true
    }
  ]);
}

// packages/common/http/src/backend.ts (Inside HttpInterceptorHandler)
handle(initialRequest: HttpRequest<any>): Observable<HttpEvent<any>> {
  if (this.chain === null) {
    // Query with {self: true} to strictly check if the *current* client configuration is delegating
    const isDelegating = this.injector.get(ɵHTTP_CLIENT_IS_DELEGATING, false, {self: true});

    const rootInterceptorFns = this.injector.get(
      HTTP_ROOT_INTERCEPTOR_FNS,
      [],
      isDelegating ? {self: true} : undefined,
    );
    // ...

it('should inherit root interceptors when withXhr overrides parent delegation', () => {
      TestBed.configureTestingModule({
        providers: [
          provideHttpClient(),
          {
            provide: HTTP_ROOT_INTERCEPTOR_FNS,
            useValue: makeLiteralTagInterceptorFn('root'),
            multi: true,
          },
        ],
      });

      const child = createEnvironmentInjector(
        [
          provideHttpClient(withRequestsMadeViaParent(), withXhr()),
          {provide: XhrFactory, useClass: MockXhrFactory},
        ],
        TestBed.inject(EnvironmentInjector),
      );

      try {
        child.get(HttpClient).get('/test').subscribe();
        const factory = child.get(XhrFactory) as MockXhrFactory;
        expect(factory.mock.mockHeaders['X-Tag']).toBe('root');
        factory.mock.mockFlush(200, 'OK', '{}');
      } finally {
        child.destroy();
      }
    });