Pausing or adding new breakpoints halfway during running in VSCode makes the Python Exception lost

[hellohawaii]

Environment data

• debugpy version: 1.8.13
• OS and version: Linux abc 5.15.0-139-generic #149 ~20.04.1-Ubuntu SMP Wed Apr 16 08:29:56 UTC 2025 x86_64 x86_64 x86_64 GNU/Linux
• Python version (& distribution if applicable, e.g. Anaconda): Python 3.10.18 (miniconda 23.5.2)
• Using VS Code or Visual Studio: VSCode

Actual behavior

Pausing or adding new breakpoints halfway during debugging in VSCode seems to make the Python Exception uncaught.

The following is a minimal example to reproduce my problem.

import contextlib, signal

@contextlib.contextmanager
def time_limit(seconds):
    def signal_handler(signum, frame):
        raise RuntimeError("Timed out!")

    signal.setitimer(signal.ITIMER_REAL, seconds)
    signal.signal(signal.SIGALRM, signal_handler)
    try:
        yield
    finally:
        signal.setitimer(signal.ITIMER_REAL, 0)
    

if __name__ == "__main__":
    print("start")
    try:
        with time_limit(10):
            a=1
            while True:
                a = -a
    except RuntimeError:
        print("timed out")
    print("finished")

Different ways of debugging will give different results:

1. Use Pause. The exception is not caught. I click the pause (F6) halfway through running, and the program pauses on the line a=-a as expected. After several seconds, the time limit is reached, and the RuntimeError is thrown, but the program fails to catch the error. The trackback is printed in the console, but the program is not interrupted (still paused). As a result, the program will run forever after clicking continue (F5).

2. Use preset breakpoint. The exception is caught. In contrast, if you set a breakpoint at the a=-a. Run the program, and the program will stop at the breakpoint. Wait a few seconds, and the program will catch the runtime error and finish successfully. The program will continue automatically once it receives the Exception without the user's permission, which is also strange to me.

3. Add a breakpoint halfway. The exception is not caught. If you add a new breakpoint at a=-a after the program runs for a while, you can find the same behavior as "using Pause". In my opinion, "Pause" may be implemented by "adding a breakpoint halfway"? If this is correct, then this problem may be about "adding a breakpoint while running".

More experimental results:
When using Pause. After pausing, if I switch to the Debug Console, the following message will be thrown when the time limit is reached:

<class 'RuntimeError'> raised from within the callback set in sys.settrace.
Debugging will be disabled for this thread (<_MainThread(MainThread, started 140324903388352)>).

Expected behavior

I expect both 1(Use Pause) and 3(Add a breakpoint halfway) to behave similarly to 2(Use preset breakpoint).

Steps to reproduce:

1. As stated in Actual behavior, just try to debug the code in three different ways.

[rchiodo]

My guess is this is because the signal has to go to the 'main' thread of the application and that's interfering with debugpy. Even just stepping through this code messes things up.

Pause and breakpoints in this app work a lot better:

import threading
import time

def long_running_task():
    a = 1
    while a < 1000:
        time.sleep(0.01)
        a += 1 # Pause and dynamic breakpoint works fine on this line
    print("Thread completed")

thread = threading.Thread(target=long_running_task)
thread.start()

thread.join(timeout=5)

if thread.is_alive():
    print("Thread timed out!")
else:
    print("Thread finished in time.")