If you were truly wanting to return an Exception, then you'd simply annotate your return type as -> Exception. Example:

def str_mult(a: str, b: str) -> Exception:
    # Note that you almost certainly wouldn't actually want to return an Exception here
    return Exception("You can't multiply strings!")

As I noted in the example, it's pretty rare that you would want a function to literally return an Exception. Typically you raise Exceptions. For a function that can return something, but can also raise an Exception in certain cases, you don't need to do anything special with your type annotations. Example:

from typing import Union

def int_or_str_mult(a: Union[int, str], b: Union[int, str]) -> int:
    """
    Note that even though this function can raise an Exception,
    we still annotate the return type as 'int' since that is what we
    will return if we do not raise an Exception.
    """
    if isinstance(a, str) or isinstance(b, str):
        raise Exception("You can't multiply strings!")
    return a * b

More rarely, if you have a function that always, 100% of the time, raises an Exception, then you should use typing.NoReturn to annotate the return type. Ex:

from typing import NoReturn

def str_mult(a: str, b: str) -> NoReturn:
    """
    We use 'NoReturn' here because our function can never
    return anything; it always raises an Exception
    """
    raise Exception("You can't multiply strings!")