Can't retry request after awaiting response about protobuf-ts HOT 2 CLOSED

export default (): RpcInterceptor => ({
  interceptUnary(
    next: NextUnaryFn,
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    method: MethodInfo<any, any>,
    input: object,
    options: RpcOptions,
  ): UnaryCall {
    let defHeader = new Deferred<RpcMetadata>();
    let defMessage = new Deferred<object>();
    let defStatus = new Deferred<RpcStatus>();
    let defTrailer = new Deferred<RpcMetadata>();

    void (async () => {
      try {
        const first_try = await next(method, input, options);

        // If the response doesn't have an auth error then resolve and exit.
        if (!isAuthError(first_try.response)) {
          defHeader.resolve(first_try.headers);
          defMessage.resolve(first_try.response);
          defStatus.resolve(first_try.status);
          defTrailer.resolve(first_try.trailers);
          return;
        }

        // Otherwise try again with a reset auth status
        console.warn(`[${method.name}] auth error, unauthenticating & retrying...`);

        const second_try = await next(
          method,
          {
            ...input,
            authStatus: {},
          },
          options,
        );

        // If the second attempt's response also has an auth error then throw a custom RpcError.
        if (isAuthError(second_try.response)) {
          const error = new RpcError(
            'The request does not have valid authentication credentials for the operation',
            'UNAUTHENTICATED',
            {...second_try.headers, ...second_try.trailers}
          );
          error.methodName = method.name;
          error.serviceName = method.service.typeName;
          throw error;
        }

        defHeader.resolve(second_try.headers);
        defMessage.resolve(second_try.response);
        defStatus.resolve(second_try.status);
        defTrailer.resolve(second_try.trailers);
      } catch (err) {
        defHeader.rejectPending(err);
        defMessage.rejectPending(err);
        defStatus.rejectPending(err);
        defTrailer.rejectPending(err);
      }
    })();

    return new UnaryCall(
      method,
      options.meta ?? {},
      input,
      defHeader.promise,
      defMessage.promise,
      defStatus.promise,
      defTrailer.promise,
    );
  },
});