Create a CDB debug session by launching a cdb.exe subprocess.

Four session types:

• live_launch: launch a new process under the debugger (target=exe path, args=launch args)

• live_attach: attach to a running process (target=PID)

• dump: load a dump file (target=dump file path)

• remote: connect to a remote debug server (target=connection string)

After creation, use the execute tool to send CDB commands.

Close a debug session, terminating the cdb.exe subprocess.

With detach=true the debugger detaches (target process keeps running). With detach=false the session is closed directly.

List all active debug sessions and their states.

Send a CDB command to the current debug session. Returns status and output.

This is the core tool for interacting with CDB. The LLM constructs valid CDB command strings; the server forwards them to cdb.exe.

Returns JSON: {"status": "completed", "output": "..."} -- command finished {"status": "pending", "output": "..."} -- command timed out but still running {"status": "error", "output": "", "error": "..."} -- error occurred

When status is "pending":

• The command is still running in CDB (not interrupted)

• Use get_output() to poll for more output

• Use interrupt() to interrupt the command

• Use wait_for_prompt() to wait for completion

Common commands:

• g : continue execution (often returns pending; use interrupt to stop)

• t / p / gu : step into / step over / step out

• bp / bc / bl : set / remove / list breakpoints

• r : display registers

• k : display call stack

• ~ : list threads

• lm : list modules

• dv : display local variables

• ?? expr : evaluate expression

• u addr : disassemble

• d addr L n : read memory

• !analyze -v : automatic crash analysis (slow; use large timeout)

Note: q/qq/qd commands are blocked (use close_session instead).

Get the output status and content of the current command.

Used to poll a command's progress after execute() returns pending. Does not send any command to CDB; only reads the existing output buffer.

Returns JSON: {"status": "pending", "output": "...", "command": "g"} -- command still running; output is what has been produced so far {"status": "idle", "output": "", "command": null} -- no command is executing

Typical usage:

1. execute("g") -> returns pending

2. get_output() -> check for new output (e.g. breakpoint hit info)

3. If output shows breakpoint reached, call interrupt() to stop

4. If still running, keep polling with get_output()

Wait for the current pending command to complete (CDB prompt to appear).

Used after execute() returns pending, to continue waiting for command completion. If no command is pending, returns idle status.

Returns JSON: {"status": "completed", "output": "..."} -- command finished {"status": "pending", "output": "..."} -- still running, timed out again {"status": "idle", "output": ""} -- no command is executing

Interrupt the running debug target (send Ctrl+Break).

Used after execute('g') returns pending, to stop the target. CDB will stop the target and display a new prompt. After interrupt, use get_output() to see the post-interrupt output.