Improvement for step functions latencies

The step functions were providing poor UX in slow debugging sessions.
The debug buttons were unresponsive for longer times cause users to
repeatedly click on stepping buttons which leads to multiple unintended
step operations.

In this implementation, a timeouted response is returned to the user
interface to change the UI state properly. For this purpose, we
implemented:

- A new utility function called `sendResponseWithTimeout` to handle the
  operation.
- Improved the `nextRequest`, `stepInRequest` and `stepOutRequest`
  methods to introduce the timeouted response, with a default of 100ms
  timeout.
- Introduce a new launch variable called `steppingResponseTimeout` to
  provide an option that user can change the default timeout for
  stepping functions.

Author: asimgunes

src/constants/session.ts

@@ -0,0 +1,15 @@
+/*********************************************************************
+ * Copyright (c) 2025 Renesas Electronics Corporation and others
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *********************************************************************/
+
+/**
+ * The default stepping response timeout.
+ * Used if it is not defined in the launch configuration.
+ */
+export const DEFAULT_STEPPING_RESPONSE_TIMEOUT = 100;

src/desktop/GDBTargetDebugSession.ts

@@ -164,7 +164,7 @@ export class GDBTargetDebugSession extends GDBDebugSession {
         args: TargetLaunchRequestArguments | TargetAttachRequestArguments
     ) {
         await this.setupCommonLoggerAndBackends(args);
-        this.initializeCustomResetCommands(args);
+        this.initializeSessionArguments(args);
 
         if (request === 'launch') {
             const launchArgs = args as TargetLaunchRequestArguments;

src/gdb/GDBDebugSessionBase.ts

@@ -43,6 +43,8 @@ import { IGDBBackend, IGDBBackendFactory } from '../types/gdb';
 import { getInstructions } from '../util/disassembly';
 import { calculateMemoryOffset } from '../util/calculateMemoryOffset';
 import { isWindowsPath } from '../util/isWindowsPath';
+import { sendResponseWithTimeout } from '../util/sendResponseWithTimeout';
+import { DEFAULT_STEPPING_RESPONSE_TIMEOUT } from '../constants/session';
 
 class ThreadWithStatus implements DebugProtocol.Thread {
     id: number;
@@ -166,6 +168,12 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
      */
     protected customResetCommands?: string[];
 
+    /**
+     *  steppingResponseTimeout from launch.json
+     */
+    protected steppingResponseTimeout: number =
+        DEFAULT_STEPPING_RESPONSE_TIMEOUT;
+
     constructor(protected readonly backendFactory: IGDBBackendFactory) {
         super();
         this.logger = logger;
@@ -242,10 +250,12 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
      * Apply the initial custom reset arguments.
      * @param args the arguments from the user to apply custom reset arguments to.
      */
-    protected initializeCustomResetCommands(
+    protected initializeSessionArguments(
         args: LaunchRequestArguments | AttachRequestArguments
     ) {
         this.customResetCommands = args.customResetCommands;
+        this.steppingResponseTimeout =
+            args.steppingResponseTimeout ?? DEFAULT_STEPPING_RESPONSE_TIMEOUT;
     }
 
     /**
@@ -1151,55 +1161,88 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
         response: DebugProtocol.NextResponse,
         args: DebugProtocol.NextArguments
     ): Promise<void> {
-        try {
-            await (args.granularity === 'instruction'
-                ? mi.sendExecNextInstruction(this.gdb, args.threadId)
-                : mi.sendExecNext(this.gdb, args.threadId));
-            this.sendResponse(response);
-        } catch (err) {
-            this.sendErrorResponse(
-                response,
-                1,
-                err instanceof Error ? err.message : String(err)
-            );
-        }
+        return sendResponseWithTimeout({
+            execute: async () => {
+                await (args.granularity === 'instruction'
+                    ? mi.sendExecNextInstruction(this.gdb, args.threadId)
+                    : mi.sendExecNext(this.gdb, args.threadId));
+            },
+            onResponse: () => {
+                this.sendResponse(response);
+            },
+            onError: (err) => {
+                const errorMessage =
+                    err instanceof Error ? err.message : String(err);
+
+                this.sendEvent(
+                    new OutputEvent(
+                        `Error occurred during the nextRequest: ${errorMessage}\n`,
+                        'console'
+                    )
+                );
+                this.sendErrorResponse(response, 1, errorMessage);
+            },
+            timeout: this.steppingResponseTimeout,
+        });
     }
 
     protected async stepInRequest(
         response: DebugProtocol.StepInResponse,
         args: DebugProtocol.StepInArguments
     ): Promise<void> {
-        try {
-            await (args.granularity === 'instruction'
-                ? mi.sendExecStepInstruction(this.gdb, args.threadId)
-                : mi.sendExecStep(this.gdb, args.threadId));
-            this.sendResponse(response);
-        } catch (err) {
-            this.sendErrorResponse(
-                response,
-                1,
-                err instanceof Error ? err.message : String(err)
-            );
-        }
+        return sendResponseWithTimeout({
+            execute: async () => {
+                await (args.granularity === 'instruction'
+                    ? mi.sendExecStepInstruction(this.gdb, args.threadId)
+                    : mi.sendExecStep(this.gdb, args.threadId));
+            },
+            onResponse: () => {
+                this.sendResponse(response);
+            },
+            onError: (err) => {
+                const errorMessage =
+                    err instanceof Error ? err.message : String(err);
+
+                this.sendEvent(
+                    new OutputEvent(
+                        `Error occurred during the stepInRequest: ${errorMessage}\n`,
+                        'console'
+                    )
+                );
+                this.sendErrorResponse(response, 1, errorMessage);
+            },
+            timeout: this.steppingResponseTimeout,
+        });
     }
 
     protected async stepOutRequest(
         response: DebugProtocol.StepOutResponse,
         args: DebugProtocol.StepOutArguments
     ): Promise<void> {
-        try {
-            await mi.sendExecFinish(this.gdb, {
-                threadId: args.threadId,
-                frameId: 0,
-            });
-            this.sendResponse(response);
-        } catch (err) {
-            this.sendErrorResponse(
-                response,
-                1,
-                err instanceof Error ? err.message : String(err)
-            );
-        }
+        return sendResponseWithTimeout({
+            execute: async () => {
+                await mi.sendExecFinish(this.gdb, {
+                    threadId: args.threadId,
+                    frameId: 0,
+                });
+            },
+            onResponse: () => {
+                this.sendResponse(response);
+            },
+            onError: (err) => {
+                const errorMessage =
+                    err instanceof Error ? err.message : String(err);
+
+                this.sendEvent(
+                    new OutputEvent(
+                        `Error occurred during the stepOutRequest: ${errorMessage}\n`,
+                        'console'
+                    )
+                );
+                this.sendErrorResponse(response, 1, errorMessage);
+            },
+            timeout: this.steppingResponseTimeout,
+        });
     }
 
     protected async continueRequest(