step

Execute a single step in Go program debugging to move to the next line or instruction within a debug session.

Instructions

Step into function call

Input Schema

TableJSON Schema

Name	Required	Description	Default
`sessionId`	Yes	ID of the debug session

Implementation Reference

src/handlers/control.ts:72-80 (handler)
Executes the 'step' tool by sending a 'step' command to the Delve debugger session via sendDelveCommand and returns a confirmation message.
```
case "step": {
  await sendDelveCommand(session, "Command", { name: "step" });
  return {
    content: [{
      type: "text",
      text: "Stepped into function"
    }]
  };
}
```

src/server.ts:210-221 (schema)

Defines the input schema for the 'step' tool, which requires a sessionId parameter.

name: "step",
description: "Step into function call",
inputSchema: {
  type: "object",
  properties: {
    sessionId: {
      type: "string",
      description: "ID of the debug session"
    }
  },
  required: ["sessionId"]
}

src/server.ts:410-413 (registration)

Registers the 'step' tool (among control tools) by dispatching tool calls to the handleControlCommands function in the MCP CallToolRequestSchema handler.

// Control commands
if (["setBreakpoint", "removeBreakpoint", "continue", "next", "step", "stepout", "variables", "evaluate"].includes(name)) {
  return handleControlCommands(name, args);
}

src/server.ts:64-397 (registration)

