Struct DapClient 

pub struct DapClient {
    pub capabilities: Capabilities,
    /* private fields */
}

DAP client for communicating with a debug adapter

Fields

capabilities: Capabilities

Adapter capabilities (populated after initialize)

Implementations

impl DapClient

pub async fn spawn(adapter_path: &Path, args: &[String]) -> Result<Self>

Spawn a new DAP adapter and create a client

pub async fn spawn_tcp(adapter_path: &Path, args: &[String]) -> Result<Self>

Spawn a new DAP adapter that uses TCP for communication (e.g., Delve)

This spawns the adapter with a –listen flag, waits for it to output the port it’s listening on, then connects via TCP.

pub fn take_event_receiver(&mut self) -> Option<UnboundedReceiver<Event>>

Take the event receiver (can only be called once)

pub async fn request<T: DeserializeOwned>( &mut self, command: &str, arguments: Option<Value>, ) -> Result<T>

Send a request and wait for the response with timeout

pub async fn request_with_timeout<T: DeserializeOwned>( &mut self, command: &str, arguments: Option<Value>, timeout: Duration, ) -> Result<T>

Send a request and wait for the response with configurable timeout

Note: We register the pending response handler BEFORE sending the request to avoid a race condition where a fast adapter response arrives before we’ve set up the handler.

pub async fn poll_event(&mut self) -> Result<Option<Event>>

Poll for events - this is now non-blocking since events are already in the channel Note: This method is kept for API compatibility but is no longer necessary since the background reader task handles all event ingestion

pub async fn initialize(&mut self, adapter_id: &str) -> Result<Capabilities>

Initialize the debug adapter

pub async fn initialize_with_timeout( &mut self, adapter_id: &str, timeout: Duration, ) -> Result<Capabilities>

Initialize the debug adapter with configurable timeout

pub async fn wait_initialized(&mut self) -> Result<()>

Wait for the initialized event with timeout

This method waits for the initialized event which comes through the event channel. It’s called before the session takes the event receiver.

pub async fn wait_initialized_with_timeout( &mut self, timeout: Duration, ) -> Result<()>

Wait for the initialized event with configurable timeout

Event Ordering Note

This method consumes events from the channel until it sees Initialized. Non-Initialized events are re-sent to the channel so they won’t be lost. This is safe because:

1. The session hasn’t taken the receiver yet (wait_initialized is called during setup)
2. The re-sent events go back to the same unbounded channel
3. The background reader task continues adding new events after our re-sent ones

Events will be received in order: [re-sent events] + [new events from reader]

pub async fn launch(&mut self, args: LaunchArguments) -> Result<()>

Launch a program for debugging

pub async fn launch_no_wait(&mut self, args: LaunchArguments) -> Result<i64>

Launch a program for debugging without waiting for response

Some debuggers (like debugpy) don’t respond to launch until after configurationDone is sent. This sends the launch request but doesn’t wait for the response.

pub async fn attach(&mut self, args: AttachArguments) -> Result<()>

Attach to a running process

pub async fn configuration_done(&mut self) -> Result<()>

Signal that configuration is done

pub async fn set_breakpoints( &mut self, source_path: &Path, breakpoints: Vec<SourceBreakpoint>, ) -> Result<Vec<Breakpoint>>

Set breakpoints for a source file

pub async fn set_function_breakpoints( &mut self, breakpoints: Vec<FunctionBreakpoint>, ) -> Result<Vec<Breakpoint>>

Set function breakpoints

pub async fn continue_execution(&mut self, thread_id: i64) -> Result<bool>

Continue execution

pub async fn next(&mut self, thread_id: i64) -> Result<()>

Step over (next)

pub async fn step_in(&mut self, thread_id: i64) -> Result<()>

Step into

pub async fn step_out(&mut self, thread_id: i64) -> Result<()>

Step out

pub async fn pause(&mut self, thread_id: i64) -> Result<()>

Pause execution

pub async fn stack_trace( &mut self, thread_id: i64, levels: i64, ) -> Result<Vec<StackFrame>>

Get stack trace

pub async fn threads(&mut self) -> Result<Vec<Thread>>

Get threads

pub async fn scopes(&mut self, frame_id: i64) -> Result<Vec<Scope>>

Get scopes for a frame

pub async fn variables( &mut self, variables_reference: i64, ) -> Result<Vec<Variable>>

Get variables

pub async fn evaluate( &mut self, expression: &str, frame_id: Option<i64>, context: &str, ) -> Result<EvaluateResponseBody>

Evaluate an expression

pub async fn disconnect(&mut self, terminate_debuggee: bool) -> Result<()>

Disconnect from the debug adapter

pub async fn terminate(&mut self) -> Result<()>

Terminate the adapter process and clean up resources

pub fn is_running(&mut self) -> bool

Check if the adapter is still running

pub async fn restart(&mut self, no_debug: bool) -> Result<()>

Restart the debug session (for adapters that support it)

Trait Implementations

impl Drop for DapClient

fn drop(&mut self)

Best-effort cleanup on drop.

Limitations

Since we can’t await in drop(), this is necessarily imperfect:

• try_send may fail if the shutdown channel is full (unlikely with capacity 1)
• task.abort() is immediate; the reader may be mid-operation
• start_kill() is non-blocking; the adapter may not exit immediately

For graceful cleanup, prefer calling terminate() before dropping. This Drop impl exists as a safety net to avoid leaking resources if terminate() wasn’t called.