Registers the 'step' tool in the list of available tools provided by ListToolsRequestSchema, including its schema.

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      // Debug tools
      {
        name: "debug",
        description: "Start debugging a Go package",
        inputSchema: {
          type: "object",
          properties: {
            package: {
              type: "string",
              description: "Package to debug (defaults to current directory)"
            },
            buildFlags: {
              type: "string",
              description: "Build flags to pass to the compiler"
            }
          }
        }
      },
      {
        name: "attach",
        description: "Attach to a running process",
        inputSchema: {
          type: "object",
          properties: {
            pid: {
              type: "number",
              description: "Process ID to attach to"
            }
          },
          required: ["pid"]
        }
      },
      {
        name: "exec",
        description: "Debug a precompiled binary",
        inputSchema: {
          type: "object",
          properties: {
            binary: {
              type: "string",
              description: "Path to the binary"
            },
            args: {
              type: "array",
              items: { type: "string" },
              description: "Arguments to pass to the binary"
            }
          },
          required: ["binary"]
        }
      },
      {
        name: "test",
        description: "Debug tests in a package",
        inputSchema: {
          type: "object",
          properties: {
            package: {
              type: "string",
              description: "Package to test (defaults to current directory)"
            },
            testFlags: {
              type: "array",
              items: { type: "string" },
              description: "Flags to pass to go test"
            }
          }
        }
      },
      // Control tools
      {
        name: "setBreakpoint",
        description: "Set a breakpoint in the debugged program",
        inputSchema: {
          type: "object",
          properties: {
            sessionId: {
              type: "string",
              description: "ID of the debug session"
            },
            file: {
              type: "string",
              description: "File path where to set the breakpoint"
            },
            line: {
              type: "number",
              description: "Line number for the breakpoint"
            },
            condition: {
              type: "string",
              description: "Optional condition for the breakpoint"
            }
          },
          required: ["sessionId", "file", "line"]
        }
      },
      {
        name: "removeBreakpoint",
        description: "Remove a breakpoint",
        inputSchema: {
          type: "object",
          properties: {
            sessionId: {
              type: "string",
              description: "ID of the debug session"
            },
            breakpointId: {
              type: "number",
              description: "ID of the breakpoint to remove"
            }
          },
          required: ["sessionId", "breakpointId"]
        }
      },
      {
        name: "continue",
        description: "Continue program execution",
        inputSchema: {
          type: "object",
          properties: {
            sessionId: {
              type: "string",
              description: "ID of the debug session"
            }
          },
          required: ["sessionId"]
        }
      },
      {
        name: "next",
        description: "Step over to next line",
        inputSchema: {
          type: "object",
          properties: {
            sessionId: {
              type: "string",
              description: "ID of the debug session"
            }
          },
          required: ["sessionId"]
        }
      },
      {
        name: "step",
        description: "Step into function call",
        inputSchema: {
          type: "object",
          properties: {
            sessionId: {
              type: "string",
              description: "ID of the debug session"
            }
          },
          required: ["sessionId"]
        }
      },
      {
        name: "stepout",
        description: "Step out of current function",
        inputSchema: {
          type: "object",
          properties: {
            sessionId: {
              type: "string",
              description: "ID of the debug session"
            }
          },
          required: ["sessionId"]
        }
      },
      {
        name: "variables",
        description: "List local variables in current scope",
        inputSchema: {
          type: "object",
          properties: {
            sessionId: {
              type: "string",
              description: "ID of the debug session"
            }
          },
          required: ["sessionId"]
        }
      },
      {
        name: "evaluate",
        description: "Evaluate an expression in current scope",
        inputSchema: {
          type: "object",
          properties: {
            sessionId: {
              type: "string",
              description: "ID of the debug session"
            },
            expr: {
              type: "string", 
              description: "Expression to evaluate"
            }
          },
          required: ["sessionId", "expr"]
        }
      },
      // Advanced debug tools
      {
        name: "core",
        description: "Examine a core dump",
        inputSchema: {
          type: "object",
          properties: {
            executable: {
              type: "string",
              description: "Path to the executable that produced the core dump"
            },
            corePath: {
              type: "string",
              description: "Path to the core dump file"
            }
          },
          required: ["executable", "corePath"]
        }
      },
      {
        name: "dap",
        description: "Start a DAP (Debug Adapter Protocol) server",
        inputSchema: {
          type: "object",
          properties: {
            clientAddr: {
              type: "string",
              description: "Optional address where DAP client is waiting for connection"
            }
          }
        }
      },
      {
        name: "replay",
        description: "Replay an rr trace",
        inputSchema: {
          type: "object",
          properties: {
            tracePath: {
              type: "string",
              description: "Path to the rr trace directory"
            },
            onProcess: {
              type: "number",
              description: "Optional PID to pass to rr"
            }
          },
          required: ["tracePath"]
        }
      },
      {
        name: "trace",
        description: "Trace program execution",
        inputSchema: {
          type: "object",
          properties: {
            regexp: {
              type: "string",
              description: "Regular expression to match functions to trace"
            },
            pkg: {
              type: "string",
              description: "Package to trace (defaults to .)"
            },
            ebpf: {
              type: "boolean",
              description: "Use eBPF for tracing (experimental)"
            },
            stack: {
              type: "number",
              description: "Show stack trace with given depth"
            },
            pid: {
              type: "number",
              description: "Pid to attach to"
            }
          },
          required: ["regexp"]
        }
      },
      // Configuration tools
      {
        name: "version",
        description: "Get Delve version information",
        inputSchema: {
          type: "object",
          properties: {}
        }
      },
      {
        name: "setBackend",
        description: "Set the backend for debugging",
        inputSchema: {
          type: "object",
          properties: {
            backend: {
              type: "string",
              description: "Backend to use (default, native, lldb, or rr)",
              enum: ["default", "native", "lldb", "rr"]
            }
          },
          required: ["backend"]
        }
      },
      {
        name: "configureLogging",
        description: "Configure debug logging",
        inputSchema: {
          type: "object",
          properties: {
            components: {
              type: "array",
              items: {
                type: "string",
                enum: ["debugger", "gdbwire", "lldbout", "debuglineerr", "rpc", "dap", "fncall", "minidump", "stack"]
              },
              description: "Components to enable logging for"
            },
            destination: {
              type: "string",
              description: "Log destination (file path or file descriptor)"
            }
          },
          required: ["components"]
        }
      }
    ]
  };
});

Delve MCP

step

Instructions

Input Schema

Implementation Reference

Other Tools

Latest Blog Posts

MCP directory API