diff --git a/.azure-pipelines/publish-to-maven.yml b/.azure-pipelines/publish-to-maven.yml
new file mode 100644
index 000000000..a1ef0a204
--- /dev/null
+++ b/.azure-pipelines/publish-to-maven.yml
@@ -0,0 +1,104 @@
+name: $(Date:yyyyMMdd).$(Rev:r)
+resources:
+  repositories:
+    - repository: MicroBuildTemplate
+      type: git
+      name: 1ESPipelineTemplates/MicroBuildTemplate
+      ref: refs/tags/release
+trigger: none
+extends:
+  template: azure-pipelines/1ES.Official.Publish.yml@MicroBuildTemplate
+  parameters:
+    pool:
+      os: linux
+      name: 1ES_JavaTooling_Pool
+      image: 1ES_JavaTooling_Ubuntu-2004
+    sdl:
+      sourceAnalysisPool:
+        name: 1ES_JavaTooling_Pool
+        image: 1ES_JavaTooling_Windows_2022
+        os: windows
+    stages:
+    - stage: PublishToMaven
+      jobs:
+      - job: PublishToMaven
+        displayName: Maven Release job
+        templateContext:
+          type: releaseJob
+          isProduction: true
+        steps:
+        - task: DownloadBuildArtifacts@1
+          displayName: 'Download Jar Artifacts'
+          inputs:
+            buildType: specific
+            project: 'a4d27ce2-a42d-4b71-8eef-78cee9a9728e'
+            pipeline: 16486
+            downloadType: specific
+            extractTars: false
+            itemPattern: 'm2/**'
+        - script: |
+            echo "import public key"
+            echo $GPG_PUBLIC_B64 | base64 -d | gpg --import
+
+            echo "import secret key"
+            echo $GPG_SECRET_B64 | base64 -d | gpg --batch --passphrase $GPGPASS --import
+          displayName: 'import GPG keys'
+          env:
+            GPG_PUBLIC_B64: $(GPG_PUBLIC_B64)
+            GPG_SECRET_B64: $(GPG_SECRET_B64)
+            GPGPASS: $(GPGPASS)
+        - task: NodeTool@0
+          displayName: 'Use Node 20.x'
+          inputs:
+            versionSpec: 20.x
+        - script: |
+            cd $(System.ArtifactsDirectory)/m2
+            pluginJarFile=$(basename -- java-debug-parent/*.pom)
+
+            # remove .* from end
+            noExt=${pluginJarFile%.*}
+
+            # remove *- from start
+            export releaseVersion=${noExt##*-} 
+            echo $releaseVersion
+
+            export artifactFolder=$(pwd .)
+            wget https://raw.githubusercontent.com/microsoft/java-debug/master/scripts/publishMaven.js
+
+            export GPG_TTY=$(tty)
+            node publishMaven.js -task gpg
+          displayName: 'sign artifacts'
+          env:
+            GPG_PUBLIC_B64: $(GPG_PUBLIC_B64)
+            GPG_SECRET_B64: $(GPG_SECRET_B64)
+            GPGPASS: $(GPGPASS)
+            NEXUS_OSSRHPASS: $(NEXUS_OSSRHPASS)
+            NEXUS_OSSRHUSER: $(NEXUS_OSSRHUSER)
+            NEXUS_STAGINGPROFILEID: $(NEXUS_STAGINGPROFILEID)
+        - template: MicroBuild.Publish.yml@MicroBuildTemplate
+          parameters: 
+            intent: 'PackageDistribution'
+            contentType: 'Maven'
+            contentSource: 'Folder'
+            folderLocation: '$(System.ArtifactsDirectory)/m2/java-debug-parent'
+            waitForReleaseCompletion: true
+            owners: 'jinbwan@microsoft.com'
+            approvers: 'roml@microsoft.com'
+        - template: MicroBuild.Publish.yml@MicroBuildTemplate
+          parameters: 
+            intent: 'PackageDistribution'
+            contentType: 'Maven'
+            contentSource: 'Folder'
+            folderLocation: '$(System.ArtifactsDirectory)/m2/com.microsoft.java.debug.core'
+            waitForReleaseCompletion: true
+            owners: 'jinbwan@microsoft.com'
+            approvers: 'roml@microsoft.com'
+        - template: MicroBuild.Publish.yml@MicroBuildTemplate
+          parameters: 
+            intent: 'PackageDistribution'
+            contentType: 'Maven'
+            contentSource: 'Folder'
+            folderLocation: '$(System.ArtifactsDirectory)/m2/com.microsoft.java.debug.plugin'
+            waitForReleaseCompletion: true
+            owners: 'jinbwan@microsoft.com'
+            approvers: 'roml@microsoft.com'
\ No newline at end of file
diff --git a/.azure-pipelines/signjars-nightly.yml b/.azure-pipelines/signjars-nightly.yml
new file mode 100644
index 000000000..8b1e8d12a
--- /dev/null
+++ b/.azure-pipelines/signjars-nightly.yml
@@ -0,0 +1,138 @@
+name: $(Date:yyyyMMdd).$(Rev:r)
+variables:
+  - name: Codeql.Enabled
+    value: true
+schedules:
+  - cron: 0 5 * * 1,2,3,4,5
+    branches:
+      include:
+        - refs/heads/main
+resources:
+  repositories:
+    - repository: self
+      type: git
+      ref: refs/heads/main
+    - repository: 1esPipelines
+      type: git
+      name: 1ESPipelineTemplates/1ESPipelineTemplates
+      ref: refs/tags/release
+trigger: none
+extends:
+  template: v1/1ES.Official.PipelineTemplate.yml@1esPipelines
+  parameters:
+    pool:
+      os: linux
+      name: 1ES_JavaTooling_Pool
+      image: 1ES_JavaTooling_Ubuntu-2004
+    sdl:
+      sourceAnalysisPool:
+        name: 1ES_JavaTooling_Pool
+        image: 1ES_JavaTooling_Windows_2022
+        os: windows
+    customBuildTags:
+      - MigrationTooling-mseng-VSJava-13474-Tool
+    stages:
+      - stage: Build
+        jobs:
+          - job: Job_1
+            displayName: Sign-Jars-Nightly
+            templateContext:
+              outputs:
+                - output: pipelineArtifact
+                  artifactName: plugin
+                  targetPath: $(Build.ArtifactStagingDirectory)
+                  displayName: "Publish Artifact: plugin"
+            steps:
+              - checkout: self
+                fetchTags: true
+              - task: UseDotNet@2
+                displayName: 'Use .NET Core 3.1.x'
+                inputs:
+                  packageType: 'sdk'
+                  version: '3.1.x'
+              - task: UseDotNet@2
+                displayName: 'Use .NET Core 8.0.x'
+                inputs:
+                  packageType: 'sdk'
+                  version: '8.0.x'
+              - task: MicroBuildSigningPlugin@4
+                displayName: 'Install Signing Plugin'
+                inputs:
+                  signType: real
+                  azureSubscription: 'MicroBuild Signing Task (MSEng)'
+                  useEsrpCli: true
+                  ConnectedPMEServiceName: 0e38ce24-f885-4c86-b997-5887b97a1899
+                  feedSource: 'https://mseng.pkgs.visualstudio.com/DefaultCollection/_packaging/MicroBuildToolset/nuget/v3/index.json'
+                env:
+                  SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+                  MicroBuildOutputFolderOverride: '$(Agent.TempDirectory)'
+              - task: JavaToolInstaller@0
+                displayName: Use Java 21
+                inputs:
+                  versionSpec: "21"
+                  jdkArchitectureOption: x64
+                  jdkSourceOption: PreInstalled
+              - task: CmdLine@2
+                displayName: Parse the release version from pom.xml
+                inputs:
+                  script: |-
+                    #!/bin/bash
+
+                    sudo apt-get install xmlstarlet
+                    xmlstarlet --version
+                    RELEASE_VERSION=$(xmlstarlet sel -t -v "/_:project/_:version" pom.xml)
+                    echo $RELEASE_VERSION
+                    echo "##vso[task.setvariable variable=RELEASE_VERSION]$RELEASE_VERSION"
+              - task: CmdLine@2
+                displayName: Build core.jar
+                inputs:
+                  script: |
+                    ./mvnw clean install -f com.microsoft.java.debug.core/pom.xml -Dmaven.repo.local=./.repository
+
+                    mkdir -p jars
+                    mv .repository/com/microsoft/java/com.microsoft.java.debug.core/$RELEASE_VERSION/com.microsoft.java.debug.core*.jar jars/
+              - task: CmdLine@2
+                displayName: Sign core jars
+                inputs:
+                  script: |
+                    files=$(find . -type f -name "com.microsoft.java.debug.core*.jar")
+                    for file in $files; do
+                        fileName=$(basename "$file")
+                        dotnet "$MBSIGN_APPFOLDER/DDSignFiles.dll" -- /file:"$fileName" /certs:100010171
+                    done
+                  workingDirectory: 'jars'
+                env:
+                  SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+              - task: CmdLine@2
+                displayName: install signed core.jar
+                inputs:
+                  script: cp jars/com.microsoft.java.debug.core*.jar .repository/com/microsoft/java/com.microsoft.java.debug.core/$RELEASE_VERSION/
+              - task: CmdLine@2
+                displayName: Build plugin.jar
+                inputs:
+                  script: |-
+                    ./mvnw clean install -N -f pom.xml -Dmaven.repo.local=./.repository
+                    ./mvnw clean install -f com.microsoft.java.debug.target/pom.xml -Dmaven.repo.local=./.repository
+                    ./mvnw clean install -f com.microsoft.java.debug.plugin/pom.xml -Dmaven.repo.local=./.repository
+
+                    mkdir -p jars
+                    mv .repository/com/microsoft/java/com.microsoft.java.debug.plugin/$RELEASE_VERSION/com.microsoft.java.debug.plugin*.jar jars/
+              - task: CmdLine@2
+                displayName: Sign plugin jars
+                inputs:
+                  script: |
+                    files=$(find . -type f -name "com.microsoft.java.debug.plugin*.jar")
+                    for file in $files; do
+                        fileName=$(basename "$file")
+                        dotnet "$MBSIGN_APPFOLDER/DDSignFiles.dll" -- /file:"$fileName" /certs:100010171
+                    done
+                  workingDirectory: 'jars'
+                env:
+                  SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+              - task: CopyFiles@2
+                displayName: "Copy plugin.jar to: $(Build.ArtifactStagingDirectory)"
+                inputs:
+                  Contents: |+
+                    jars/com.microsoft.java.debug.plugin*.jar
+
+                  TargetFolder: $(Build.ArtifactStagingDirectory)
diff --git a/.azure-pipelines/signjars-rc.yml b/.azure-pipelines/signjars-rc.yml
new file mode 100644
index 000000000..e87444603
--- /dev/null
+++ b/.azure-pipelines/signjars-rc.yml
@@ -0,0 +1,169 @@
+name: $(Date:yyyyMMdd).$(Rev:r)
+variables:
+  - name: Codeql.Enabled
+    value: true
+resources:
+  repositories:
+    - repository: self
+      type: git
+      ref: refs/heads/main
+    - repository: 1esPipelines
+      type: git
+      name: 1ESPipelineTemplates/1ESPipelineTemplates
+      ref: refs/tags/release
+trigger: none
+extends:
+  template: v1/1ES.Official.PipelineTemplate.yml@1esPipelines
+  parameters:
+    pool:
+      os: linux
+      name: 1ES_JavaTooling_Pool
+      image: 1ES_JavaTooling_Ubuntu-2004
+    sdl:
+      sourceAnalysisPool:
+        name: 1ES_JavaTooling_Pool
+        image: 1ES_JavaTooling_Windows_2022
+        os: windows
+    customBuildTags:
+      - MigrationTooling-mseng-VSJava-9151-Tool
+    stages:
+      - stage: Build
+        jobs:
+          - job: Job_1
+            displayName: Sign-Jars-RC
+            templateContext:
+              outputs:
+                - output: pipelineArtifact
+                  artifactName: m2
+                  targetPath: $(Build.ArtifactStagingDirectory)/m2
+                  displayName: "Publish Artifact: m2"
+            steps:
+              - checkout: self
+                fetchTags: true
+              - task: UseDotNet@2
+                displayName: 'Use .NET Core 3.1.x'
+                inputs:
+                  packageType: 'sdk'
+                  version: '3.1.x'
+              - task: UseDotNet@2
+                displayName: 'Use .NET Core 8.0.x'
+                inputs:
+                  packageType: 'sdk'
+                  version: '8.0.x'
+              - task: MicroBuildSigningPlugin@4
+                displayName: 'Install Signing Plugin'
+                inputs:
+                  signType: real
+                  azureSubscription: 'MicroBuild Signing Task (MSEng)'
+                  useEsrpCli: true
+                  ConnectedPMEServiceName: 0e38ce24-f885-4c86-b997-5887b97a1899
+                  feedSource: 'https://mseng.pkgs.visualstudio.com/DefaultCollection/_packaging/MicroBuildToolset/nuget/v3/index.json'
+                env:
+                  SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+                  MicroBuildOutputFolderOverride: '$(Agent.TempDirectory)'
+              - task: JavaToolInstaller@0
+                displayName: Use Java 21
+                inputs:
+                  versionSpec: "21"
+                  jdkArchitectureOption: x64
+                  jdkSourceOption: PreInstalled
+              - task: CmdLine@2
+                displayName: Parse the release version from pom.xml
+                inputs:
+                  script: |-
+                    #!/bin/bash
+
+                    sudo apt-get install xmlstarlet
+                    xmlstarlet --version
+                    RELEASE_VERSION=$(xmlstarlet sel -t -v "/_:project/_:version" pom.xml)
+                    echo $RELEASE_VERSION
+                    echo "##vso[task.setvariable variable=RELEASE_VERSION]$RELEASE_VERSION"
+              - task: CmdLine@2
+                displayName: Build core.jar
+                inputs:
+                  script: |
+                    ./mvnw -N clean install -Dmaven.repo.local=./.repository
+
+                    ./mvnw clean install -f com.microsoft.java.debug.core/pom.xml -Dmaven.repo.local=./.repository
+
+                    mkdir -p jars
+                    mv .repository/com/microsoft/java/com.microsoft.java.debug.core/$RELEASE_VERSION/com.microsoft.java.debug.core*.jar jars/
+              - task: CmdLine@2
+                displayName: Sign core jars
+                inputs:
+                  script: |
+                    files=$(find . -type f -name "com.microsoft.java.debug.core*.jar")
+                    for file in $files; do
+                        fileName=$(basename "$file")
+                        dotnet "$MBSIGN_APPFOLDER/DDSignFiles.dll" -- /file:"$fileName" /certs:100010171
+                    done
+                  workingDirectory: 'jars'
+                env:
+                  SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+              - task: CmdLine@2
+                displayName: install signed core.jar
+                inputs:
+                  script: cp jars/com.microsoft.java.debug.core*.jar .repository/com/microsoft/java/com.microsoft.java.debug.core/$RELEASE_VERSION/
+              - task: CmdLine@2
+                displayName: Build plugin.jar
+                inputs:
+                  script: |-
+                    ./mvnw clean install -f com.microsoft.java.debug.target/pom.xml -Dmaven.repo.local=./.repository
+                    ./mvnw clean install -f com.microsoft.java.debug.plugin/pom.xml -Dmaven.repo.local=./.repository
+
+                    mkdir -p jars
+                    mv .repository/com/microsoft/java/com.microsoft.java.debug.plugin/$RELEASE_VERSION/com.microsoft.java.debug.plugin*.jar jars/
+              - task: CmdLine@2
+                displayName: Sign plugin jars
+                inputs:
+                  script: |
+                    files=$(find . -type f -name "com.microsoft.java.debug.plugin*.jar")
+                    for file in $files; do
+                        fileName=$(basename "$file")
+                        dotnet "$MBSIGN_APPFOLDER/DDSignFiles.dll" -- /file:"$fileName" /certs:100010171
+                    done
+                  workingDirectory: 'jars'
+                env:
+                  SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+              - task: CmdLine@2
+                displayName: install signed plugin.jar
+                inputs:
+                  script: cp jars/com.microsoft.java.debug.plugin*.jar .repository/com/microsoft/java/com.microsoft.java.debug.plugin/$RELEASE_VERSION/
+              - task: CmdLine@2
+                displayName: build m2 artifacts
+                inputs:
+                  script: |
+                    ./mvnw source:jar -f com.microsoft.java.debug.core/pom.xml -Dmaven.repo.local=./.repository
+                    ./mvnw javadoc:jar -f com.microsoft.java.debug.core/pom.xml -Ddoclint=none -Dmaven.repo.local=./.repository
+
+                    ./mvnw source:jar -f com.microsoft.java.debug.plugin/pom.xml -Dmaven.repo.local=./.repository
+                    ./mvnw javadoc:jar -f com.microsoft.java.debug.plugin/pom.xml -Ddoclint=none -Dmaven.repo.local=./.repository
+
+                    mkdir -p m2/java-debug-parent
+                    cp pom.xml m2/java-debug-parent/java-debug-parent-$RELEASE_VERSION.pom
+
+                    mkdir -p m2/com.microsoft.java.debug.core
+                    cp com.microsoft.java.debug.core/target/com.microsoft.java.debug.core*.jar m2/com.microsoft.java.debug.core
+                    cp com.microsoft.java.debug.core/pom.xml m2/com.microsoft.java.debug.core/com.microsoft.java.debug.core-$RELEASE_VERSION.pom
+
+                    mkdir -p m2/com.microsoft.java.debug.plugin
+                    cp com.microsoft.java.debug.plugin/target/com.microsoft.java.debug.plugin*.jar m2/com.microsoft.java.debug.plugin
+                    cp com.microsoft.java.debug.plugin/pom.xml m2/com.microsoft.java.debug.plugin/com.microsoft.java.debug.plugin-$RELEASE_VERSION.pom
+              - task: CmdLine@2
+                displayName: Sign m2 jars
+                inputs:
+                  script: |
+                    files=$(find . -type f -name "*.jar")
+                    for file in $files; do
+                        # fileName=$(basename "$file")
+                        dotnet "$MBSIGN_APPFOLDER/DDSignFiles.dll" -- /file:"$file" /certs:100010171
+                    done
+                  workingDirectory: 'm2'
+                env:
+                  SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+              - task: CopyFiles@2
+                displayName: "Copy m2 to: $(Build.ArtifactStagingDirectory)"
+                inputs:
+                  Contents: |+
+                    m2/**
+                  TargetFolder: $(Build.ArtifactStagingDirectory)
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 000000000..9d7579633
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1 @@
+* @testforstephen @jdneo @chagong @wenytang-ms
diff --git a/.github/llms.md b/.github/llms.md
new file mode 100644
index 000000000..55d69b238
--- /dev/null
+++ b/.github/llms.md
@@ -0,0 +1,38 @@
+# Extension Pack for Java
+Extension Pack for Java is a collection of popular extensions that can help write, test and debug Java applications in Visual Studio Code. By installing Extension Pack for Java, the following extensions are installed:
+
+- [📦 Language Support for Java™ by Red Hat ](https://marketplace.visualstudio.com/items?itemName=redhat.java)
+    - Code Navigation
+    - Auto Completion
+    - Refactoring
+    - Code Snippets
+- [📦 Debugger for Java](https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-java-debug)
+    - Debugging
+- [📦 Test Runner for Java](https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-java-test)
+    - Run & Debug JUnit/TestNG Test Cases
+- [📦 Maven for Java](https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-maven)
+    - Project Scaffolding
+    - Custom Goals
+- [📦 Gradle for Java](https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-gradle)
+    - View Gradle tasks and project dependencies
+    - Gradle file authoring
+    - Import Gradle projects via [Gradle Build Server](https://github.com/microsoft/build-server-for-gradle)
+- [📦 Project Manager for Java](https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-java-dependency)
+    - Manage Java projects, referenced libraries, resource files, packages, classes, and class members
+- [📦 Visual Studio IntelliCode](https://marketplace.visualstudio.com/items?itemName=VisualStudioExptTeam.vscodeintellicode)
+    - AI-assisted development
+    - Completion list ranked by AI
+
+## Label
+When labeling an issue, follow the rules below per label category:
+### General Rules
+- Analyze if the issue is related with the scope of using extensions for Java development. If not, STOP labelling IMMEDIATELY.
+- Assign label per category.
+- If a category is not applicable or you're unsure, you may skip it.
+- Do not assign multiple labels within the same category, unless explicitly allowed as an exception.
+
+### Issue Type Labels 
+- [bug]: Primary label for real bug issues 
+- [enhancement]: Primary label for enhancement issues 
+- [documentation]: Primary label for documentation issues 
+- [question]: Primary label for question issues 
\ No newline at end of file
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 000000000..553d95a9a
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,94 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  linux:
+    name: Linux
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Cache local Maven repository
+        uses: actions/cache@v4
+        with:
+          path: ~/.m2/repository
+          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+          restore-keys: |
+            ${{ runner.os }}-maven-
+
+      - name: Verify
+        run: ./mvnw clean verify -U
+
+      - name: Checkstyle
+        run: ./mvnw checkstyle:check
+
+  windows:
+    name: Windows
+    runs-on: windows-latest
+    timeout-minutes: 30
+    steps:
+      - name: Set git to use LF
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.eol lf
+
+      - uses: actions/checkout@v5
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Cache local Maven repository
+        uses: actions/cache@v4
+        with:
+          path: $HOME/.m2/repository
+          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+          restore-keys: |
+            ${{ runner.os }}-maven-
+
+      - name: Verify
+        run: ./mvnw.cmd clean verify
+
+      - name: Checkstyle
+        run: ./mvnw.cmd checkstyle:check
+
+  darwin:
+    name: macOS
+    runs-on: macos-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Cache local Maven repository
+        uses: actions/cache@v4
+        with:
+          path: ~/.m2/repository
+          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+          restore-keys: |
+            ${{ runner.os }}-maven-
+
+      - name: Verify
+        run: ./mvnw clean verify -U
+
+      - name: Checkstyle
+        run: ./mvnw checkstyle:check
diff --git a/.github/workflows/triage-agent.yml b/.github/workflows/triage-agent.yml
new file mode 100644
index 000000000..f1df6e117
--- /dev/null
+++ b/.github/workflows/triage-agent.yml
@@ -0,0 +1,125 @@
+name: AI Triage
+on:
+  issues:
+    types: [opened]
+  workflow_dispatch:
+    inputs:
+      issue_number:
+        description: 'Issue number to triage (manual run). e.g. 123'
+        required: true
+
+run-name: >-
+  AI Triage for Issue #${{ github.event.issue.number || github.event.inputs.issue_number }}
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  label_and_comment:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Get issue data
+        id: get_issue
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const eventName = context.eventName;
+            let issue;
+            if (eventName === 'workflow_dispatch') {
+              const inputs = context.payload.inputs || {};
+              const issueNumber = inputs.issue_number || inputs.issueNumber;
+              if (!issueNumber) core.setFailed('Input issue_number is required for manual run.');
+              const { data } = await github.rest.issues.get({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: parseInt(issueNumber, 10),
+              });
+              issue = data;
+            } else if (context.payload.issue) {
+              issue = context.payload.issue;
+            } else {
+              core.setFailed('No issue information found in the event payload.');
+            }
+            core.setOutput('id', String(issue.number));
+            core.setOutput('user', String((issue.user && issue.user.login) || ''));
+            core.setOutput('title', String(issue.title || ''));
+            core.setOutput('body', String(issue.body || ''));
+            const labelNames = (issue.labels || []).map(label => label.name);
+            core.setOutput('labels', JSON.stringify(labelNames));
+
+      - name: Call Azure Function
+        id: call_azure_function
+        env:
+          PAYLOAD: >-
+            {
+              "authToken": "${{ secrets.GITHUB_TOKEN }}",
+              "repoId": "microsoft/java-debug",
+              "issueData": {
+                "id": ${{ steps.get_issue.outputs.id }},
+                "user": ${{ toJson(steps.get_issue.outputs.user) }},
+                "title": ${{ toJson(steps.get_issue.outputs.title) }},
+                "body":  ${{ toJson(steps.get_issue.outputs.body)  }},
+                "labels": ${{ steps.get_issue.outputs.labels }}
+              },
+              "mode": "DirectUpdate"
+            }
+
+        run: |
+          # Make the HTTP request with improved error handling and timeouts
+          echo "Making request to triage agent..."
+
+          # Add timeout handling and better error detection
+          set +e  # Don't exit on curl failure
+          response=$(timeout ${{ vars.TRIAGE_AGENT_TIMEOUT }} curl \
+              --max-time 0 \
+              --connect-timeout 30 \
+              --fail-with-body \
+              --silent \
+              --show-error \
+              --write-out "HTTPSTATUS:%{http_code}" \
+              --header "Content-Type: application/json" \
+              --request POST \
+              --data "$PAYLOAD" \
+              ${{ secrets.TRIAGE_FUNCTION_LINK }} 2>&1)
+
+          curl_exit_code=$?
+          set -e  # Re-enable exit on error
+
+          echo "Curl exit code: $curl_exit_code"
+
+          # Check if curl command timed out or failed
+          if [ $curl_exit_code -eq 124 ]; then
+            echo "❌ Request timed out after 650 seconds"
+            exit 1
+          elif [ $curl_exit_code -ne 0 ]; then
+            echo "❌ Curl command failed with exit code: $curl_exit_code"
+            echo "Response: $response"
+            exit 1
+          fi
+
+          # Extract HTTP status code and response body
+          http_code=$(echo "$response" | grep -o "HTTPSTATUS:[0-9]*" | cut -d: -f2)
+          response_body=$(echo "$response" | sed 's/HTTPSTATUS:[0-9]*$//')
+
+          echo "HTTP Status Code: $http_code"
+
+          # Validate HTTP status code
+          if [ -z "$http_code" ]; then
+            echo "❌ Failed to extract HTTP status code from response"
+            echo "Raw response: $response"
+            exit 1
+          fi
+
+          # Check if the request was successful
+          if [ "$http_code" -ge 200 ] && [ "$http_code" -lt 300 ]; then
+            echo "✅ Azure Function call succeeded"
+          else
+            echo "❌ Azure Function call failed with status code: $http_code"
+            echo "Response: $response_body"
+            exit 1
+          fi
\ No newline at end of file
diff --git a/.github/workflows/triage-all-open-issues.yml b/.github/workflows/triage-all-open-issues.yml
new file mode 100644
index 000000000..092f4ef70
--- /dev/null
+++ b/.github/workflows/triage-all-open-issues.yml
@@ -0,0 +1,145 @@
+name: AI Triage - Process All Open Issues
+on:
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: 'Dry run mode - only list issues without processing'
+        required: false
+        default: false
+        type: boolean
+      max_issues:
+        description: 'Maximum number of issues to process (0 = all)'
+        required: false
+        default: '0'
+        type: string
+
+permissions:
+  issues: write
+  contents: read
+  actions: write
+
+jobs:
+  get_open_issues:
+    runs-on: ubuntu-latest
+    outputs:
+      issue_numbers: ${{ steps.get_issues.outputs.issue_numbers }}
+      total_count: ${{ steps.get_issues.outputs.total_count }}
+    
+    steps:
+      - name: Get all open issues
+        id: get_issues
+        uses: actions/github-script@v6
+        with:
+          script: |
+            // Use Search API to filter issues at API level
+            const { data } = await github.rest.search.issuesAndPullRequests({
+              q: `repo:${context.repo.owner}/${context.repo.repo} is:issue is:open -label:ai-triaged -label:invalid`,
+              sort: 'created',
+              order: 'asc',
+              per_page: 100
+            });
+            
+            const actualIssues = data.items;
+            
+            let issuesToProcess = actualIssues;
+            const maxIssues = parseInt('${{ inputs.max_issues }}' || '0');
+            
+            if (maxIssues > 0 && actualIssues.length > maxIssues) {
+              issuesToProcess = actualIssues.slice(0, maxIssues);
+              console.log(`Limiting to first ${maxIssues} issues out of ${actualIssues.length} total`);
+            }
+            
+            const issueNumbers = issuesToProcess.map(issue => issue.number);
+            const totalCount = issuesToProcess.length;
+            
+            console.log(`Found ${actualIssues.length} open issues, processing ${totalCount}:`);
+            issuesToProcess.forEach(issue => {
+              console.log(`  #${issue.number}: ${issue.title}`);
+            });
+            
+            core.setOutput('issue_numbers', JSON.stringify(issueNumbers));
+            core.setOutput('total_count', totalCount);
+
+  process_issues:
+    runs-on: ubuntu-latest
+    needs: get_open_issues
+    if: needs.get_open_issues.outputs.total_count > 0
+    
+    strategy:
+      # Process issues one by one (max-parallel: 1)
+      max-parallel: 1
+      matrix:
+        issue_number: ${{ fromJSON(needs.get_open_issues.outputs.issue_numbers) }}
+    
+    steps:
+      - name: Log current issue being processed
+        run: |
+          echo "🔄 Processing issue #${{ matrix.issue_number }}"
+          echo "Total issues to process: ${{ needs.get_open_issues.outputs.total_count }}"
+      
+      - name: Check if dry run mode
+        if: inputs.dry_run == true
+        run: |
+          echo "🔍 DRY RUN MODE: Would process issue #${{ matrix.issue_number }}"
+          echo "Skipping actual triage processing"
+      
+      - name: Trigger triage workflow for issue
+        if: inputs.dry_run != true
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const issueNumber = '${{ matrix.issue_number }}';
+            
+            try {
+              console.log(`Triggering triage workflow for issue #${issueNumber}`);
+              
+              const response = await github.rest.actions.createWorkflowDispatch({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                workflow_id: 'triage-agent.yml',
+                ref: 'main',
+                inputs: {
+                  issue_number: issueNumber
+                }
+              });
+              
+              console.log(`✅ Successfully triggered triage workflow for issue #${issueNumber}`);
+              
+            } catch (error) {
+              console.error(`❌ Failed to trigger triage workflow for issue #${issueNumber}:`, error);
+              core.setFailed(`Failed to process issue #${issueNumber}: ${error.message}`);
+            }
+      
+      - name: Wait for workflow completion
+        if: inputs.dry_run != true
+        run: |
+          echo "⏳ Waiting for triage workflow to complete for issue #${{ matrix.issue_number }}..."
+          echo "Timeout: ${{ vars.TRIAGE_AGENT_TIMEOUT }} seconds"
+          sleep ${{ vars.TRIAGE_AGENT_TIMEOUT }}  # Wait for triage workflow completion
+
+  summary:
+    runs-on: ubuntu-latest
+    needs: [get_open_issues, process_issues]
+    if: always()
+    
+    steps:
+      - name: Print summary
+        run: |
+          echo "## Triage Processing Summary"
+          echo "Total open issues found: ${{ needs.get_open_issues.outputs.total_count }}"
+          
+          if [ "${{ inputs.dry_run }}" == "true" ]; then
+            echo "Mode: DRY RUN (no actual processing performed)"
+          else
+            echo "Mode: FULL PROCESSING"
+          fi
+          
+          if [ "${{ needs.process_issues.result }}" == "success" ]; then
+            echo "✅ All issues processed successfully"
+          elif [ "${{ needs.process_issues.result }}" == "failure" ]; then
+            echo "❌ Some issues failed to process"
+          elif [ "${{ needs.process_issues.result }}" == "skipped" ]; then
+            echo "⏭️ Processing was skipped (no open issues found)"
+          else
+            echo "⚠️ Processing completed with status: ${{ needs.process_issues.result }}"
+          fi
diff --git a/.gitignore b/.gitignore
index 82b11c483..993fb23a4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,10 +28,7 @@ hs_err_pid*
 .DS_Store
 .idea
 target/
-.classpath
-.project
 .settings
-javaConfig.json
 **/.checkstyle
 target/
 bin/
diff --git a/.mvn/wrapper/maven-wrapper.jar b/.mvn/wrapper/maven-wrapper.jar
deleted file mode 100644
index 41c70a7e0..000000000
Binary files a/.mvn/wrapper/maven-wrapper.jar and /dev/null differ
diff --git a/.mvn/wrapper/maven-wrapper.properties b/.mvn/wrapper/maven-wrapper.properties
index 56bb0164e..44f3cf2c1 100644
--- a/.mvn/wrapper/maven-wrapper.properties
+++ b/.mvn/wrapper/maven-wrapper.properties
@@ -1 +1,2 @@
-distributionUrl=https://repo1.maven.org/maven2/org/apache/maven/apache-maven/3.5.0/apache-maven-3.5.0-bin.zip
\ No newline at end of file
+distributionType=only-script
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.11/apache-maven-3.9.11-bin.zip
diff --git a/.project b/.project
new file mode 100644
index 000000000..f00ccfc41
--- /dev/null
+++ b/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>java-debug-parent</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1665543654766</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 2c448eebf..000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-language: java
-
-os:
-  - linux
-  - osx
-
-script: 
-  - ./mvnw clean verify
-
-cache:
-  directories:
-  - $HOME/.m2
diff --git a/.vscode/launch.json b/.vscode/launch.json
index c8c1f83c8..6de8b630d 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -14,7 +14,8 @@
       "sourcePaths": [
         "${workspaceRoot}/com.microsoft.java.debug.core/main/java",
         "${workspaceRoot}/com.microsoft.java.debug.plugin/src/main/java"
-      ]
+      ],
+      "projectName": "com.microsoft.java.debug.plugin"
     }
   ]
 }
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
index fbaf055a0..2c67a2d4b 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,5 +1,4 @@
 {
-  "java.configuration.updateBuildConfiguration": "automatic",
   "files.exclude": {
     "**/.git": true,
     "**/*.class": true,
diff --git a/LICENSE.txt b/LICENSE.txt
index 0a5bf4ce2..252834722 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,109 +1,109 @@
-------------------------------------------- START OF LICENSE ---------------------------------------- 
-
-Java Debug Server for Visual Studio Code
-
-Copyright (c) Microsoft Corporation 
-
-All rights reserved.  
-
-
-Eclipse Public License - v 1.0
-
-
-THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
-
-
-1. DEFINITIONS
-
-"Contribution" means:
-
-a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
-
-b) in the case of each subsequent Contributor:
-
-i) changes to the Program, and
-
-ii) additions to the Program;
-
-where such changes and/or additions to the Program originate from and are distributed by that particular Contributor. A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not derivative works of the Program.
-
-"Contributor" means any person or entity that distributes the Program.
-
-"Licensed Patents" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.
-
-"Program" means the Contributions distributed in accordance with this Agreement.
-
-"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
-
-
-2. GRANT OF RIGHTS
-
-a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form.
-
-b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
-
-c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program.
-
-d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement.
-
-
-3. REQUIREMENTS
-
-A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
-
-a) it complies with the terms and conditions of this Agreement; and
-
-b) its license agreement:
-
-i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;
-
-ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits;
-
-iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party; and
-
-iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it in a reasonable manner on or through a medium customarily used for software exchange.
-
-When the Program is made available in source code form:
-
-a) it must be made available under this Agreement; and
-
-b) a copy of this Agreement must be included with each copy of the Program.
-
-Contributors may not remove or alter any copyright notices contained within the Program.
-
-Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution.
-
-
-4. COMMERCIAL DISTRIBUTION
-
-Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor ("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor") against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.
-
-For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages.
-
-
-5. NO WARRANTY
-
-
-EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
-
-
-6. DISCLAIMER OF LIABILITY
-
-EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-7. GENERAL
-
-If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
-
-If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.
-
-
-All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.
-
-
-Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
-
-This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation.
-
-
+------------------------------------------- START OF LICENSE ---------------------------------------- 
+
+Java Debug Server for Visual Studio Code
+
+Copyright (c) Microsoft Corporation 
+
+All rights reserved.  
+
+
+Eclipse Public License - v 1.0
+
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor. A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement.
+
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution.
+
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor ("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor") against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages.
+
+
+5. NO WARRANTY
+
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.
+
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.
+
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation.
+
+
 ----------------------------------------------- END OF LICENSE --------------------------------------
\ No newline at end of file
diff --git a/README.md b/README.md
index eb97a9bed..4bf15f675 100644
--- a/README.md
+++ b/README.md
@@ -24,6 +24,47 @@ The Java Debug Server is the bridge between VSCode and JVM. The implementation i
 - com.microsoft.java.debug.core - the core logic of the debug server
 - com.microsoft.java.debug.plugin - wraps the debug server into an Eclipse plugin to work with Eclipse JDT Language Server
 
+## Installation
+
+### Windows:
+```
+mvnw.cmd clean install
+```
+### Linux and macOS:
+```
+./mvnw clean install
+```
+
+
+## Usage with eclipse.jdt.ls
+
+To use `java-debug` as a [jdt.ls](https://github.com/eclipse/eclipse.jdt.ls) plugin, an [LSP client](https://langserver.org/) has to launch [jdt.ls](https://github.com/eclipse/eclipse.jdt.ls) with `initializationOptions` that contain the path to the built `java-debug` jar within a `bundles` array:
+
+
+```
+{
+    "initializationOptions": {
+        "bundles": [
+            "path/to/microsoft/java-debug/com.microsoft.java.debug.plugin/target/com.microsoft.java.debug.plugin-<version>.jar"
+        ]
+    }
+}
+```
+
+Editor extensions like [vscode-java](https://github.com/redhat-developer/vscode-java) take care of this.
+
+
+Once `eclipse.jdt.ls` launched, the client can send a [Command](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#command) to the server to start a debug session:
+
+```
+{
+  "command": "vscode.java.startDebugSession"
+}
+```
+
+The response to this request will contain a port number on which the debug adapter is listening, and to which a client implementing the debug-adapter protocol can connect to.
+
+
 License
 -------
-EPL 1.0, See [LICENSE](LICENSE.txt) file.
\ No newline at end of file
+EPL 1.0, See [LICENSE](LICENSE.txt) file.
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 000000000..e138ec5d6
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,41 @@
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.8 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc). 
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->
diff --git a/ThirdPartyNotices.txt b/ThirdPartyNotices.txt
new file mode 100644
index 000000000..b9fc26420
--- /dev/null
+++ b/ThirdPartyNotices.txt
@@ -0,0 +1,437 @@
+java-debug
+
+THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
+Do Not Translate or Localize
+
+This project incorporates components from the projects listed below. The original copyright notices and the licenses under which Microsoft received such components are set forth below. Microsoft reserves all rights not expressly granted herein, whether by implication, estoppel or otherwise.
+
+1. ReactiveX/RxJava (https://github.com/ReactiveX/RxJava)
+2. reactive-streams/reactive-streams-jvm (https://github.com/reactive-streams/reactive-streams-jvm)
+3. apache/commons-io (https://github.com/apache/commons-io)
+
+
+%% ReactiveX/RxJava NOTICES AND INFORMATION BEGIN HERE
+=========================================
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+=========================================
+END OF ReactiveX/RxJava NOTICES AND INFORMATION
+
+%% reactive-streams/reactive-streams-jvm NOTICES AND INFORMATION BEGIN HERE
+=========================================
+MIT No Attribution
+
+Copyright 2014 Reactive Streams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=========================================
+END OF reactive-streams/reactive-streams-jvm NOTICES AND INFORMATION
+
+%% apache/commons-io NOTICES AND INFORMATION BEGIN HERE
+=========================================
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+=========================================
+END OF apache/commons-io NOTICES AND INFORMATION
\ No newline at end of file
diff --git a/check_style.xml b/check_style.xml
index e875c5296..3f19228a5 100644
--- a/check_style.xml
+++ b/check_style.xml
@@ -20,7 +20,7 @@
 
     <property name="fileExtensions" value="java, properties, xml"/>
     <module name="RegexpHeader">
-        <property name="headerFile" value="${basedir}/microsoft.header"/>
+        <property name="headerFile" value="microsoft.header"/>
     </module>
     <!-- Checks for whitespace                              
      See http://checkstyle.sf.net/config_whitespace.html -->
@@ -40,6 +40,23 @@
         <property name="message" value="CRLF and CR line endings are prohibited, but this file uses them."/>
     </module>
 
+    <module name="LineLengthCheck">
+        <property name="fileExtensions" value="java" />
+        <!-- Checks if a line is too long. -->
+        <property name="max" value="${com.puppycrawl.tools.checkstyle.checks.sizes.LineLength.max}" default="160"/>
+        <property name="severity" value="error"/>
+
+        <!--
+          The default ignore pattern exempts the following elements:
+            - import statements
+            - long URLs inside comments
+        -->
+
+        <property name="ignorePattern"
+                  value="${com.puppycrawl.tools.checkstyle.checks.sizes.LineLength.ignorePattern}"
+                  default="^(package .*;\s*)|(import .*;\s*)|( *\* *https?://.*)$"/>
+    </module>
+
     <module name="TreeWalker">
         <!-- Default CheckStyle Whitespace rules seem reasonable to use. -->
         <module name="EmptyForIteratorPad"/>
@@ -92,10 +109,6 @@
             <property name="allowByTailComment" value="true"/>
             <property name="allowNonPrintableEscapes" value="true"/>
         </module>
-        <module name="LineLength">
-            <property name="max" value="160"/>
-            <property name="ignorePattern" value="^package.*|^import.*|a href|href|http://|https://|ftp://"/>
-        </module>
         <module name="AvoidStarImport"/>
         <module name="OneTopLevelClass"/>
         <module name="NoLineWrap"/>
@@ -104,9 +117,6 @@
             <property name="tokens" value="LITERAL_TRY, LITERAL_FINALLY, LITERAL_IF, LITERAL_ELSE, LITERAL_SWITCH"/>
         </module>
         <module name="NeedBraces"/>
-        <module name="LeftCurly">
-            <property name="maxLineLength" value="120"/>
-        </module>
         <module name="RightCurly">
             <property name="id" value="RightCurlySame"/>
             <property name="tokens"
@@ -137,6 +147,9 @@
         <module name="ModifierOrder"/>
         <module name="EmptyLineSeparator">
             <property name="allowNoEmptyLineBetweenFields" value="true"/>
+            <property name="allowMultipleEmptyLines" value="false"/>
+            <property name="allowMultipleEmptyLinesInsideClassMembers" value="false"/>
+            <property name="tokens" value="VARIABLE_DEF, METHOD_DEF"/>
         </module>
         <module name="SeparatorWrap">
             <property name="id" value="SeparatorWrapDot"/>
@@ -226,6 +239,7 @@
             <property name="thirdPartyPackageRegExp" value="^com\."/>
             <property name="sortImportsInGroupAlphabetically" value="true"/>
             <property name="separateLineBetweenGroups" value="true"/>
+            <property name="severity" value="info"/>
         </module>
         <module name="MethodParamPad"/>
         <module name="ParenPad"/>
@@ -249,7 +263,7 @@
             <property name="forbiddenSummaryFragments"
                       value="^@return the *|^This method returns |^A [{]@code [a-zA-Z0-9]+[}]( is a )"/>
         </module>
-        <module name="JavadocParagraph"/>
+        <!-- <module name="JavadocParagraph"/> -->
         <module name="AtclauseOrder">
             <property name="tagOrder" value="@param, @return, @throws, @deprecated"/>
             <property name="target" value="CLASS_DEF, INTERFACE_DEF, ENUM_DEF, METHOD_DEF, CTOR_DEF, VARIABLE_DEF"/>
@@ -257,11 +271,8 @@
         <module name="JavadocMethod">
             <property name="scope" value="public"/>
             <property name="allowMissingParamTags" value="true"/>
-            <property name="allowMissingThrowsTags" value="true"/>
             <property name="allowMissingReturnTag" value="true"/>
-            <property name="minLineCount" value="2"/>
             <property name="allowedAnnotations" value="Override, Test"/>
-            <property name="allowThrowsTagsForSubclasses" value="true"/>
         </module>
         <module name="MethodName">
             <property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9_]*$"/>
@@ -277,5 +288,16 @@
         <module name="CommentsIndentation"/>
         <module name="EmptyStatement"/>
         <module name="StringLiteralEquality"/>
+         <!-- Developer should probably bring up this issue with designer if ever it occurs. -->
+        <module name="EqualsHashCode">
+            <property name="severity" value="info" />
+        </module>
+        <!-- Only apply this to local variables; Designers seem to prefer using same parameter names as class members. -->
+        <module name="HiddenField">
+            <property name="tokens" value="VARIABLE_DEF"/>
+        </module>
+        
+        <module name="SimplifyBooleanExpression"/>
+        <module name="SimplifyBooleanReturn"/>
     </module>
-</module>
\ No newline at end of file
+</module>
diff --git a/com.microsoft.java.debug.core/.classpath b/com.microsoft.java.debug.core/.classpath
new file mode 100644
index 000000000..b6fe6b96c
--- /dev/null
+++ b/com.microsoft.java.debug.core/.classpath
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-21">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="target/generated-sources/annotations">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="ignore_optional_problems" value="true"/>
+			<attribute name="m2e-apt" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="target/generated-test-sources/test-annotations">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="ignore_optional_problems" value="true"/>
+			<attribute name="m2e-apt" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
diff --git a/com.microsoft.java.debug.core/.project b/com.microsoft.java.debug.core/.project
new file mode 100644
index 000000000..353c44be5
--- /dev/null
+++ b/com.microsoft.java.debug.core/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>com.microsoft.java.debug.core</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>net.sf.eclipsecs.core.CheckstyleBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>net.sf.eclipsecs.core.CheckstyleNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1665543654702</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>
diff --git a/com.microsoft.java.debug.core/pom.xml b/com.microsoft.java.debug.core/pom.xml
index adbb7b5fe..8bfdb7292 100644
--- a/com.microsoft.java.debug.core/pom.xml
+++ b/com.microsoft.java.debug.core/pom.xml
@@ -4,8 +4,8 @@
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>com.microsoft.java</groupId>
-        <artifactId>parent</artifactId>
-        <version>0.1.0</version>
+        <artifactId>java-debug-parent</artifactId>
+        <version>0.53.2</version>
     </parent>
     <artifactId>com.microsoft.java.debug.core</artifactId>
     <packaging>jar</packaging>
@@ -28,8 +28,8 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.7.0</version>
                 <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
+                    <source>11</source>
+                    <target>11</target>
                 </configuration>
             </plugin>
             <plugin>
@@ -39,43 +39,36 @@
         </plugins>
     </build>
     <dependencies>
-        <dependency>
-            <groupId>com.sun</groupId>
-            <artifactId>tools</artifactId>
-            <version>1.8</version>
-            <scope>system</scope>
-            <systemPath>${java.home}/../lib/tools.jar</systemPath>
-        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
-            <version>3.6</version>
+            <version>3.18.0</version>
         </dependency>
         <dependency>
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
-            <version>2.7</version>
+            <version>2.8.9</version>
         </dependency>
         <dependency>
             <groupId>io.reactivex.rxjava2</groupId>
             <artifactId>rxjava</artifactId>
-            <version>2.1.1</version>
+            <version>2.2.21</version>
         </dependency>
         <dependency>
             <groupId>org.reactivestreams</groupId>
             <artifactId>reactive-streams</artifactId>
-            <version>1.0.0</version>
+            <version>1.0.4</version>
         </dependency>
         <dependency>
             <groupId>commons-io</groupId>
             <artifactId>commons-io</artifactId>
-            <version>2.5</version>
+            <version>2.14.0</version>
         </dependency>
         <!-- Dependencies for test -->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.12</version>
+            <version>4.13.1</version>
             <scope>test</scope>
         </dependency>
         <dependency>
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/AsyncJdwpUtils.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/AsyncJdwpUtils.java
new file mode 100644
index 000000000..fad2ac223
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/AsyncJdwpUtils.java
@@ -0,0 +1,143 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+import static java.util.concurrent.CompletableFuture.allOf;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.Supplier;
+
+public class AsyncJdwpUtils {
+    /**
+     * Create a the thread pool to process JDWP tasks.
+     * JDWP tasks are IO-bounded, so use a relatively large thread pool for JDWP tasks.
+     */
+    public static ExecutorService jdwpThreadPool = Executors.newWorkStealingPool(100);
+    // public static ExecutorService jdwpThreadPool = Executors.newCachedThreadPool();
+
+    public static CompletableFuture<Void> runAsync(List<Runnable> tasks) {
+        return runAsync(jdwpThreadPool, tasks.toArray(new Runnable[0]));
+    }
+
+    public static CompletableFuture<Void> runAsync(Runnable... tasks) {
+        return runAsync(jdwpThreadPool, tasks);
+    }
+
+    public static CompletableFuture<Void> runAsync(Executor executor, List<Runnable> tasks) {
+        return runAsync(executor, tasks.toArray(new Runnable[0]));
+    }
+
+    public static CompletableFuture<Void> runAsync(Executor executor, Runnable... tasks) {
+        List<CompletableFuture<Void>> promises = new ArrayList<>();
+        for (Runnable task : tasks) {
+            if (task == null) {
+                continue;
+            }
+
+            promises.add(CompletableFuture.runAsync(task, executor));
+        }
+
+        return CompletableFuture.allOf(promises.toArray(new CompletableFuture[0]));
+    }
+
+    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
+        return supplyAsync(jdwpThreadPool, supplier);
+    }
+
+    public static <U> CompletableFuture<U> supplyAsync(Executor executor, Supplier<U> supplier) {
+        return CompletableFuture.supplyAsync(supplier, executor);
+    }
+
+    public static <U> U await(CompletableFuture<U> future) {
+        try {
+            return future.join();
+        } catch (CompletionException ex) {
+            if (ex.getCause() instanceof RuntimeException) {
+                throw (RuntimeException) ex.getCause();
+            }
+
+            throw ex;
+        }
+    }
+
+    public static <U> List<U> await(CompletableFuture<U>[] futures) {
+        List<U> results = new ArrayList<>();
+        try {
+            allOf(futures).join();
+            for (CompletableFuture<U> future : futures) {
+                results.add(await(future));
+            }
+        } catch (CompletionException ex) {
+            if (ex.getCause() instanceof RuntimeException) {
+                throw (RuntimeException) ex.getCause();
+            }
+
+            throw ex;
+        }
+
+        return results;
+    }
+
+    public static <U> List<U> await(List<CompletableFuture<U>> futures) {
+        return await((CompletableFuture<U>[]) futures.toArray(new CompletableFuture[0]));
+    }
+
+    public static <U> CompletableFuture<List<U>> all(CompletableFuture<U>... futures) {
+        return allOf(futures).thenApply((res) -> {
+            List<U> results = new ArrayList<>();
+            for (CompletableFuture<U> future : futures) {
+                results.add(future.join());
+            }
+
+            return results;
+        });
+    }
+
+    public static <U> CompletableFuture<List<U>> all(List<CompletableFuture<U>> futures) {
+        return allOf(futures.toArray(new CompletableFuture[0])).thenApply((res) -> {
+            List<U> results = new ArrayList<>();
+            for (CompletableFuture<U> future : futures) {
+                results.add(future.join());
+            }
+
+            return results;
+        });
+    }
+
+    public static <U> CompletableFuture<List<U>> flatAll(CompletableFuture<List<U>>... futures) {
+        return allOf(futures).thenApply((res) -> {
+            List<U> results = new ArrayList<>();
+            for (CompletableFuture<List<U>> future : futures) {
+                results.addAll(future.join());
+            }
+
+            return results;
+        });
+    }
+
+    public static <U> CompletableFuture<List<U>> flatAll(List<CompletableFuture<List<U>>> futures) {
+        return allOf(futures.toArray(new CompletableFuture[0])).thenApply((res) -> {
+            List<U> results = new ArrayList<>();
+            for (CompletableFuture<List<U>> future : futures) {
+                results.addAll(future.join());
+            }
+
+            return results;
+        });
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/Breakpoint.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/Breakpoint.java
index c8b23c488..d8316c2e3 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/Breakpoint.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/Breakpoint.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -12,12 +12,17 @@
 package com.microsoft.java.debug.core;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 
+import com.sun.jdi.AbsentInformationException;
 import com.sun.jdi.Location;
+import com.sun.jdi.Method;
 import com.sun.jdi.ReferenceType;
 import com.sun.jdi.VMDisconnectedException;
 import com.sun.jdi.VirtualMachine;
@@ -32,25 +37,65 @@
 public class Breakpoint implements IBreakpoint {
     private VirtualMachine vm = null;
     private IEventHub eventHub = null;
-    private String className = null;
-    private int lineNumber = 0;
+    private JavaBreakpointLocation sourceLocation = null;
     private int hitCount = 0;
+    private String condition = null;
+    private String logMessage = null;
     private HashMap<Object, Object> propertyMap = new HashMap<>();
+    private final boolean suspendAllThreads;
 
-    Breakpoint(VirtualMachine vm, IEventHub eventHub, String className, int lineNumber) {
-        this(vm, eventHub, className, lineNumber, 0);
+    private boolean async = false;
+
+    Breakpoint(VirtualMachine vm, IEventHub eventHub, String className, int lineNumber, boolean suspendAllThreads) {
+        this(vm, eventHub, className, lineNumber, 0, null, suspendAllThreads);
+    }
+
+    Breakpoint(VirtualMachine vm, IEventHub eventHub, String className, int lineNumber, int hitCount, boolean suspendAllThreads) {
+        this(vm, eventHub, className, lineNumber, hitCount, null, suspendAllThreads);
+    }
+
+    Breakpoint(VirtualMachine vm, IEventHub eventHub, String className, int lineNumber, int hitCount,
+            String condition, boolean suspendAllThreads) {
+        this(vm, eventHub, className, lineNumber, hitCount, condition, null, suspendAllThreads);
+    }
+
+    Breakpoint(VirtualMachine vm, IEventHub eventHub, String className, int lineNumber, int hitCount,
+            String condition, String logMessage, boolean suspendAllThreads) {
+        this.vm = vm;
+        this.eventHub = eventHub;
+        this.suspendAllThreads = suspendAllThreads;
+        String contextClass = className;
+        String methodName = null;
+        String methodSignature = null;
+        if (className != null && className.contains("#")) {
+            contextClass = className.substring(0, className.indexOf("#"));
+            String[] methodInfo = className.substring(className.indexOf("#") + 1).split("#");
+            methodName = methodInfo[0];
+            methodSignature = methodInfo[1];
+        }
+
+        this.sourceLocation = new JavaBreakpointLocation(lineNumber, -1);
+        this.sourceLocation.setClassName(contextClass);
+        this.sourceLocation.setMethodName(methodName);
+        this.sourceLocation.setMethodSignature(methodSignature);
+        this.hitCount = hitCount;
+        this.condition = condition;
+        this.logMessage = logMessage;
     }
 
-    Breakpoint(VirtualMachine vm, IEventHub eventHub, String className, int lineNumber, int hitCount) {
+    Breakpoint(VirtualMachine vm, IEventHub eventHub, JavaBreakpointLocation sourceLocation, int hitCount,
+            String condition, String logMessage, boolean suspendAllThreads) {
         this.vm = vm;
         this.eventHub = eventHub;
-        this.className = className;
-        this.lineNumber = lineNumber;
+        this.sourceLocation = sourceLocation;
         this.hitCount = hitCount;
+        this.condition = condition;
+        this.logMessage = logMessage;
+        this.suspendAllThreads = suspendAllThreads;
     }
 
     // IDebugResource
-    private List<EventRequest> requests = new ArrayList<>();
+    private List<EventRequest> requests = Collections.synchronizedList(new ArrayList<>());
     private List<Disposable> subscriptions = new ArrayList<>();
 
     @Override
@@ -66,35 +111,63 @@ public List<Disposable> subscriptions() {
     // AutoCloseable
     @Override
     public void close() throws Exception {
-        vm.eventRequestManager().deleteEventRequests(requests());
+        try {
+            vm.eventRequestManager().deleteEventRequests(requests());
+        } catch (VMDisconnectedException ex) {
+            // ignore since removing breakpoints is meaningless when JVM is terminated.
+        }
         subscriptions().forEach(subscription -> {
             subscription.dispose();
         });
+        requests.clear();
+        subscriptions.clear();
     }
 
     // IBreakpoint
+    @Override
+    public JavaBreakpointLocation sourceLocation() {
+        return this.sourceLocation;
+    }
+
     @Override
     public String className() {
-        return className;
+        return this.sourceLocation.className();
+    }
+
+    @Override
+    public int getLineNumber() {
+        return this.sourceLocation.lineNumber();
     }
 
     @Override
-    public int lineNumber() {
-        return lineNumber;
+    public int getColumnNumber() {
+        return this.sourceLocation.columnNumber();
+    }
+
+    @Override
+    public String getCondition() {
+        return condition;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(sourceLocation);
     }
 
     @Override
     public boolean equals(Object obj) {
-        if (!(obj instanceof IBreakpoint)) {
-            return super.equals(obj);
+        if (this == obj) {
+            return true;
         }
-
-        IBreakpoint breakpoint = (IBreakpoint) obj;
-        return Objects.equals(this.className(), breakpoint.className()) && this.lineNumber() == breakpoint.lineNumber();
+        if (!(obj instanceof Breakpoint)) {
+            return false;
+        }
+        Breakpoint other = (Breakpoint) obj;
+        return Objects.equals(sourceLocation, other.sourceLocation);
     }
 
     @Override
-    public int hitCount() {
+    public int getHitCount() {
         return hitCount;
     }
 
@@ -106,22 +179,61 @@ public void setHitCount(int hitCount) {
             .filter(request -> request instanceof BreakpointRequest)
             .subscribe(request -> {
                 request.addCountFilter(hitCount);
+                request.disable();
                 request.enable();
             });
     }
 
+    @Override
+    public void setCondition(String condition) {
+        this.condition = condition;
+    }
+
+    @Override
+    public void setLogMessage(String logMessage) {
+        this.logMessage = logMessage;
+    }
+
+    @Override
+    public String getLogMessage() {
+        return this.logMessage;
+    }
+
+    @Override
+    public boolean async() {
+        return this.async;
+    }
+
+    @Override
+    public void setAsync(boolean async) {
+        this.async = async;
+    }
+
+    @Override
+    public void setSuspendPolicy(String policy) {
+    }
+
+    @Override
+    public String getSuspendPolicy() {
+        return suspendAllThreads ? "SUSPEND_ALL" : "SUSPEND_EVENT_THREAD";
+    }
+
+    protected boolean suspendAllThreads() {
+        return suspendAllThreads;
+    }
+
     @Override
     public CompletableFuture<IBreakpoint> install() {
         // It's possible that different class loaders create new class with the same name.
         // Here to listen to future class prepare events to handle such case.
         ClassPrepareRequest classPrepareRequest = vm.eventRequestManager().createClassPrepareRequest();
-        classPrepareRequest.addClassFilter(className);
+        classPrepareRequest.addClassFilter(className());
         classPrepareRequest.enable();
         requests.add(classPrepareRequest);
 
         // Local types also needs to be handled
         ClassPrepareRequest localClassPrepareRequest = vm.eventRequestManager().createClassPrepareRequest();
-        localClassPrepareRequest.addClassFilter(className + "$*");
+        localClassPrepareRequest.addClassFilter(className() + "$*");
         localClassPrepareRequest.enable();
         requests.add(localClassPrepareRequest);
 
@@ -133,8 +245,9 @@ public CompletableFuture<IBreakpoint> install() {
                             || localClassPrepareRequest.equals(debugEvent.event.request())))
                 .subscribe(debugEvent -> {
                     ClassPrepareEvent event = (ClassPrepareEvent) debugEvent.event;
-                    List<BreakpointRequest> newRequests = createBreakpointRequests(event.referenceType(),
-                            lineNumber, hitCount);
+                    List<BreakpointRequest> newRequests = AsyncJdwpUtils.await(
+                        createBreakpointRequests(event.referenceType(), getLineNumber(), hitCount, false)
+                    );
                     requests.addAll(newRequests);
                     if (!newRequests.isEmpty() && !future.isDone()) {
                         this.putProperty("verified", true);
@@ -143,87 +256,230 @@ public CompletableFuture<IBreakpoint> install() {
                 });
         subscriptions.add(subscription);
 
-        List<ReferenceType> refTypes = vm.classesByName(className);
-        List<BreakpointRequest> newRequests = createBreakpointRequests(refTypes, lineNumber, hitCount);
-        requests.addAll(newRequests);
-        if (!newRequests.isEmpty() && !future.isDone()) {
-            this.putProperty("verified", true);
-            future.complete(this);
+        Runnable resolveRequestsFromExistingClasses = () -> {
+            List<ReferenceType> refTypes = vm.classesByName(className());
+            createBreakpointRequests(refTypes, getLineNumber(), hitCount, true)
+                .whenComplete((newRequests, ex) -> {
+                    if (ex != null) {
+                        return;
+                    }
+
+                    requests.addAll(newRequests);
+                    if (!newRequests.isEmpty() && !future.isDone()) {
+                        this.putProperty("verified", true);
+                        future.complete(this);
+                    }
+                });
+        };
+
+        if (async()) {
+            AsyncJdwpUtils.runAsync(resolveRequestsFromExistingClasses);
+        } else {
+            resolveRequestsFromExistingClasses.run();
         }
 
         return future;
     }
 
-    private static List<Location> collectLocations(ReferenceType refType, int lineNumber) {
-        List<Location> locations = new ArrayList<>();
+    private CompletableFuture<List<Location>> collectLocations(ReferenceType refType, int lineNumber) {
+        List<CompletableFuture<List<Location>>> futures = new ArrayList<>();
+        Iterator<Method> iter = refType.methods().iterator();
+        while (iter.hasNext()) {
+            Method method = iter.next();
+            if (async()) {
+                futures.add(AsyncJdwpUtils.supplyAsync(() -> findLocaitonsOfLine(method, lineNumber)));
+            } else {
+                futures.add(CompletableFuture.completedFuture(findLocaitonsOfLine(method, lineNumber)));
+            }
+        }
+
+        return AsyncJdwpUtils.flatAll(futures);
+    }
+
+    private CompletableFuture<List<Location>> collectLocations(List<ReferenceType> refTypes, int lineNumber, boolean includeNestedTypes) {
+        List<CompletableFuture<List<Location>>> futures = new ArrayList<>();
+        refTypes.forEach(refType -> {
+            futures.add(collectLocations(refType, lineNumber, includeNestedTypes));
+        });
 
-        try {
-            locations.addAll(refType.locationsOfLine(lineNumber));
-        } catch (Exception e) {
-            // could be AbsentInformationException or ClassNotPreparedException
-            // but both are expected so no need to further handle
+        return AsyncJdwpUtils.flatAll(futures);
+    }
+
+    private CompletableFuture<List<Location>> collectLocations(ReferenceType refType, int lineNumber, boolean includeNestedTypes) {
+        return collectLocations(refType, lineNumber).thenCompose((newLocations) -> {
+            if (!newLocations.isEmpty()) {
+                return CompletableFuture.completedFuture(newLocations);
+            } else if (includeNestedTypes) {
+                // ReferenceType.nestedTypes() will invoke vm.allClasses() to list all loaded classes,
+                // should avoid using nestedTypes for performance.
+                for (ReferenceType nestedType : refType.nestedTypes()) {
+                    CompletableFuture<List<Location>> nestedLocationsFuture = collectLocations(nestedType, lineNumber);
+                    List<Location> nestedLocations = nestedLocationsFuture.join();
+                    if (!nestedLocations.isEmpty()) {
+                        return CompletableFuture.completedFuture(nestedLocations);
+                    }
+                }
+            }
+
+            return CompletableFuture.completedFuture(Collections.emptyList());
+        });
+    }
+
+    private CompletableFuture<List<Location>> collectLocations(List<ReferenceType> refTypes, String methodName, String methodSiguature) {
+        List<CompletableFuture<Location>> futures = new ArrayList<>();
+        for (ReferenceType refType : refTypes) {
+            if (async()) {
+                futures.add(AsyncJdwpUtils.supplyAsync(() -> findMethodLocaiton(refType, methodName, methodSiguature)));
+            } else {
+                futures.add(CompletableFuture.completedFuture(findMethodLocaiton(refType, methodName, methodSiguature)));
+            }
+        }
+
+        return AsyncJdwpUtils.all(futures);
+    }
+
+    private Location findMethodLocaiton(ReferenceType refType, String methodName, String methodSiguature) {
+        List<Method> methods = refType.methods();
+        Location location = null;
+        for (Method method : methods) {
+            if (!method.isAbstract() && !method.isNative()
+                    && methodName.equals(method.name())
+                    && (methodSiguature.equals(method.genericSignature()) || methodSiguature.equals(method.signature())
+                            || toNoneGeneric(methodSiguature).equals(method.signature()))) {
+                location = method.location();
+                break;
+            }
         }
 
-        return locations;
+        return location;
+    }
+
+    static String toNoneGeneric(String genericSig) {
+        StringBuilder builder = new StringBuilder();
+        boolean append = true;
+        int depth = 0;
+        char[] chars = genericSig.toCharArray();
+        for (int i = 0; i < chars.length; i++) {
+            char c = chars[i];
+            if (c == '<') {
+                depth++;
+                append = (depth == 0);
+            }
+            if (append) {
+                builder.append(c);
+            }
+            if (c == '>') {
+                depth--;
+                append = (depth == 0);
+            }
+        }
+        return builder.toString();
     }
 
-    private static List<Location> collectLocations(List<ReferenceType> refTypes, int lineNumber) {
-        List<Location> locations = new ArrayList<>();
+    private List<Location> findLocaitonsOfLine(Method method, int lineNumber) {
         try {
-            refTypes.forEach(refType -> {
-                locations.addAll(collectLocations(refType, lineNumber));
-                locations.addAll(collectLocations(refType.nestedTypes(), lineNumber));
-            });
-        } catch (VMDisconnectedException ex) {
-            // collect locations operation may be executing while JVM is running, thus the VMDisconnectedException may be
-            // possible, in case of VMDisconnectedException, this method will return an empty array which turns out a valid
-            // response in vscode, causing no error log in trace.
+            return method.locationsOfLine(lineNumber);
+        } catch (AbsentInformationException e) {
+            // could be AbsentInformationException or ClassNotPreparedException
+            // but both are expected so no need to further handle
         }
 
-        return locations;
+        return Collections.emptyList();
     }
 
-    private List<BreakpointRequest> createBreakpointRequests(ReferenceType refType, int lineNumber, int hitCount) {
-        List<ReferenceType> refTypes = new ArrayList<>();
-        refTypes.add(refType);
-        return createBreakpointRequests(refTypes, lineNumber, hitCount);
+    private CompletableFuture<List<BreakpointRequest>> createBreakpointRequests(ReferenceType refType, int lineNumber, int hitCount,
+            boolean includeNestedTypes) {
+        return createBreakpointRequests(Arrays.asList(refType), lineNumber, hitCount, includeNestedTypes);
     }
 
-    private List<BreakpointRequest> createBreakpointRequests(List<ReferenceType> refTypes, int lineNumber, int hitCount) {
-        List<Location> locations = collectLocations(refTypes, lineNumber);
+    private CompletableFuture<List<BreakpointRequest>> createBreakpointRequests(List<ReferenceType> refTypes, int lineNumber,
+            int hitCount, boolean includeNestedTypes) {
+        CompletableFuture<List<Location>> locationsFuture;
+        if (this.sourceLocation.methodName() != null) {
+            locationsFuture = collectLocations(refTypes, this.sourceLocation.methodName(), this.sourceLocation.methodSignature());
+        } else {
+            locationsFuture = collectLocations(refTypes, lineNumber, includeNestedTypes).thenApply((locations) -> {
+                if (locations.isEmpty()) {
+                    return locations;
+                }
 
-        // find out the existing breakpoint locations
-        List<Location> existingLocations = new ArrayList<>(requests.size());
-        Observable.fromIterable(requests).filter(request -> request instanceof BreakpointRequest)
-                .map(request -> ((BreakpointRequest) request).location()).toList().subscribe(list -> {
-                    existingLocations.addAll(list);
-                });
+                /**
+                 * For a line breakpoint, we default to breaking at the first location
+                 * of the line. If you want to break at other locations on the same line,
+                 * you can add an inline breakpoint based on the locations returned by
+                 * the BreakpointLocation request.
+                 */
+                return Arrays.asList(locations.get(0));
+            });
+        }
 
-        // remove duplicated locations
-        List<Location> newLocations = new ArrayList<>(locations.size());
-        Observable.fromIterable(locations).filter(location -> !existingLocations.contains(location)).toList().subscribe(list -> {
-            newLocations.addAll(list);
-        });
+        return locationsFuture.thenCompose((locations) -> {
+            // find out the existing breakpoint locations
+            List<Location> existingLocations = new ArrayList<>(requests.size());
+            Observable.fromIterable(requests).filter(request -> request instanceof BreakpointRequest)
+                    .map(request -> ((BreakpointRequest) request).location()).toList().subscribe(list -> {
+                        existingLocations.addAll(list);
+                    });
+
+            // remove duplicated locations
+            List<Location> newLocations = new ArrayList<>(locations.size());
+            Observable.fromIterable(locations).filter(location -> !existingLocations.contains(location)).toList().subscribe(list -> {
+                newLocations.addAll(list);
+            });
 
-        List<BreakpointRequest> newRequests = new ArrayList<>(newLocations.size());
+            List<BreakpointRequest> newRequests = new ArrayList<>(newLocations.size());
 
-        newLocations.forEach(location -> {
-            try {
+            newLocations.forEach(location -> {
                 BreakpointRequest request = vm.eventRequestManager().createBreakpointRequest(location);
-                request.setSuspendPolicy(BreakpointRequest.SUSPEND_EVENT_THREAD);
+                if ("SUSPEND_ALL".equals(getSuspendPolicy())) {
+                    request.setSuspendPolicy(BreakpointRequest.SUSPEND_ALL);
+                } else {
+                    request.setSuspendPolicy(BreakpointRequest.SUSPEND_EVENT_THREAD);
+                }
                 if (hitCount > 0) {
                     request.addCountFilter(hitCount);
                 }
-                request.enable();
+                request.putProperty(IBreakpoint.REQUEST_TYPE, computeRequestType());
                 newRequests.add(request);
-            } catch (VMDisconnectedException ex) {
-                // enable breakpoint operation may be executing while JVM is running, thus the VMDisconnectedException may be
-                // possible, in case of VMDisconnectedException, this method will return an empty array which turns out a valid
-                // response in vscode, causing no error log in trace.
+            });
+
+            List<CompletableFuture<Void>> futures = new ArrayList<>();
+            for (BreakpointRequest request : newRequests) {
+                if (async()) {
+                    futures.add(AsyncJdwpUtils.runAsync(() -> {
+                        try {
+                            request.enable();
+                        } catch (VMDisconnectedException ex) {
+                            // enable breakpoint operation may be executing while JVM is terminating, thus the VMDisconnectedException may be
+                            // possible, in case of VMDisconnectedException, this method will return an empty array which turns out a valid
+                            // response in vscode, causing no error log in trace.
+                        }
+                    }));
+                } else {
+                    try {
+                        request.enable();
+                    } catch (VMDisconnectedException ex) {
+                        // enable breakpoint operation may be executing while JVM is terminating, thus the VMDisconnectedException may be
+                        // possible, in case of VMDisconnectedException, this method will return an empty array which turns out a valid
+                        // response in vscode, causing no error log in trace.
+                    }
+                }
             }
+
+            return AsyncJdwpUtils.all(futures).thenApply((res) -> newRequests);
         });
+    }
 
-        return newRequests;
+    private Object computeRequestType() {
+        if (this.sourceLocation.methodName() == null) {
+            return IBreakpoint.REQUEST_TYPE_LINE;
+        }
+
+        if (this.sourceLocation.methodName().startsWith("lambda$")) {
+            return IBreakpoint.REQUEST_TYPE_LAMBDA;
+        } else {
+            return IBreakpoint.REQUEST_TYPE_METHOD;
+        }
     }
 
     @Override
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugEvent.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugEvent.java
index 9e6dc98b1..859de27e3 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugEvent.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugEvent.java
@@ -12,8 +12,10 @@
 package com.microsoft.java.debug.core;
 
 import com.sun.jdi.event.Event;
+import com.sun.jdi.event.EventSet;
 
 public class DebugEvent {
     public Event event = null;
+    public EventSet eventSet = null;
     public boolean shouldResume = true;
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugException.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugException.java
index eae0291b7..302b9a4bb 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugException.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugException.java
@@ -13,6 +13,9 @@
 
 public class DebugException extends Exception {
     private static final long serialVersionUID = 1L;
+    private int errorCode;
+
+    private boolean userError = false;
 
     public DebugException() {
         super();
@@ -29,4 +32,43 @@ public DebugException(String message, Throwable cause) {
     public DebugException(Throwable cause) {
         super(cause);
     }
+
+    public DebugException(String message, int errorCode) {
+        super(message);
+        this.errorCode = errorCode;
+    }
+
+    /**
+     * Create a debug exception with userError flag.
+     * @param message the error message
+     * @param errorCode the error code
+     * @param userError the boolean value indicating whether this exception is caused by a known user error
+     */
+    public DebugException(String message, int errorCode, boolean userError) {
+        super(message);
+        this.errorCode = errorCode;
+        this.userError = userError;
+    }
+
+    public DebugException(String message, Throwable cause, int errorCode) {
+        super(message, cause);
+        this.errorCode = errorCode;
+    }
+
+    public DebugException(Throwable cause, int errorCode) {
+        super(cause);
+        this.errorCode = errorCode;
+    }
+
+    public int getErrorCode() {
+        return this.errorCode;
+    }
+
+    public void setUserError(boolean userError) {
+        this.userError = userError;
+    }
+
+    public boolean isUserError() {
+        return this.userError;
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugSession.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugSession.java
index 986d4704e..c040f5b79 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugSession.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugSession.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -11,37 +11,84 @@
 
 package com.microsoft.java.debug.core;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
 
+import org.apache.commons.lang3.StringUtils;
+
+import com.sun.jdi.ObjectCollectedException;
+import com.sun.jdi.ReferenceType;
 import com.sun.jdi.ThreadReference;
+import com.sun.jdi.VMDisconnectedException;
 import com.sun.jdi.VirtualMachine;
+import com.sun.jdi.event.ClassPrepareEvent;
+import com.sun.jdi.request.ClassPrepareRequest;
 import com.sun.jdi.request.EventRequest;
 import com.sun.jdi.request.EventRequestManager;
 import com.sun.jdi.request.ExceptionRequest;
 
+import io.reactivex.disposables.Disposable;
+
 public class DebugSession implements IDebugSession {
     private VirtualMachine vm;
     private EventHub eventHub = new EventHub();
+    private List<EventRequest> eventRequests = new ArrayList<>();
+    private List<Disposable> subscriptions = new ArrayList<>();
+    private final boolean suspendAllThreads;
 
     public DebugSession(VirtualMachine virtualMachine) {
         vm = virtualMachine;
+        // Capture suspend policy at session start - this persists for the session lifetime
+        this.suspendAllThreads = DebugSettings.getCurrent().suspendAllThreads;
     }
 
     @Override
     public void start() {
+        boolean supportsVirtualThreads = mayCreateVirtualThreads();
+
         // request thread events by default
         EventRequest threadStartRequest = vm.eventRequestManager().createThreadStartRequest();
         threadStartRequest.setSuspendPolicy(EventRequest.SUSPEND_NONE);
+        if (supportsVirtualThreads) {
+            addPlatformThreadsOnlyFilter(threadStartRequest);
+        }
         threadStartRequest.enable();
 
         EventRequest threadDeathRequest = vm.eventRequestManager().createThreadDeathRequest();
         threadDeathRequest.setSuspendPolicy(EventRequest.SUSPEND_NONE);
+        if (supportsVirtualThreads) {
+            addPlatformThreadsOnlyFilter(threadDeathRequest);
+        }
         threadDeathRequest.enable();
 
         eventHub.start(vm);
     }
 
+    private boolean mayCreateVirtualThreads() {
+        try {
+            Method method = vm.getClass().getMethod("mayCreateVirtualThreads");
+            return (boolean) method.invoke(vm);
+        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+            // ignore
+        }
+
+        return false;
+    }
+
+    /**
+     * For thread start and thread death events, restrict the events so they are only sent for platform threads.
+     */
+    private void addPlatformThreadsOnlyFilter(EventRequest threadLifecycleRequest) {
+        try {
+            Method method = threadLifecycleRequest.getClass().getMethod("addPlatformThreadsOnlyFilter");
+            method.invoke(threadLifecycleRequest);
+        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+            // ignore
+        }
+    }
+
     @Override
     public void suspend() {
         vm.suspend();
@@ -57,8 +104,12 @@ public void resume() {
          * all threads fully.
          */
         for (ThreadReference tr : DebugUtility.getAllThreadsSafely(this)) {
-            while (!tr.isCollected() && tr.suspendCount() > 1) {
-                tr.resume();
+            try {
+                while (tr.suspendCount() > 1) {
+                    tr.resume();
+                }
+            } catch (ObjectCollectedException ex) {
+                // Skip it if the thread is garbage collected.
             }
         }
         vm.resume();
@@ -66,34 +117,134 @@ public void resume() {
 
     @Override
     public void detach() {
-        vm.dispose();
+        try {
+            vm.dispose();
+        } catch (VMDisconnectedException ex) {
+            // ignore — VM already disconnected (e.g. process was terminated first)
+        }
     }
 
     @Override
     public void terminate() {
-        if (vm.process().isAlive()) {
+        if (vm.process() != null && vm.process().isAlive()) {
+            vm.process().destroy();
+        } else if (vm.process() == null || vm.process().isAlive()) {
             vm.exit(0);
         }
     }
 
     @Override
-    public IBreakpoint createBreakpoint(String className, int lineNumber) {
-        return new Breakpoint(vm, this.eventHub(), className, lineNumber);
+    public IBreakpoint createBreakpoint(JavaBreakpointLocation sourceLocation, int hitCount, String condition, String logMessage) {
+        return new EvaluatableBreakpoint(vm, this.getEventHub(), sourceLocation, hitCount, condition, logMessage, suspendAllThreads);
+    }
+
+    @Override
+    public IBreakpoint createBreakpoint(String className, int lineNumber, int hitCount, String condition, String logMessage) {
+        return new EvaluatableBreakpoint(vm, this.getEventHub(), className, lineNumber, hitCount, condition, logMessage, suspendAllThreads);
     }
 
     @Override
-    public IBreakpoint createBreakpoint(String className, int lineNumber, int hitCount) {
-        return new Breakpoint(vm, this.eventHub(), className, lineNumber, hitCount);
+    public IWatchpoint createWatchPoint(String className, String fieldName, String accessType, String condition, int hitCount) {
+        return new Watchpoint(vm, this.getEventHub(), className, fieldName, accessType, condition, hitCount, suspendAllThreads);
     }
 
     @Override
     public void setExceptionBreakpoints(boolean notifyCaught, boolean notifyUncaught) {
+        setExceptionBreakpoints(notifyCaught, notifyUncaught, null, null);
+    }
+
+    @Override
+    public void setExceptionBreakpoints(boolean notifyCaught, boolean notifyUncaught, String[] classFilters, String[] classExclusionFilters) {
+        setExceptionBreakpoints(notifyCaught, notifyUncaught, null, classFilters, classExclusionFilters);
+    }
+
+    @Override
+    public void setExceptionBreakpoints(boolean notifyCaught, boolean notifyUncaught, String[] exceptionTypes,
+        String[] classFilters, String[] classExclusionFilters) {
         EventRequestManager manager = vm.eventRequestManager();
-        ArrayList<ExceptionRequest> legacy = new ArrayList<>(manager.exceptionRequests());
-        manager.deleteEventRequests(legacy);
-        ExceptionRequest request = manager.createExceptionRequest(null, notifyCaught, notifyUncaught);
-        request.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
-        request.enable();
+
+        try {
+            ArrayList<ExceptionRequest> legacy = new ArrayList<>(manager.exceptionRequests());
+            manager.deleteEventRequests(legacy);
+            manager.deleteEventRequests(eventRequests);
+        } catch (VMDisconnectedException ex) {
+            // ignore since removing breakpoints is meaningless when JVM is terminated.
+        }
+        subscriptions.forEach(subscription -> {
+            subscription.dispose();
+        });
+        subscriptions.clear();
+        eventRequests.clear();
+
+        // When no exception breakpoints are requested, no need to create an empty exception request.
+        if (notifyCaught || notifyUncaught) {
+            // from: https://www.javatips.net/api/REPLmode-master/src/jm/mode/replmode/REPLRunner.java
+            // Calling this seems to set something internally to make the
+            // Eclipse JDI wake up. Without it, an ObjectCollectedException
+            // is thrown on request.enable(). No idea why this works,
+            // but at least exception handling has returned. (Suspect that it may
+            // block until all or at least some threads are available, meaning
+            // that the app has launched and we have legit objects to talk to).
+            vm.allThreads();
+            // The bug may not have been noticed because the test suite waits for
+            // a thread to be available, and queries it by calling allThreads().
+            // See org.eclipse.debug.jdi.tests.AbstractJDITest for the example.
+
+            if (exceptionTypes == null || exceptionTypes.length == 0) {
+                ExceptionRequest request = manager.createExceptionRequest(null, notifyCaught, notifyUncaught);
+                request.setSuspendPolicy(suspendAllThreads ? EventRequest.SUSPEND_ALL : EventRequest.SUSPEND_EVENT_THREAD);
+                if (classFilters != null) {
+                    for (String classFilter : classFilters) {
+                        request.addClassFilter(classFilter);
+                    }
+                }
+                if (classExclusionFilters != null) {
+                    for (String exclusionFilter : classExclusionFilters) {
+                        request.addClassExclusionFilter(exclusionFilter);
+                    }
+                }
+                request.enable();
+                return;
+            }
+
+            for (String exceptionType : exceptionTypes) {
+                if (StringUtils.isBlank(exceptionType)) {
+                    continue;
+                }
+
+                // register exception breakpoint in the future loaded classes.
+                ClassPrepareRequest classPrepareRequest = manager.createClassPrepareRequest();
+                classPrepareRequest.addClassFilter(exceptionType);
+                classPrepareRequest.enable();
+                eventRequests.add(classPrepareRequest);
+
+                Disposable subscription = eventHub.events()
+                    .filter(debugEvent -> debugEvent.event instanceof ClassPrepareEvent
+                        && eventRequests.contains(debugEvent.event.request()))
+                    .subscribe(debugEvent -> {
+                        ClassPrepareEvent event = (ClassPrepareEvent) debugEvent.event;
+                        createExceptionBreakpoint(event.referenceType(), notifyCaught, notifyUncaught, classFilters, classExclusionFilters);
+                    });
+                subscriptions.add(subscription);
+
+                // register exception breakpoint in the loaded classes.
+                for (ReferenceType refType : vm.classesByName(exceptionType)) {
+                    createExceptionBreakpoint(refType, notifyCaught, notifyUncaught, classFilters, classExclusionFilters);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void setExceptionBreakpoints(boolean notifyCaught, boolean notifyUncaught, String[] exceptionTypes,
+            String[] classFilters, String[] classExclusionFilters, boolean async) {
+        if (async) {
+            AsyncJdwpUtils.runAsync(() -> {
+                setExceptionBreakpoints(notifyCaught, notifyUncaught, exceptionTypes, classFilters, classExclusionFilters);
+            });
+        } else {
+            setExceptionBreakpoints(notifyCaught, notifyUncaught, exceptionTypes, classFilters, classExclusionFilters);
+        }
     }
 
     @Override
@@ -102,12 +253,46 @@ public Process process() {
     }
 
     @Override
-    public List<ThreadReference> allThreads() {
+    public List<ThreadReference> getAllThreads() {
         return vm.allThreads();
     }
 
     @Override
-    public IEventHub eventHub() {
+    public IEventHub getEventHub() {
         return eventHub;
     }
+
+    @Override
+    public VirtualMachine getVM() {
+        return vm;
+    }
+
+    @Override
+    public boolean shouldSuspendAllThreads() {
+        return suspendAllThreads;
+    }
+
+    @Override
+    public IMethodBreakpoint createFunctionBreakpoint(String className, String functionName, String condition,
+            int hitCount) {
+        return new MethodBreakpoint(vm, this.getEventHub(), className, functionName, condition, hitCount, suspendAllThreads);
+    }
+
+    private void createExceptionBreakpoint(ReferenceType refType, boolean notifyCaught, boolean notifyUncaught,
+            String[] classFilters, String[] classExclusionFilters) {
+        EventRequestManager manager = vm.eventRequestManager();
+        ExceptionRequest request = manager.createExceptionRequest(refType, notifyCaught, notifyUncaught);
+        request.setSuspendPolicy(suspendAllThreads ? EventRequest.SUSPEND_ALL : EventRequest.SUSPEND_EVENT_THREAD);
+        if (classFilters != null) {
+            for (String classFilter : classFilters) {
+                request.addClassFilter(classFilter);
+            }
+        }
+        if (classExclusionFilters != null) {
+            for (String exclusionFilter : classExclusionFilters) {
+                request.addClassExclusionFilter(exclusionFilter);
+            }
+        }
+        request.enable();
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugSettings.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugSettings.java
new file mode 100644
index 000000000..b422f6801
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugSettings.java
@@ -0,0 +1,112 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
+
+import com.google.gson.JsonSyntaxException;
+import com.google.gson.annotations.SerializedName;
+import com.microsoft.java.debug.core.protocol.JsonUtils;
+import com.microsoft.java.debug.core.protocol.Requests.ExceptionFilters;
+import com.microsoft.java.debug.core.protocol.Requests.StepFilters;
+
+public final class DebugSettings {
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    private static Set<IDebugSettingChangeListener> listeners =
+        Collections.newSetFromMap(new ConcurrentHashMap<IDebugSettingChangeListener, Boolean>());
+    private static DebugSettings current = new DebugSettings();
+
+    public int maxStringLength = 0;
+    public int numericPrecision = 0;
+    public boolean showStaticVariables = false;
+    public boolean showQualifiedNames = false;
+    public boolean showHex = false;
+    public boolean showLogicalStructure = true;
+    public boolean showToString = true;
+    public String logLevel;
+    public String javaHome;
+    public HotCodeReplace hotCodeReplace = HotCodeReplace.MANUAL;
+    public StepFilters stepFilters = new StepFilters();
+    public ExceptionFilters exceptionFilters = new ExceptionFilters();
+    public boolean exceptionFiltersUpdated = false;
+    public int limitOfVariablesPerJdwpRequest = 100;
+    public int jdwpRequestTimeout = 3000;
+    public AsyncMode asyncJDWP = AsyncMode.OFF;
+    public Switch debugSupportOnDecompiledSource = Switch.OFF;
+    public boolean suspendAllThreads = false;
+
+    public static DebugSettings getCurrent() {
+        return current;
+    }
+
+    /**
+     * Update current settings with the values in the parameter.
+     *
+     * @param jsonSettings
+     *            the new settings represents in json format.
+     */
+    public void updateSettings(String jsonSettings) {
+        try {
+            DebugSettings oldSettings = current;
+            current = JsonUtils.fromJson(jsonSettings, DebugSettings.class);
+            for (IDebugSettingChangeListener listener : listeners) {
+                listener.update(oldSettings, current);
+            }
+        } catch (JsonSyntaxException ex) {
+            logger.severe(String.format("Invalid json for debugSettings: %s, %s", jsonSettings, ex.getMessage()));
+        }
+    }
+
+    private DebugSettings() {
+
+    }
+
+    public static boolean addDebugSettingChangeListener(IDebugSettingChangeListener listener) {
+        return listeners.add(listener);
+    }
+
+    public static boolean removeDebugSettingChangeListener(IDebugSettingChangeListener listener) {
+        return listeners.remove(listener);
+    }
+
+    public static enum HotCodeReplace {
+        @SerializedName("manual")
+        MANUAL,
+        @SerializedName("auto")
+        AUTO,
+        @SerializedName("never")
+        NEVER
+    }
+
+    public static enum AsyncMode {
+        @SerializedName("auto")
+        AUTO,
+        @SerializedName("on")
+        ON,
+        @SerializedName("off")
+        OFF
+    }
+
+    public static enum Switch {
+        @SerializedName("on")
+        ON,
+        @SerializedName("off")
+        OFF
+    }
+
+    public static interface IDebugSettingChangeListener {
+        public void update(DebugSettings oldSettings, DebugSettings newSettings);
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugUtility.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugUtility.java
index 5a4043008..8a31792f0 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugUtility.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/DebugUtility.java
@@ -13,14 +13,21 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 
 import org.apache.commons.lang3.StringUtils;
 
-import com.sun.jdi.Location;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.sun.jdi.Method;
 import com.sun.jdi.ObjectCollectedException;
 import com.sun.jdi.ThreadReference;
 import com.sun.jdi.VMDisconnectedException;
@@ -31,14 +38,112 @@
 import com.sun.jdi.connect.IllegalConnectorArgumentsException;
 import com.sun.jdi.connect.LaunchingConnector;
 import com.sun.jdi.connect.VMStartException;
-import com.sun.jdi.event.StepEvent;
+import com.sun.jdi.event.MethodEntryEvent;
 import com.sun.jdi.request.EventRequest;
+import com.sun.jdi.request.EventRequestManager;
+import com.sun.jdi.request.MethodEntryRequest;
 import com.sun.jdi.request.StepRequest;
 
 public class DebugUtility {
-    public static IDebugSession launch(VirtualMachineManager vmManager, String mainClass, String programArguments, String vmArguments, List<String> classPaths)
+    public static final String HOME = "home";
+    public static final String OPTIONS = "options";
+    public static final String MAIN = "main";
+    public static final String SUSPEND = "suspend";
+    public static final String QUOTE = "quote";
+    public static final String EXEC = "vmexec";
+    public static final String CWD = "cwd";
+    public static final String ENV = "env";
+    public static final String HOSTNAME = "hostname";
+    public static final String PORT = "port";
+    public static final String TIMEOUT = "timeout";
+
+    /**
+     * Launch a debuggee in suspend mode.
+     * @see #launch(VirtualMachineManager, String, String, String, String, String, String, String[])
+     */
+    public static IDebugSession launch(VirtualMachineManager vmManager,
+            String mainClass,
+            String programArguments,
+            String vmArguments,
+            List<String> modulePaths,
+            List<String> classPaths,
+            String cwd,
+            String[] envVars)
+            throws IOException, IllegalConnectorArgumentsException, VMStartException {
+        return DebugUtility.launch(vmManager,
+                mainClass,
+                programArguments,
+                vmArguments,
+                String.join(File.pathSeparator, modulePaths),
+                String.join(File.pathSeparator, classPaths),
+                cwd,
+                envVars);
+    }
+
+    /**
+     * Launch a debuggee in suspend mode.
+     * @see #launch(VirtualMachineManager, String, String, String, String, String, String, String[], String)
+     */
+    public static IDebugSession launch(VirtualMachineManager vmManager,
+            String mainClass,
+            String programArguments,
+            String vmArguments,
+            List<String> modulePaths,
+            List<String> classPaths,
+            String cwd,
+            String[] envVars,
+            String javaExec)
+            throws IOException, IllegalConnectorArgumentsException, VMStartException {
+        return DebugUtility.launch(vmManager,
+                mainClass,
+                programArguments,
+                vmArguments,
+                String.join(File.pathSeparator, modulePaths),
+                String.join(File.pathSeparator, classPaths),
+                cwd,
+                envVars,
+                javaExec);
+    }
+
+    /**
+     * Launches a debuggee in suspend mode.
+     *
+     * @param vmManager
+     *            the virtual machine manager.
+     * @param mainClass
+     *            the main class.
+     * @param programArguments
+     *            the program arguments.
+     * @param vmArguments
+     *            the vm arguments.
+     * @param modulePaths
+     *            the module paths.
+     * @param classPaths
+     *            the class paths.
+     * @param cwd
+     *            the working directory of the program.
+     * @param envVars
+     *            array of strings, each element of which has environment variable settings in the format name=value.
+     *            or null if the subprocess should inherit the environment of the current process.
+     * @return an instance of IDebugSession.
+     * @throws IOException
+     *             when unable to launch.
+     * @throws IllegalConnectorArgumentsException
+     *             when one of the arguments is invalid.
+     * @throws VMStartException
+     *             when the debuggee was successfully launched, but terminated
+     *             with an error before a connection could be established.
+     */
+    public static IDebugSession launch(VirtualMachineManager vmManager,
+            String mainClass,
+            String programArguments,
+            String vmArguments,
+            String modulePaths,
+            String classPaths,
+            String cwd,
+            String[] envVars)
             throws IOException, IllegalConnectorArgumentsException, VMStartException {
-        return DebugUtility.launch(vmManager, mainClass, programArguments, vmArguments, String.join(File.pathSeparator, classPaths));
+        return launch(vmManager, mainClass, programArguments, vmArguments, modulePaths, classPaths, cwd, envVars, null);
     }
 
     /**
@@ -52,8 +157,17 @@ public static IDebugSession launch(VirtualMachineManager vmManager, String mainC
      *            the program arguments.
      * @param vmArguments
      *            the vm arguments.
+     * @param modulePaths
+     *            the module paths.
      * @param classPaths
      *            the class paths.
+     * @param cwd
+     *            the working directory of the program.
+     * @param envVars
+     *            array of strings, each element of which has environment variable settings in the format name=value.
+     *            or null if the subprocess should inherit the environment of the current process.
+     * @param javaExec
+     *            the java executable path. If not defined, then resolve from java home.
      * @return an instance of IDebugSession.
      * @throws IOException
      *             when unable to launch.
@@ -63,23 +177,73 @@ public static IDebugSession launch(VirtualMachineManager vmManager, String mainC
      *             when the debuggee was successfully launched, but terminated
      *             with an error before a connection could be established.
      */
-    public static IDebugSession launch(VirtualMachineManager vmManager, String mainClass, String programArguments, String vmArguments, String classPaths)
+    public static IDebugSession launch(VirtualMachineManager vmManager,
+            String mainClass,
+            String programArguments,
+            String vmArguments,
+            String modulePaths,
+            String classPaths,
+            String cwd,
+            String[] envVars,
+            String javaExec)
             throws IOException, IllegalConnectorArgumentsException, VMStartException {
         List<LaunchingConnector> connectors = vmManager.launchingConnectors();
         LaunchingConnector connector = connectors.get(0);
 
+        /** In the sun JDK 10, the first launching connector is com.sun.tools.jdi.RawCommandLineLauncher, which is not the one we want to use.
+         *  Add the logic to filter the right one from LaunchingConnector list.
+         *  This fix is only for the JDI implementation by JDK. Other JDI implementations (such as JDT) doesn't have the impact.
+         */
+        final String SUN_LAUNCHING_CONNECTOR = "com.sun.tools.jdi.SunCommandLineLauncher";
+        for (LaunchingConnector con : connectors) {
+            if (con.getClass().getName().equals(SUN_LAUNCHING_CONNECTOR)) {
+                connector = con;
+                break;
+            }
+        }
+
         Map<String, Argument> arguments = connector.defaultArguments();
-        arguments.get("suspend").setValue("true");
+        arguments.get(SUSPEND).setValue("true");
+
+        String options = "";
         if (StringUtils.isNotBlank(vmArguments)) {
-            arguments.get("options").setValue(vmArguments + " -cp \"" + classPaths + "\"");
-        } else {
-            arguments.get("options").setValue("-cp \"" + classPaths + "\"");
+            options = vmArguments;
+        }
+        if (StringUtils.isNotBlank(modulePaths)) {
+            options += " --module-path \"" + modulePaths + "\"";
+        }
+        if (StringUtils.isNotBlank(classPaths)) {
+            options += " -cp \"" + classPaths + "\"";
+        }
+        arguments.get(OPTIONS).setValue(options);
+
+        // For java 9 project, should specify "-m $MainClass".
+        String[] mainClasses = mainClass.split("/");
+        if (mainClasses.length == 2) {
+            mainClass = "-m " + mainClass;
         }
         if (StringUtils.isNotBlank(programArguments)) {
-            arguments.get("main").setValue(mainClass + " " + programArguments);
-        } else {
-            arguments.get("main").setValue(mainClass);
+            mainClass += " " + programArguments;
+        }
+        arguments.get(MAIN).setValue(mainClass);
+
+        if (arguments.get(CWD) != null) {
+            arguments.get(CWD).setValue(cwd);
+        }
+
+        if (arguments.get(ENV) != null) {
+            arguments.get(ENV).setValue(encodeArrayArgument(envVars));
+        }
+
+        if (isValidJavaExec(javaExec)) {
+            String vmExec = new File(javaExec).getName();
+            String javaHome = new File(javaExec).getParentFile().getParentFile().getAbsolutePath();
+            arguments.get(HOME).setValue(javaHome);
+            arguments.get(EXEC).setValue(vmExec);
+        } else if (StringUtils.isNotEmpty(DebugSettings.getCurrent().javaHome)) {
+            arguments.get(HOME).setValue(DebugSettings.getCurrent().javaHome);
         }
+
         VirtualMachine vm = connector.launch(arguments);
         // workaround for JDT bug.
         // vm.version() calls org.eclipse.jdi.internal.MirrorImpl#requestVM
@@ -91,6 +255,20 @@ public static IDebugSession launch(VirtualMachineManager vmManager, String mainC
         return new DebugSession(vm);
     }
 
+    private static boolean isValidJavaExec(String javaExec) {
+        if (StringUtils.isBlank(javaExec)) {
+            return false;
+        }
+
+        File file = new File(javaExec);
+        if (!file.exists() || !file.isFile()) {
+            return false;
+        }
+
+        return Files.isExecutable(file.toPath())
+            && Objects.equals(file.getParentFile().getName(), "bin");
+    }
+
     /**
      * Attach to an existing debuggee VM.
      * @param vmManager
@@ -111,73 +289,148 @@ public static IDebugSession attach(VirtualMachineManager vmManager, String hostN
             throws IOException, IllegalConnectorArgumentsException {
         List<AttachingConnector> connectors = vmManager.attachingConnectors();
         AttachingConnector connector = connectors.get(0);
+        // in JDK 10, the first AttachingConnector is not the one we want
+        final String SUN_ATTACH_CONNECTOR = "com.sun.tools.jdi.SocketAttachingConnector";
+        for (AttachingConnector con : connectors) {
+            if (con.getClass().getName().equals(SUN_ATTACH_CONNECTOR)) {
+                connector = con;
+                break;
+            }
+        }
         Map<String, Argument> arguments = connector.defaultArguments();
-        arguments.get("hostname").setValue(hostName);
-        arguments.get("port").setValue(String.valueOf(port));
-        arguments.get("timeout").setValue(String.valueOf(attachTimeout));
+        arguments.get(HOSTNAME).setValue(hostName);
+        arguments.get(PORT).setValue(String.valueOf(port));
+        arguments.get(TIMEOUT).setValue(String.valueOf(attachTimeout));
         return new DebugSession(connector.attach(arguments));
     }
 
     /**
-     * Steps over newly pushed frames.
-     *
+     * Create a step over request on the specified thread.
      * @param thread
-     *            the target thread.
-     * @param eventHub
-     *            the {@link IEventHub} instance.
-     * @return the new {@link Location} of the execution flow of the specified
-     *         thread.
+     *              the target thread.
+     * @param stepFilters
+     *              the step filters when stepping.
+     * @return the new step request.
      */
-    public static CompletableFuture<Location> stepOver(ThreadReference thread, IEventHub eventHub) {
-        return DebugUtility.step(thread, eventHub, StepRequest.STEP_LINE, StepRequest.STEP_OVER);
+    public static StepRequest createStepOverRequest(ThreadReference thread, String[] stepFilters) {
+        return createStepOverRequest(thread, null, stepFilters);
     }
 
     /**
-     * Steps into newly pushed frames.
-     *
+     * Create a step over request on the specified thread.
      * @param thread
-     *            the target thread.
-     * @param eventHub
-     *            the {@link IEventHub} instance.
-     * @return the new {@link Location} of the execution flow of the specified
-     *         thread.
+     *              the target thread.
+     * @param classFilters
+     *              restricts the step event to those matching the given class patterns when stepping.
+     * @param classExclusionFilters
+     *              restricts the step event to those not matching the given class patterns when stepping.
+     * @return the new step request.
      */
-    public static CompletableFuture<Location> stepInto(ThreadReference thread, IEventHub eventHub) {
-        return DebugUtility.step(thread, eventHub, StepRequest.STEP_LINE, StepRequest.STEP_INTO);
+    public static StepRequest createStepOverRequest(ThreadReference thread, String[] classFilters, String[] classExclusionFilters) {
+        return createStepRequest(thread, StepRequest.STEP_LINE, StepRequest.STEP_OVER, classFilters, classExclusionFilters);
     }
 
     /**
-     * Steps out of the current frame.
-     *
+     * Create a step into request on the specified thread.
      * @param thread
-     *            the target thread.
-     * @param eventHub
-     *            the {@link IEventHub} instance.
-     * @return the new {@link Location} of the execution flow of the specified
-     *         thread.
+     *              the target thread.
+     * @param stepFilters
+     *              the step filters when stepping.
+     * @return the new step request.
      */
-    public static CompletableFuture<Location> stepOut(ThreadReference thread, IEventHub eventHub) {
-        return DebugUtility.step(thread, eventHub, StepRequest.STEP_LINE, StepRequest.STEP_OUT);
+    public static StepRequest createStepIntoRequest(ThreadReference thread, String[] stepFilters) {
+        return createStepIntoRequest(thread, null, stepFilters);
     }
 
-    private static CompletableFuture<Location> step(ThreadReference thread, IEventHub eventHub, int stepSize,
-            int stepDepth) {
-        CompletableFuture<Location> future = new CompletableFuture<>();
+    /**
+     * Create a step into request on the specified thread.
+     * @param thread
+     *              the target thread.
+     * @param classFilters
+     *              restricts the step event to those matching the given class patterns when stepping.
+     * @param classExclusionFilters
+     *              restricts the step event to those not matching the given class patterns when stepping.
+     * @return the new step request.
+     */
+    public static StepRequest createStepIntoRequest(ThreadReference thread, String[] classFilters, String[] classExclusionFilters) {
+        return createStepRequest(thread, StepRequest.STEP_LINE, StepRequest.STEP_INTO, classFilters, classExclusionFilters);
+    }
+
+    /**
+     * Create a step out request on the specified thread.
+     * @param thread
+     *              the target thread.
+     * @param stepFilters
+     *              the step filters when stepping.
+     * @return the new step request.
+     */
+    public static StepRequest createStepOutRequest(ThreadReference thread, String[] stepFilters) {
+        return createStepOutRequest(thread, null, stepFilters);
+    }
 
-        StepRequest request = thread.virtualMachine().eventRequestManager().createStepRequest(thread, stepSize,
-                stepDepth);
+    /**
+     * Create a step out request on the specified thread.
+     * @param thread
+     *              the target thread.
+     * @param classFilters
+     *              restricts the step event to those matching the given class patterns when stepping.
+     * @param classExclusionFilters
+     *              restricts the step event to those not matching the given class patterns when stepping.
+     * @return the new step request.
+     */
+    public static StepRequest createStepOutRequest(ThreadReference thread, String[] classFilters, String[] classExclusionFilters) {
+        return createStepRequest(thread, StepRequest.STEP_LINE, StepRequest.STEP_OUT, classFilters, classExclusionFilters);
+    }
 
-        eventHub.stepEvents().filter(debugEvent -> request.equals(debugEvent.event.request())).take(1)
-                .subscribe(debugEvent -> {
-                    StepEvent event = (StepEvent) debugEvent.event;
-                    future.complete(event.location());
-                    thread.virtualMachine().eventRequestManager().deleteEventRequest(request);
-                });
+    private static StepRequest createStepRequest(ThreadReference thread, int stepSize, int stepDepth, String[] classFilters, String[] classExclusionFilters) {
+        StepRequest request = thread.virtualMachine().eventRequestManager().createStepRequest(thread, stepSize, stepDepth);
+        if (classFilters != null) {
+            for (String classFilter : classFilters) {
+                request.addClassFilter(classFilter);
+            }
+        }
+        if (classExclusionFilters != null) {
+            for (String exclusionFilter : classExclusionFilters) {
+                request.addClassExclusionFilter(exclusionFilter);
+            }
+        }
+        // Note: suspend policy will be set by the caller (StepRequestHandler) based on session settings
         request.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
         request.addCountFilter(1);
-        request.enable();
 
-        thread.resume();
+        return request;
+    }
+
+    /**
+     * Suspend the main thread when the program enters the main method of the specified main class.
+     * @param debugSession
+     *                  the debug session.
+     * @param mainClass
+     *                  the fully qualified name of the main class.
+     * @return
+     *        a {@link CompletableFuture} that contains the suspended main thread id.
+     */
+    public static CompletableFuture<Long> stopOnEntry(IDebugSession debugSession, String mainClass) {
+        CompletableFuture<Long> future = new CompletableFuture<>();
+
+        EventRequestManager manager = debugSession.getVM().eventRequestManager();
+        MethodEntryRequest request = manager.createMethodEntryRequest();
+        request.addClassFilter(mainClass);
+        request.setSuspendPolicy(debugSession.shouldSuspendAllThreads() ? EventRequest.SUSPEND_ALL : EventRequest.SUSPEND_EVENT_THREAD);
+
+        debugSession.getEventHub().events().filter(debugEvent -> {
+            return debugEvent.event instanceof MethodEntryEvent && request.equals(debugEvent.event.request());
+        }).subscribe(debugEvent -> {
+            Method method = ((MethodEntryEvent) debugEvent.event).method();
+            if (method.isPublic() && method.isStatic() && method.name().equals("main")
+                    && method.signature().equals("([Ljava/lang/String;)V")) {
+                deleteEventRequestSafely(debugSession.getVM().eventRequestManager(), request);
+                debugEvent.shouldResume = false;
+                ThreadReference bpThread = ((MethodEntryEvent) debugEvent.event).thread();
+                future.complete(bpThread.uniqueID());
+            }
+        });
+        request.enable();
 
         return future;
     }
@@ -192,7 +445,7 @@ private static CompletableFuture<Location> step(ThreadReference thread, IEventHu
      */
     public static ThreadReference getThread(IDebugSession debugSession, long threadId) {
         for (ThreadReference thread : getAllThreadsSafely(debugSession)) {
-            if (thread.uniqueID() == threadId && !thread.isCollected()) {
+            if (thread.uniqueID() == threadId) {
                 return thread;
             }
         }
@@ -209,7 +462,7 @@ public static ThreadReference getThread(IDebugSession debugSession, long threadI
     public static List<ThreadReference> getAllThreadsSafely(IDebugSession debugSession) {
         if (debugSession != null) {
             try {
-                return debugSession.allThreads();
+                return debugSession.getAllThreads();
             } catch (VMDisconnectedException ex) {
                 // do nothing.
             }
@@ -225,7 +478,7 @@ public static List<ThreadReference> getAllThreadsSafely(IDebugSession debugSessi
      */
     public static void resumeThread(ThreadReference thread) {
         // if thread is not found or is garbage collected, do nothing
-        if (thread == null || thread.isCollected()) {
+        if (thread == null) {
             return;
         }
         try {
@@ -242,4 +495,303 @@ public static void resumeThread(ThreadReference thread) {
             // the resume operation to this thread is meanness.
         }
     }
+
+    public static void resumeThread(ThreadReference thread, int resumeCount) {
+        if (thread == null) {
+            return;
+        }
+
+        try {
+            for (int i = 0; i < resumeCount; i++) {
+                /**
+                 * Invoking this method will decrement the count of pending suspends on this thread.
+                 * If it is decremented to 0, the thread will continue to execute.
+                 */
+                thread.resume();
+            }
+        } catch (ObjectCollectedException ex) {
+            // ObjectCollectionException can be thrown if the thread has already completed (exited) in the VM when calling suspendCount,
+            // the resume operation to this thread is meanness.
+        }
+    }
+
+    /**
+     * Remove the event request from the vm. If the vm has terminated, do nothing.
+     * @param eventManager
+     *                  The event request manager.
+     * @param request
+     *                  The target event request.
+     */
+    public static void deleteEventRequestSafely(EventRequestManager eventManager, EventRequest request) {
+        try {
+            eventManager.deleteEventRequest(request);
+        } catch (VMDisconnectedException ex) {
+            // ignore.
+        }
+    }
+
+    /**
+     * Remove the event request list from the vm. If the vm has terminated, do nothing.
+     * @param eventManager
+     *                  The event request manager.
+     * @param requests
+     *                  The target event request list.
+     */
+    public static void deleteEventRequestSafely(EventRequestManager eventManager, List<EventRequest> requests) {
+        try {
+            eventManager.deleteEventRequests(requests);
+        } catch (VMDisconnectedException ex) {
+            // ignore.
+        }
+    }
+
+    /**
+     * Encode an string array to a string as the follows.
+     *
+     * <p>source argument:
+     * <pre>["path=C:\\ProgramFiles\\java\\bin", "JAVA_HOME=C:\\ProgramFiles\\java"]</pre>
+     *
+     * <p>after encoded:
+     * <pre>"path%3DC%3A%5CProgramFiles%5Cjava%5Cbin\nJAVA_HOME%3DC%3A%5CProgramFiles%5Cjava"</pre>
+     *
+     * @param argument the string array arguments
+     * @return the encoded string
+     */
+    public static String encodeArrayArgument(String[] argument) {
+        if (argument == null) {
+            return null;
+        }
+
+        List<String> encodedArgs = new ArrayList<>();
+        for (String arg : argument) {
+            try {
+                encodedArgs.add(URLEncoder.encode(arg, StandardCharsets.UTF_8.name()));
+            } catch (UnsupportedEncodingException e) {
+                // do nothing.
+            }
+        }
+        return String.join("\n", encodedArgs);
+    }
+
+    /**
+     * Decode the encoded string to the original string array by the rules defined in encodeArrayArgument.
+     *
+     * @param argument the encoded string
+     * @return the original string array argument
+     */
+    public static String[] decodeArrayArgument(String argument) {
+        if (argument == null) {
+            return null;
+        }
+
+        List<String> result = new ArrayList<>();
+        String[] splits = argument.split("\n");
+        for (String split : splits) {
+            try {
+                result.add(URLDecoder.decode(split, StandardCharsets.UTF_8.name()));
+            } catch (UnsupportedEncodingException e) {
+                // do nothing.
+            }
+        }
+
+        return result.toArray(new String[0]);
+    }
+
+    /**
+     * Parses the given command line into separate arguments that can be passed
+     * to <code>Runtime.getRuntime().exec(cmdArray)</code>.
+     *
+     * @param cmdStr command line as a single string.
+     * @return the individual arguments.
+     */
+    public static List<String> parseArguments(String cmdStr) {
+        if (cmdStr == null) {
+            return new ArrayList<>();
+        }
+
+        return AdapterUtils.isWindows() ? parseArgumentsWindows(cmdStr) : parseArgumentsNonWindows(cmdStr);
+    }
+
+    /**
+     * Parses the given command line into separate arguments for mac/linux platform.
+     * This piece of code is mainly copied from
+     * https://github.com/eclipse/eclipse.platform.debug/blob/master/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java#L1374
+     *
+     * @param args
+     *            the command line arguments as a single string.
+     * @return the individual arguments
+     */
+    private static List<String> parseArgumentsNonWindows(String args) {
+        // man sh, see topic QUOTING
+        List<String> result = new ArrayList<>();
+
+        final int DEFAULT = 0;
+        final int ARG = 1;
+        final int IN_DOUBLE_QUOTE = 2;
+        final int IN_SINGLE_QUOTE = 3;
+
+        int state = DEFAULT;
+        StringBuilder buf = new StringBuilder();
+        int len = args.length();
+        for (int i = 0; i < len; i++) {
+            char ch = args.charAt(i);
+            if (Character.isWhitespace(ch)) {
+                if (state == DEFAULT) {
+                    // skip
+                    continue;
+                } else if (state == ARG) {
+                    state = DEFAULT;
+                    result.add(buf.toString());
+                    buf.setLength(0);
+                    continue;
+                }
+            }
+            switch (state) {
+                case DEFAULT:
+                case ARG:
+                    if (ch == '"') {
+                        state = IN_DOUBLE_QUOTE;
+                    } else if (ch == '\'') {
+                        state = IN_SINGLE_QUOTE;
+                    } else if (ch == '\\' && i + 1 < len) {
+                        state = ARG;
+                        ch = args.charAt(++i);
+                        buf.append(ch);
+                    } else {
+                        state = ARG;
+                        buf.append(ch);
+                    }
+                    break;
+
+                case IN_DOUBLE_QUOTE:
+                    if (ch == '"') {
+                        state = ARG;
+                    } else if (ch == '\\' && i + 1 < len && (args.charAt(i + 1) == '\\' || args.charAt(i + 1) == '"')) {
+                        ch = args.charAt(++i);
+                        buf.append(ch);
+                    } else {
+                        buf.append(ch);
+                    }
+                    break;
+
+                case IN_SINGLE_QUOTE:
+                    if (ch == '\'') {
+                        state = ARG;
+                    } else {
+                        buf.append(ch);
+                    }
+                    break;
+
+                default:
+                    throw new IllegalStateException();
+            }
+        }
+        if (buf.length() > 0 || state != DEFAULT) {
+            result.add(buf.toString());
+        }
+
+        return result;
+    }
+
+    /**
+     * Parses the given command line into separate arguments for windows platform.
+     * This piece of code is mainly copied from
+     * https://github.com/eclipse/eclipse.platform.debug/blob/master/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java#L1264
+     *
+     * @param args
+     *            the command line arguments as a single string.
+     * @return the individual arguments
+     */
+    private static List<String> parseArgumentsWindows(String args) {
+        // see http://msdn.microsoft.com/en-us/library/a1y7w461.aspx
+        List<String> result = new ArrayList<>();
+        final int DEFAULT = 0;
+        final int ARG = 1;
+        final int IN_DOUBLE_QUOTE = 2;
+
+        int state = DEFAULT;
+        int backslashes = 0;
+        StringBuilder buf = new StringBuilder();
+        int len = args.length();
+        for (int i = 0; i < len; i++) {
+            char ch = args.charAt(i);
+            if (ch == '\\') {
+                backslashes++;
+                continue;
+            } else if (backslashes != 0) {
+                if (ch == '"') {
+                    for (; backslashes >= 2; backslashes -= 2) {
+                        buf.append('\\');
+                    }
+                    if (backslashes == 1) {
+                        if (state == DEFAULT) {
+                            state = ARG;
+                        }
+                        buf.append('"');
+                        backslashes = 0;
+                        continue;
+                    } // else fall through to switch
+                } else {
+                    // false alarm, treat passed backslashes literally...
+                    if (state == DEFAULT) {
+                        state = ARG;
+                    }
+                    for (; backslashes > 0; backslashes--) {
+                        buf.append('\\');
+                    }
+                    // fall through to switch
+                }
+            }
+            if (Character.isWhitespace(ch)) {
+                if (state == DEFAULT) {
+                    // skip
+                    continue;
+                } else if (state == ARG) {
+                    state = DEFAULT;
+                    result.add(buf.toString());
+                    buf.setLength(0);
+                    continue;
+                }
+            }
+            switch (state) {
+                case DEFAULT:
+                case ARG:
+                    if (ch == '"') {
+                        state = IN_DOUBLE_QUOTE;
+                    } else {
+                        state = ARG;
+                        buf.append(ch);
+                    }
+                    break;
+
+                case IN_DOUBLE_QUOTE:
+                    if (ch == '"') {
+                        if (i + 1 < len && args.charAt(i + 1) == '"') {
+                            /* Undocumented feature in Windows:
+                             * Two consecutive double quotes inside a double-quoted argument are interpreted as
+                             * a single double quote.
+                             */
+                            buf.append('"');
+                            i++;
+                        } else if (buf.length() == 0) {
+                            // empty string on Windows platform. Account for bug in constructor of JDK's java.lang.ProcessImpl.
+                            result.add("\"\""); //$NON-NLS-1$
+                            state = DEFAULT;
+                        } else {
+                            state = ARG;
+                        }
+                    } else {
+                        buf.append(ch);
+                    }
+                    break;
+
+                default:
+                    throw new IllegalStateException();
+            }
+        }
+        if (buf.length() > 0 || state != DEFAULT) {
+            result.add(buf.toString());
+        }
+        return result;
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/EvaluatableBreakpoint.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/EvaluatableBreakpoint.java
new file mode 100644
index 000000000..d5a909f0b
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/EvaluatableBreakpoint.java
@@ -0,0 +1,128 @@
+/*******************************************************************************
+* Copyright (c) 2018-2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.VirtualMachine;
+import com.sun.jdi.event.ThreadDeathEvent;
+
+import io.reactivex.disposables.Disposable;
+
+public class EvaluatableBreakpoint extends Breakpoint implements IEvaluatableBreakpoint {
+    private IEventHub eventHub = null;
+    private Object compiledConditionalExpression = null;
+    private Object compiledLogpointExpression = null;
+    private Map<Long, Object> compiledExpressions = new ConcurrentHashMap<>();
+
+    EvaluatableBreakpoint(VirtualMachine vm, IEventHub eventHub, String className, int lineNumber, boolean suspendAllThreads) {
+        this(vm, eventHub, className, lineNumber, 0, null, suspendAllThreads);
+    }
+
+    EvaluatableBreakpoint(VirtualMachine vm, IEventHub eventHub, String className, int lineNumber, int hitCount, boolean suspendAllThreads) {
+        this(vm, eventHub, className, lineNumber, hitCount, null, suspendAllThreads);
+    }
+
+    EvaluatableBreakpoint(VirtualMachine vm, IEventHub eventHub, String className, int lineNumber, int hitCount,
+            String condition, boolean suspendAllThreads) {
+        this(vm, eventHub, className, lineNumber, hitCount, condition, null, suspendAllThreads);
+    }
+
+    EvaluatableBreakpoint(VirtualMachine vm, IEventHub eventHub, String className, int lineNumber, int hitCount,
+            String condition, String logMessage, boolean suspendAllThreads) {
+        super(vm, eventHub, className, lineNumber, hitCount, condition, logMessage, suspendAllThreads);
+        this.eventHub = eventHub;
+    }
+
+    EvaluatableBreakpoint(VirtualMachine vm, IEventHub eventHub, JavaBreakpointLocation sourceLocation, int hitCount,
+        String condition, String logMessage, boolean suspendAllThreads) {
+        super(vm, eventHub, sourceLocation, hitCount, condition, logMessage, suspendAllThreads);
+        this.eventHub = eventHub;
+    }
+
+    @Override
+    public boolean containsEvaluatableExpression() {
+        return containsConditionalExpression() || containsLogpointExpression();
+    }
+
+    @Override
+    public boolean containsConditionalExpression() {
+        return StringUtils.isNotBlank(getCondition());
+    }
+
+    @Override
+    public boolean containsLogpointExpression() {
+        return StringUtils.isNotBlank(getLogMessage());
+    }
+
+    @Override
+    public void setCompiledConditionalExpression(Object compiledExpression) {
+        this.compiledConditionalExpression = compiledExpression;
+    }
+
+    @Override
+    public Object getCompiledConditionalExpression() {
+        return compiledConditionalExpression;
+    }
+
+    @Override
+    public void setCompiledLogpointExpression(Object compiledExpression) {
+        this.compiledLogpointExpression = compiledExpression;
+    }
+
+    @Override
+    public Object getCompiledLogpointExpression() {
+        return compiledLogpointExpression;
+    }
+
+    @Override
+    public void setCondition(String condition) {
+        super.setCondition(condition);
+        setCompiledConditionalExpression(null);
+        compiledExpressions.clear();
+    }
+
+    @Override
+    public void setLogMessage(String logMessage) {
+        super.setLogMessage(logMessage);
+        setCompiledLogpointExpression(null);
+        compiledExpressions.clear();
+    }
+
+    @Override
+    public Object getCompiledExpression(long threadId) {
+        return compiledExpressions.get(threadId);
+    }
+
+    @Override
+    public void setCompiledExpression(long threadId, Object compiledExpression) {
+        compiledExpressions.put(threadId, compiledExpression);
+    }
+
+    @Override
+    public CompletableFuture<IBreakpoint> install() {
+        Disposable subscription = eventHub.events()
+            .filter(debugEvent -> debugEvent.event instanceof ThreadDeathEvent)
+            .subscribe(debugEvent -> {
+                ThreadReference deathThread = ((ThreadDeathEvent) debugEvent.event).thread();
+                compiledExpressions.remove(deathThread.uniqueID());
+            });
+        super.subscriptions().add(subscription);
+
+        return super.install();
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/EventHub.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/EventHub.java
index db7f8934f..712ed03ba 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/EventHub.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/EventHub.java
@@ -74,6 +74,7 @@ public void start(VirtualMachine vm) {
                         }
                         DebugEvent dbgEvent = new DebugEvent();
                         dbgEvent.event = event;
+                        dbgEvent.eventSet = set;
                         subject.onNext(dbgEvent);
                         shouldResume &= dbgEvent.shouldResume;
                     }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IBreakpoint.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IBreakpoint.java
index 496de82c7..ec3ea818a 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IBreakpoint.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IBreakpoint.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -14,11 +14,24 @@
 import java.util.concurrent.CompletableFuture;
 
 public interface IBreakpoint extends IDebugResource {
+
+    String REQUEST_TYPE = "request_type";
+
+    int REQUEST_TYPE_LINE = 0;
+
+    int REQUEST_TYPE_METHOD = 1;
+
+    int REQUEST_TYPE_LAMBDA = 2;
+
+    JavaBreakpointLocation sourceLocation();
+
     String className();
 
-    int lineNumber();
+    int getLineNumber();
 
-    int hitCount();
+    int getColumnNumber();
+
+    int getHitCount();
 
     void setHitCount(int hitCount);
 
@@ -27,4 +40,26 @@ public interface IBreakpoint extends IDebugResource {
     void putProperty(Object key, Object value);
 
     Object getProperty(Object key);
+
+    String getCondition();
+
+    void setCondition(String condition);
+
+    String getLogMessage();
+
+    void setLogMessage(String logMessage);
+
+    default void setAsync(boolean async) {
+    }
+
+    default boolean async() {
+        return false;
+    }
+
+    default void setSuspendPolicy(String policy) {
+    }
+
+    default String getSuspendPolicy() {
+        return null;
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IDebugSession.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IDebugSession.java
index 03e2f98ec..afc2283f0 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IDebugSession.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IDebugSession.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -14,6 +14,7 @@
 import java.util.List;
 
 import com.sun.jdi.ThreadReference;
+import com.sun.jdi.VirtualMachine;
 
 public interface IDebugSession {
     void start();
@@ -27,18 +28,34 @@ public interface IDebugSession {
     void terminate();
 
     // breakpoints
-    IBreakpoint createBreakpoint(String className, int lineNumber);
+    IBreakpoint createBreakpoint(String className, int lineNumber, int hitCount, String condition, String logMessage);
 
-    IBreakpoint createBreakpoint(String className, int lineNumber, int hitCount);
+    IBreakpoint createBreakpoint(JavaBreakpointLocation sourceLocation, int hitCount, String condition, String logMessage);
+
+    IWatchpoint createWatchPoint(String className, String fieldName, String accessType, String condition, int hitCount);
 
     void setExceptionBreakpoints(boolean notifyCaught, boolean notifyUncaught);
 
-    // TODO: createFunctionBreakpoint
+    void setExceptionBreakpoints(boolean notifyCaught, boolean notifyUncaught, String[] classFilters, String[] classExclusionFilters);
+
+    void setExceptionBreakpoints(boolean notifyCaught, boolean notifyUncaught, String[] exceptionTypes, String[] classFilters, String[] classExclusionFilters);
+
+    void setExceptionBreakpoints(boolean notifyCaught, boolean notifyUncaught, String[] exceptionTypes, String[] classFilters, String[] classExclusionFilters,
+        boolean async);
+
+    IMethodBreakpoint createFunctionBreakpoint(String className, String functionName, String condition, int hitCount);
 
     Process process();
 
-    List<ThreadReference> allThreads();
+    List<ThreadReference> getAllThreads();
 
-    IEventHub eventHub();
-}
+    IEventHub getEventHub();
+
+    VirtualMachine getVM();
 
+    /**
+     * Returns whether breakpoints should suspend all threads or just the event thread.
+     * This value is captured at session start and persists for the session lifetime.
+     */
+    boolean shouldSuspendAllThreads();
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IEvaluatableBreakpoint.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IEvaluatableBreakpoint.java
new file mode 100644
index 000000000..16d8904c9
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IEvaluatableBreakpoint.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+* Copyright (c) 2018 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+public interface IEvaluatableBreakpoint {
+    boolean containsEvaluatableExpression();
+
+    boolean containsConditionalExpression();
+
+    boolean containsLogpointExpression();
+
+    String getCondition();
+
+    void setCondition(String condition);
+
+    String getLogMessage();
+
+    void setLogMessage(String logMessage);
+
+    /**
+     * please use {@link #setCompiledExpression(long, Object)} instead.
+     */
+    @Deprecated
+    void setCompiledConditionalExpression(Object compiledExpression);
+
+    /**
+     * please use {@link #getCompiledExpression(long)} instead.
+     */
+    @Deprecated
+    Object getCompiledConditionalExpression();
+
+    /**
+     * please use {@link #setCompiledExpression(long, Object)} instead.
+     */
+    @Deprecated
+    void setCompiledLogpointExpression(Object compiledExpression);
+
+    /**
+     * please use {@link #getCompiledExpression(long)} instead.
+     */
+    @Deprecated
+    Object getCompiledLogpointExpression();
+
+    /**
+     * Sets the compiled expression for a thread.
+     *
+     * @param threadId - thread the breakpoint is hit in
+     * @param compiledExpression - associated compiled expression
+     */
+    void setCompiledExpression(long threadId, Object compiledExpression);
+
+    /**
+     * Returns existing compiled expression for the given thread or
+     * <code>null</code>.
+     *
+     * @param threadId thread the breakpoint was hit in
+     * @return compiled expression or <code>null</code>
+     */
+    Object getCompiledExpression(long threadId);
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IMethodBreakpoint.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IMethodBreakpoint.java
new file mode 100644
index 000000000..68f9539c8
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IMethodBreakpoint.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Gayan Perera - initial API and implementation
+*******************************************************************************/
+package com.microsoft.java.debug.core;
+
+import java.util.concurrent.CompletableFuture;
+
+public interface IMethodBreakpoint extends IDebugResource {
+    String methodName();
+
+    String className();
+
+    int getHitCount();
+
+    String getCondition();
+
+    void setHitCount(int hitCount);
+
+    void setCondition(String condition);
+
+    CompletableFuture<IMethodBreakpoint> install();
+
+    Object getProperty(Object key);
+
+    void putProperty(Object key, Object value);
+
+    default void setAsync(boolean async) {
+    }
+
+    default boolean async() {
+        return false;
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IWatchpoint.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IWatchpoint.java
new file mode 100644
index 000000000..a3a29a851
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/IWatchpoint.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+* Copyright (c) 2019 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+import java.util.concurrent.CompletableFuture;
+
+public interface IWatchpoint extends IDebugResource {
+    String className();
+
+    String fieldName();
+
+    String accessType();
+
+    CompletableFuture<IWatchpoint> install();
+
+    void putProperty(Object key, Object value);
+
+    Object getProperty(Object key);
+
+    int getHitCount();
+
+    void setHitCount(int hitCount);
+
+    String getCondition();
+
+    void setCondition(String condition);
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/JavaBreakpointLocation.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/JavaBreakpointLocation.java
new file mode 100644
index 000000000..3dbc1a24d
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/JavaBreakpointLocation.java
@@ -0,0 +1,125 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+import java.util.Objects;
+
+import com.microsoft.java.debug.core.protocol.Types;
+
+public class JavaBreakpointLocation {
+    /**
+     * The line number in the source file.
+     */
+    private int lineNumberInSourceFile = Integer.MIN_VALUE;
+    /**
+     * The line number in the class file.
+     */
+    private int lineNumber;
+    /**
+     * The source column of the breakpoint.
+     */
+    private int columnNumber = -1;
+    /**
+     * The declaring class name that encloses the target position.
+     */
+    private String className;
+    /**
+     * The method name and signature when the target position
+     * points to a method declaration.
+     */
+    private String methodName;
+    private String methodSignature;
+    /**
+     * All possible locations for source breakpoints in a given range.
+     */
+    private Types.BreakpointLocation[] availableBreakpointLocations = new Types.BreakpointLocation[0];
+
+    public JavaBreakpointLocation(int lineNumber, int columnNumber) {
+        this.lineNumber = lineNumber;
+        this.columnNumber = columnNumber;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(lineNumber, columnNumber, className, methodName, methodSignature);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof JavaBreakpointLocation)) {
+            return false;
+        }
+        JavaBreakpointLocation other = (JavaBreakpointLocation) obj;
+        return lineNumber == other.lineNumber && columnNumber == other.columnNumber
+                && Objects.equals(className, other.className) && Objects.equals(methodName, other.methodName)
+                && Objects.equals(methodSignature, other.methodSignature);
+    }
+
+    public int lineNumber() {
+        return lineNumber;
+    }
+
+    public void setLineNumber(int lineNumber) {
+        this.lineNumber = lineNumber;
+    }
+
+    public int columnNumber() {
+        return columnNumber;
+    }
+
+    public void setColumnNumber(int columnNumber) {
+        this.columnNumber = columnNumber;
+    }
+
+    public String className() {
+        return className;
+    }
+
+    public void setClassName(String className) {
+        this.className = className;
+    }
+
+    public String methodName() {
+        return methodName;
+    }
+
+    public void setMethodName(String methodName) {
+        this.methodName = methodName;
+    }
+
+    public String methodSignature() {
+        return methodSignature;
+    }
+
+    public void setMethodSignature(String methodSignature) {
+        this.methodSignature = methodSignature;
+    }
+
+    public Types.BreakpointLocation[] availableBreakpointLocations() {
+        return availableBreakpointLocations;
+    }
+
+    public void setAvailableBreakpointLocations(Types.BreakpointLocation[] availableBreakpointLocations) {
+        this.availableBreakpointLocations = availableBreakpointLocations;
+    }
+
+    public int lineNumberInSourceFile() {
+        return lineNumberInSourceFile == Integer.MIN_VALUE ? lineNumber : lineNumberInSourceFile;
+    }
+
+    public void setLineNumberInSourceFile(int lineNumberInSourceFile) {
+        this.lineNumberInSourceFile = lineNumberInSourceFile;
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/JdiExceptionReference.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/JdiExceptionReference.java
new file mode 100644
index 000000000..0bdd142a3
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/JdiExceptionReference.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+* Copyright (c) 2019 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+import com.sun.jdi.ObjectReference;
+
+public class JdiExceptionReference {
+    public ObjectReference exception;
+    public boolean isUncaught;
+
+    public JdiExceptionReference(ObjectReference exception, boolean isUncaught) {
+        this.exception = exception;
+        this.isUncaught = isUncaught;
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/JdiMethodResult.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/JdiMethodResult.java
new file mode 100644
index 000000000..715e23622
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/JdiMethodResult.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+* Copyright (c) 2020 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+import com.sun.jdi.Method;
+import com.sun.jdi.Value;
+
+public class JdiMethodResult {
+    public Method method;
+    public Value value;
+
+    public JdiMethodResult(Method method, Value value) {
+        this.method = method;
+        this.value = value;
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/LaunchException.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/LaunchException.java
new file mode 100644
index 000000000..6c1e1a513
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/LaunchException.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+* Copyright (c) 2018-2021 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+import com.sun.jdi.connect.VMStartException;
+
+/**
+ * Extends {@link VMStartException} to provide more detail about the failed process
+ * from before it is destroyed.
+ */
+public class LaunchException extends VMStartException {
+
+    boolean exited;
+    int exitStatus;
+    String stdout;
+    String stderr;
+
+    public LaunchException(String message, Process process, boolean exited, int exitStatus, String stdout, String stderr) {
+        super(message, process);
+        this.exited = exited;
+        this.exitStatus = exitStatus;
+        this.stdout = stdout;
+        this.stderr = stderr;
+    }
+
+    public boolean isExited() {
+        return exited;
+    }
+
+    public int getExitStatus() {
+        return exitStatus;
+    }
+
+    public String getStdout() {
+        return stdout;
+    }
+
+    public String getStderr() {
+        return stderr;
+    }
+
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/MethodBreakpoint.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/MethodBreakpoint.java
new file mode 100644
index 000000000..bc46fd96f
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/MethodBreakpoint.java
@@ -0,0 +1,296 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Gayan Perera - initial API and implementation
+*******************************************************************************/
+package com.microsoft.java.debug.core;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.VMDisconnectedException;
+import com.sun.jdi.VirtualMachine;
+import com.sun.jdi.event.ClassPrepareEvent;
+import com.sun.jdi.event.ThreadDeathEvent;
+import com.sun.jdi.request.ClassPrepareRequest;
+import com.sun.jdi.request.EventRequest;
+import com.sun.jdi.request.MethodEntryRequest;
+
+import io.reactivex.Observable;
+import io.reactivex.disposables.Disposable;
+
+public class MethodBreakpoint implements IMethodBreakpoint, IEvaluatableBreakpoint {
+
+    private VirtualMachine vm;
+    private IEventHub eventHub;
+    private String className;
+    private String functionName;
+    private String condition;
+    private int hitCount;
+    private boolean async = false;
+    private final boolean suspendAllThreads;
+
+    private HashMap<Object, Object> propertyMap = new HashMap<>();
+    private Object compiledConditionalExpression = null;
+    private Map<Long, Object> compiledExpressions = new ConcurrentHashMap<>();
+
+    private List<EventRequest> requests = Collections.synchronizedList(new ArrayList<>());
+    private List<Disposable> subscriptions = new ArrayList<>();
+
+    public MethodBreakpoint(VirtualMachine vm, IEventHub eventHub, String className, String functionName,
+            String condition, int hitCount, boolean suspendAllThreads) {
+        Objects.requireNonNull(vm);
+        Objects.requireNonNull(eventHub);
+        Objects.requireNonNull(className);
+        Objects.requireNonNull(functionName);
+        this.vm = vm;
+        this.eventHub = eventHub;
+        this.className = className;
+        this.functionName = functionName;
+        this.condition = condition;
+        this.hitCount = hitCount;
+        this.suspendAllThreads = suspendAllThreads;
+    }
+
+    @Override
+    public List<EventRequest> requests() {
+        return requests;
+    }
+
+    @Override
+    public List<Disposable> subscriptions() {
+        return subscriptions;
+    }
+
+    @Override
+    public void close() throws Exception {
+        try {
+            vm.eventRequestManager().deleteEventRequests(requests());
+        } catch (VMDisconnectedException ex) {
+            // ignore since removing breakpoints is meaningless when JVM is terminated.
+        }
+        subscriptions().forEach(Disposable::dispose);
+        requests.clear();
+        subscriptions.clear();
+    }
+
+    @Override
+    public boolean containsEvaluatableExpression() {
+        return containsConditionalExpression() || containsLogpointExpression();
+    }
+
+    @Override
+    public boolean containsConditionalExpression() {
+        return StringUtils.isNotBlank(getCondition());
+    }
+
+    @Override
+    public boolean containsLogpointExpression() {
+        return false;
+    }
+
+    @Override
+    public String getCondition() {
+        return condition;
+    }
+
+    @Override
+    public void setCondition(String condition) {
+        this.condition = condition;
+        setCompiledConditionalExpression(null);
+        compiledExpressions.clear();
+    }
+
+    @Override
+    public String getLogMessage() {
+        return null;
+    }
+
+    @Override
+    public void setLogMessage(String logMessage) {
+        // for future implementation
+    }
+
+    @Override
+    public void setCompiledConditionalExpression(Object compiledExpression) {
+        this.compiledConditionalExpression = compiledExpression;
+    }
+
+    @Override
+    public Object getCompiledConditionalExpression() {
+        return compiledConditionalExpression;
+    }
+
+    @Override
+    public void setCompiledLogpointExpression(Object compiledExpression) {
+        // for future implementation
+    }
+
+    @Override
+    public Object getCompiledLogpointExpression() {
+        return null;
+    }
+
+    @Override
+    public void setCompiledExpression(long threadId, Object compiledExpression) {
+        compiledExpressions.put(threadId, compiledExpression);
+    }
+
+    @Override
+    public Object getCompiledExpression(long threadId) {
+        return compiledExpressions.get(threadId);
+    }
+
+    @Override
+    public int getHitCount() {
+        return hitCount;
+    }
+
+    @Override
+    public void setHitCount(int hitCount) {
+        this.hitCount = hitCount;
+        Observable.fromIterable(this.requests())
+                .filter(request -> request instanceof MethodEntryRequest)
+                .subscribe(request -> {
+                    request.addCountFilter(hitCount);
+                    request.enable();
+                });
+    }
+
+    @Override
+    public boolean async() {
+        return this.async;
+    }
+
+    @Override
+    public void setAsync(boolean async) {
+        this.async = async;
+    }
+
+    @Override
+    public CompletableFuture<IMethodBreakpoint> install() {
+        Disposable subscription = eventHub.events()
+                .filter(debugEvent -> debugEvent.event instanceof ThreadDeathEvent)
+                .subscribe(debugEvent -> {
+                    ThreadReference deathThread = ((ThreadDeathEvent) debugEvent.event).thread();
+                    compiledExpressions.remove(deathThread.uniqueID());
+                });
+
+        subscriptions.add(subscription);
+
+        // It's possible that different class loaders create new class with the same
+        // name.
+        // Here to listen to future class prepare events to handle such case.
+        ClassPrepareRequest classPrepareRequest = vm.eventRequestManager().createClassPrepareRequest();
+        classPrepareRequest.addClassFilter(className);
+        classPrepareRequest.enable();
+        requests.add(classPrepareRequest);
+
+        CompletableFuture<IMethodBreakpoint> future = new CompletableFuture<>();
+        subscription = eventHub.events()
+                .filter(debugEvent -> debugEvent.event instanceof ClassPrepareEvent
+                        && (classPrepareRequest.equals(debugEvent.event.request())))
+                .subscribe(debugEvent -> {
+                    ClassPrepareEvent event = (ClassPrepareEvent) debugEvent.event;
+                    Optional<MethodEntryRequest> createdRequest = AsyncJdwpUtils.await(
+                        createMethodEntryRequest(event.referenceType())
+                    );
+                    if (createdRequest.isPresent()) {
+                        MethodEntryRequest methodEntryRequest = createdRequest.get();
+                        requests.add(methodEntryRequest);
+                        if (!future.isDone()) {
+                            this.putProperty("verified", true);
+                            future.complete(this);
+                        }
+                    }
+                });
+        subscriptions.add(subscription);
+
+        Runnable createRequestsFromLoadedClasses = () -> {
+            List<ReferenceType> types = vm.classesByName(className);
+            for (ReferenceType type : types) {
+                createMethodEntryRequest(type).whenComplete((createdRequest, ex) -> {
+                    if (ex != null) {
+                        return;
+                    }
+
+                    if (createdRequest.isPresent()) {
+                        MethodEntryRequest methodEntryRequest = createdRequest.get();
+                        requests.add(methodEntryRequest);
+                        if (!future.isDone()) {
+                            this.putProperty("verified", true);
+                            future.complete(this);
+                        }
+                    }
+                });
+            }
+        };
+
+        if (async()) {
+            AsyncJdwpUtils.runAsync(createRequestsFromLoadedClasses);
+        } else {
+            createRequestsFromLoadedClasses.run();
+        }
+
+        return future;
+    }
+
+    private CompletableFuture<Optional<MethodEntryRequest>> createMethodEntryRequest(ReferenceType type) {
+        if (async()) {
+            return CompletableFuture.supplyAsync(() -> createMethodEntryRequest0(type));
+        } else {
+            return CompletableFuture.completedFuture(createMethodEntryRequest0(type));
+        }
+    }
+
+    private Optional<MethodEntryRequest> createMethodEntryRequest0(ReferenceType type) {
+        return type.methodsByName(functionName).stream().findFirst().map(method -> {
+            MethodEntryRequest request = vm.eventRequestManager().createMethodEntryRequest();
+
+            request.addClassFilter(type);
+            request.setSuspendPolicy(suspendAllThreads ? EventRequest.SUSPEND_ALL : EventRequest.SUSPEND_EVENT_THREAD);
+            if (hitCount > 0) {
+                request.addCountFilter(hitCount);
+            }
+            request.enable();
+            return request;
+        });
+    }
+
+    @Override
+    public Object getProperty(Object key) {
+        return propertyMap.get(key);
+    }
+
+    @Override
+    public void putProperty(Object key, Object value) {
+        propertyMap.put(key, value);
+    }
+
+    @Override
+    public String methodName() {
+        return functionName;
+    }
+
+    @Override
+    public String className() {
+        return className;
+    }
+
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/StackFrameUtility.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/StackFrameUtility.java
new file mode 100644
index 000000000..3195747f3
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/StackFrameUtility.java
@@ -0,0 +1,78 @@
+/*******************************************************************************
+* Copyright (c) 2017 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+import com.sun.jdi.AbsentInformationException;
+import com.sun.jdi.IncompatibleThreadStateException;
+import com.sun.jdi.InvalidStackFrameException;
+import com.sun.jdi.NativeMethodException;
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.StackFrame;
+
+public final class StackFrameUtility {
+
+    public static boolean isNative(StackFrame frame) {
+        return frame.location().method().isNative();
+    }
+
+    /**
+     * Pop a StackFrame from its thread.
+     *
+     * @param frame
+     *            the StackFrame will be popped
+     */
+    public static void pop(StackFrame frame) throws DebugException {
+        try {
+            frame.thread().popFrames(frame);
+        } catch (IncompatibleThreadStateException e) {
+            throw new DebugException(String.format("%s occurred popping stack frame.", e.getMessage()), e);
+        } catch (InvalidStackFrameException e) {
+            throw new DebugException("Cannot pop up the top stack farme.", e);
+        } catch (NativeMethodException e) {
+            throw new DebugException("Cannot pop up the stack frame because it is not valid for a native method.", e);
+        } catch (RuntimeException e) {
+            throw new DebugException(String.format("Runtime exception happened: %s", e.getMessage()), e);
+        }
+    }
+
+    public static String getName(StackFrame frame) {
+        return frame.location().method().name();
+    }
+
+    public static String getSignature(StackFrame frame) {
+        return frame.location().method().signature();
+    }
+
+    public static boolean isObsolete(StackFrame frame) {
+        return frame.location().method().isObsolete();
+    }
+
+    /**
+     * Get the StackFrame associated source file path.
+     *
+     * @param frame
+     *            StackFrame for the source path
+     * @return the source file path
+     */
+    public static String getSourcePath(StackFrame frame) {
+        try {
+            return frame.location().sourcePath();
+        } catch (AbsentInformationException e) {
+            // Ignore it
+        }
+        return null;
+    }
+
+    public static ReferenceType getDeclaringType(StackFrame frame) {
+        return frame.location().method().declaringType();
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/UsageDataSession.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/UsageDataSession.java
index ce4bbfda9..b645e2843 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/UsageDataSession.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/UsageDataSession.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -12,6 +12,7 @@
 package com.microsoft.java.debug.core;
 
 import java.util.ArrayList;
+import java.util.Formatter;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -21,9 +22,10 @@
 
 import com.google.gson.JsonElement;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
-import com.microsoft.java.debug.core.adapter.JsonUtils;
-import com.microsoft.java.debug.core.adapter.Messages.Request;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.protocol.JsonUtils;
+import com.microsoft.java.debug.core.protocol.Messages.Request;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
 import com.sun.jdi.event.Event;
 
 public class UsageDataSession {
@@ -31,6 +33,7 @@ public class UsageDataSession {
     private static final Logger usageDataLogger = Logger.getLogger(Configuration.USAGE_DATA_LOGGER_NAME);
     private static final long RESPONSE_MAX_DELAY_MS = 1000;
     private static final ThreadLocal<UsageDataSession> threadLocal = new InheritableThreadLocal<>();
+    private static final boolean TRACE_DAP_PERF = Boolean.getBoolean("debug.dap.perf");
 
     private final String sessionGuid = UUID.randomUUID().toString();
     private boolean jdiEventSequenceEnabled = false;
@@ -39,10 +42,13 @@ public class UsageDataSession {
     private Map<String, Integer> commandCountMap = new HashMap<>();
     private Map<String, Integer> breakpointCountMap = new HashMap<>();
     private Map<Integer, RequestEvent> requestEventMap = new HashMap<>();
+    private Map<String, Integer> userErrorCount = new HashMap<>();
+    private Map<String, Integer> commandPerfCountMap = new HashMap<>();
     private List<String> eventList = new ArrayList<>();
+    private List<String[]> dapPerf = new ArrayList<>();
 
     public static String getSessionGuid() {
-        return threadLocal.get().sessionGuid;
+        return threadLocal.get() == null ? "" : threadLocal.get().sessionGuid;
     }
 
     public UsageDataSession() {
@@ -112,6 +118,13 @@ public void recordResponse(Response response) {
                 requestEventMap.remove(response.request_seq);
             }
             long duration = responseMillis - requestMillis;
+            commandPerfCountMap.compute(command, (k, v) -> (v == null ? 0 : v.intValue()) + (int) duration);
+
+            if (TRACE_DAP_PERF) {
+                synchronized (dapPerf) {
+                    dapPerf.add(new String[]{command, String.valueOf(duration)});
+                }
+            }
 
             if (!response.success || duration > RESPONSE_MAX_DELAY_MS) {
                 Map<String, Object> props = new HashMap<>();
@@ -136,10 +149,26 @@ public void submitUsageData() {
         props.put("sessionStopAt", String.valueOf(stopAt));
         props.put("commandCount", JsonUtils.toJson(commandCountMap));
         props.put("breakpointCount", JsonUtils.toJson(breakpointCountMap));
+        props.put("userErrorCount", JsonUtils.toJson(userErrorCount));
+        props.put("commandPerfCount", JsonUtils.toJson(commandPerfCountMap));
         if (jdiEventSequenceEnabled) {
-            props.put("jdiEventSequence", JsonUtils.toJson(eventList));
+            synchronized (eventList) {
+                props.put("jdiEventSequence", JsonUtils.toJson(eventList));
+            }
         }
         usageDataLogger.log(Level.INFO, "session usage data summary", props);
+
+        if (TRACE_DAP_PERF) {
+            Formatter fmt = new Formatter();
+            fmt.format("\nDAP Performance Metrics:\n");
+            fmt.format("%30s %10s(ms)\n", "Request", "Duration");
+            synchronized (dapPerf) {
+                dapPerf.forEach((event) -> {
+                    fmt.format("%30s %14s\n", event[0], event[1]);
+                });
+            }
+            logger.info(String.valueOf(fmt));
+        }
     }
 
     /**
@@ -152,13 +181,37 @@ public static void recordEvent(Event event) {
                 Map<String, String> eventEntry = new HashMap<>();
                 eventEntry.put("timestamp", String.valueOf(System.currentTimeMillis()));
                 eventEntry.put("event", event.toString());
-                currentSession.eventList.add(JsonUtils.toJson(eventEntry));
+                synchronized (currentSession.eventList) {
+                    currentSession.eventList.add(JsonUtils.toJson(eventEntry));
+                }
             }
         } catch (Exception e) {
             logger.log(Level.SEVERE, String.format("Exception on recording event: %s.", e.toString()), e);
         }
     }
 
+    public static void recordInfo(String key, Object value) {
+        Map<String, Object> map = new HashMap<>();
+        map.put(key, value);
+        usageDataLogger.log(Level.INFO, "session info", map);
+    }
+
+    public static void recordInfo(String description, Map<String, Object> data) {
+        usageDataLogger.log(Level.INFO, description, data);
+    }
+
+    /**
+     * Record counts for each user errors encountered.
+     */
+    public void recordUserError(ErrorCode errorCode) {
+        try {
+            String errorCodeStr = errorCode.name();
+            userErrorCount.put(errorCodeStr, userErrorCount.getOrDefault(errorCodeStr, 0) + 1);
+        } catch (Exception e) {
+            logger.log(Level.SEVERE, String.format("Exception on recording user error: %s.", e.toString()), e);
+        }
+    }
+
     /**
      * Enable JDI event sequence track in current session.
      */
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/UsageDataStore.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/UsageDataStore.java
index 56b55447c..fdc2505ad 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/UsageDataStore.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/UsageDataStore.java
@@ -16,7 +16,7 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentLinkedQueue;
 
-import com.microsoft.java.debug.core.adapter.JsonUtils;
+import com.microsoft.java.debug.core.protocol.JsonUtils;
 
 public class UsageDataStore {
     private ConcurrentLinkedQueue<Object> queue;
@@ -40,7 +40,7 @@ private static final class SingletonHolder {
     }
 
     /**
-     * Fetch all pending user data records
+     * Fetch all pending user data records.
      * @return List of user data Object.
      */
     public synchronized Object[] fetchAll() {
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/Watchpoint.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/Watchpoint.java
new file mode 100644
index 000000000..fdb2354a9
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/Watchpoint.java
@@ -0,0 +1,279 @@
+/*******************************************************************************
+* Copyright (c) 2019 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.sun.jdi.Field;
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.VMDisconnectedException;
+import com.sun.jdi.VirtualMachine;
+import com.sun.jdi.event.ClassPrepareEvent;
+import com.sun.jdi.event.ThreadDeathEvent;
+import com.sun.jdi.request.ClassPrepareRequest;
+import com.sun.jdi.request.EventRequest;
+import com.sun.jdi.request.WatchpointRequest;
+
+import io.reactivex.Observable;
+import io.reactivex.disposables.Disposable;
+
+public class Watchpoint implements IWatchpoint, IEvaluatableBreakpoint {
+    private final VirtualMachine vm;
+    private final IEventHub eventHub;
+    private final String className;
+    private final String fieldName;
+    private String accessType = null;
+    private String condition = null;
+    private int hitCount;
+    private HashMap<Object, Object> propertyMap = new HashMap<>();
+    private Object compiledConditionalExpression = null;
+    private Map<Long, Object> compiledExpressions = new ConcurrentHashMap<>();
+    private final boolean suspendAllThreads;
+
+    // IDebugResource
+    private List<EventRequest> requests = new ArrayList<>();
+    private List<Disposable> subscriptions = new ArrayList<>();
+
+    Watchpoint(VirtualMachine vm, IEventHub eventHub, String className, String fieldName, boolean suspendAllThreads) {
+        this(vm, eventHub, className, fieldName, "write", suspendAllThreads);
+    }
+
+    Watchpoint(VirtualMachine vm, IEventHub eventHub, String className, String fieldName, String accessType, boolean suspendAllThreads) {
+        this(vm, eventHub, className, fieldName, accessType, null, 0, suspendAllThreads);
+    }
+
+    Watchpoint(VirtualMachine vm, IEventHub eventHub, String className, String fieldName, String accessType,
+            String condition, int hitCount, boolean suspendAllThreads) {
+        Objects.requireNonNull(vm);
+        Objects.requireNonNull(eventHub);
+        Objects.requireNonNull(className);
+        Objects.requireNonNull(fieldName);
+        this.vm = vm;
+        this.eventHub = eventHub;
+        this.className = className;
+        this.fieldName = fieldName;
+        this.accessType = accessType;
+        this.condition = condition;
+        this.hitCount = hitCount;
+        this.suspendAllThreads = suspendAllThreads;
+    }
+
+    @Override
+    public List<EventRequest> requests() {
+        return requests;
+    }
+
+    @Override
+    public List<Disposable> subscriptions() {
+        return subscriptions;
+    }
+
+    @Override
+    public void close() throws Exception {
+        try {
+            vm.eventRequestManager().deleteEventRequests(requests());
+        } catch (VMDisconnectedException ex) {
+            // ignore since removing breakpoints is meaningless when JVM is terminated.
+        }
+        subscriptions().forEach(subscription -> {
+            subscription.dispose();
+        });
+        requests.clear();
+        subscriptions.clear();
+    }
+
+    @Override
+    public String className() {
+        return className;
+    }
+
+    @Override
+    public String fieldName() {
+        return fieldName;
+    }
+
+    @Override
+    public String accessType() {
+        return accessType;
+    }
+
+    @Override
+    public String getCondition() {
+        return condition;
+    }
+
+    @Override
+    public void setCondition(String condition) {
+        this.condition = condition;
+        setCompiledConditionalExpression(null);
+        compiledExpressions.clear();
+    }
+
+    @Override
+    public int getHitCount() {
+        return hitCount;
+    }
+
+    @Override
+    public void setHitCount(int hitCount) {
+        this.hitCount = hitCount;
+
+        Observable.fromIterable(this.requests())
+            .filter(request -> request instanceof WatchpointRequest)
+            .subscribe(request -> {
+                request.addCountFilter(hitCount);
+                request.enable();
+            });
+    }
+
+    @Override
+    public void putProperty(Object key, Object value) {
+        propertyMap.put(key, value);
+    }
+
+    @Override
+    public Object getProperty(Object key) {
+        return propertyMap.get(key);
+    }
+
+    @Override
+    public CompletableFuture<IWatchpoint> install() {
+        Disposable subscription = eventHub.events()
+            .filter(debugEvent -> debugEvent.event instanceof ThreadDeathEvent)
+            .subscribe(debugEvent -> {
+                ThreadReference deathThread = ((ThreadDeathEvent) debugEvent.event).thread();
+                compiledExpressions.remove(deathThread.uniqueID());
+            });
+        subscriptions.add(subscription);
+
+        // It's possible that different class loaders create new class with the same name.
+        // Here to listen to future class prepare events to handle such case.
+        ClassPrepareRequest classPrepareRequest = vm.eventRequestManager().createClassPrepareRequest();
+        classPrepareRequest.addClassFilter(className);
+        classPrepareRequest.enable();
+        requests.add(classPrepareRequest);
+
+        CompletableFuture<IWatchpoint> future = new CompletableFuture<>();
+        subscription = eventHub.events()
+            .filter(debugEvent -> debugEvent.event instanceof ClassPrepareEvent && (classPrepareRequest.equals(debugEvent.event.request())))
+            .subscribe(debugEvent -> {
+                ClassPrepareEvent event = (ClassPrepareEvent) debugEvent.event;
+                List<WatchpointRequest> watchpointRequests = createWatchpointRequests(event.referenceType());
+                requests.addAll(watchpointRequests);
+                if (!watchpointRequests.isEmpty() && !future.isDone()) {
+                    this.putProperty("verified", true);
+                    future.complete(this);
+                }
+            });
+        subscriptions.add(subscription);
+
+        List<EventRequest> watchpointRequests = new ArrayList<>();
+        List<ReferenceType> types = vm.classesByName(className);
+        for (ReferenceType type : types) {
+            watchpointRequests.addAll(createWatchpointRequests(type));
+        }
+
+        requests.addAll(watchpointRequests);
+        if (!watchpointRequests.isEmpty() && !future.isDone()) {
+            this.putProperty("verified", true);
+            future.complete(this);
+        }
+
+        return future;
+    }
+
+    private List<WatchpointRequest> createWatchpointRequests(ReferenceType type) {
+        List<WatchpointRequest> watchpointRequests = new ArrayList<>();
+        Field field = type.fieldByName(fieldName);
+        if (field != null) {
+            if ("read".equals(accessType)) {
+                watchpointRequests.add(vm.eventRequestManager().createAccessWatchpointRequest(field));
+            } else if ("readWrite".equals(accessType)) {
+                watchpointRequests.add(vm.eventRequestManager().createAccessWatchpointRequest(field));
+                watchpointRequests.add(vm.eventRequestManager().createModificationWatchpointRequest(field));
+            } else {
+                watchpointRequests.add(vm.eventRequestManager().createModificationWatchpointRequest(field));
+            }
+        }
+
+        watchpointRequests.forEach(request -> {
+            request.setSuspendPolicy(suspendAllThreads ? EventRequest.SUSPEND_ALL : EventRequest.SUSPEND_EVENT_THREAD);
+            if (hitCount > 0) {
+                request.addCountFilter(hitCount);
+            }
+            request.enable();
+        });
+        return watchpointRequests;
+    }
+
+    @Override
+    public String getLogMessage() {
+        return null;
+    }
+
+    @Override
+    public void setLogMessage(String logMessage) {
+        throw new UnsupportedOperationException("Log message feature is unsupported for watchpoint.");
+    }
+
+    @Override
+    public boolean containsEvaluatableExpression() {
+        return containsConditionalExpression();
+    }
+
+    @Override
+    public boolean containsConditionalExpression() {
+        return StringUtils.isNotBlank(getCondition());
+    }
+
+    @Override
+    public boolean containsLogpointExpression() {
+        return false;
+    }
+
+    public void setCompiledConditionalExpression(Object compiledExpression) {
+        this.compiledConditionalExpression = compiledExpression;
+    }
+
+    public Object getCompiledConditionalExpression() {
+        return compiledConditionalExpression;
+    }
+
+    @Override
+    public void setCompiledLogpointExpression(Object compiledExpression) {
+        // do nothing
+    }
+
+    @Override
+    public Object getCompiledLogpointExpression() {
+        return null;
+    }
+
+    @Override
+    public Object getCompiledExpression(long threadId) {
+        return compiledExpressions.get(threadId);
+    }
+
+    @Override
+    public void setCompiledExpression(long threadId, Object compiledExpression) {
+        compiledExpressions.put(threadId, compiledExpression);
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/AdapterUtils.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/AdapterUtils.java
index b97847e70..c30aa8742 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/AdapterUtils.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/AdapterUtils.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2021 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -11,8 +11,12 @@
 
 package com.microsoft.java.debug.core.adapter;
 
+import java.io.File;
+import java.io.UnsupportedEncodingException;
+import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.net.URLDecoder;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.FileSystemNotFoundException;
 import java.nio.file.Files;
@@ -21,14 +25,23 @@
 import java.nio.file.Paths;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import com.microsoft.java.debug.core.adapter.Messages.Response;
+import org.apache.commons.lang3.StringUtils;
+
+import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types;
 
 public class AdapterUtils {
     private static final String OS_NAME = System.getProperty("os.name", "").toLowerCase();
     private static final Pattern ENCLOSING_CLASS_REGEX = Pattern.compile("^([^\\$]*)");
+    public static final boolean isWin = isWindows();
+    public static final boolean isMac = OS_NAME.contains("mac") || OS_NAME.contains("darwin");
 
     /**
      * Check if the OS is windows or not.
@@ -46,10 +59,12 @@ public static boolean isWindows() {
      * @return the absolute file path
      */
     public static String sourceLookup(String[] sourcePaths, String sourceName) {
-        for (String path : sourcePaths) {
-            Path fullpath = Paths.get(path, sourceName);
-            if (Files.isRegularFile(fullpath)) {
-                return fullpath.toString();
+        if (sourcePaths != null) {
+            for (String path : sourcePaths) {
+                Path fullpath = Paths.get(path, sourceName);
+                if (Files.isRegularFile(fullpath)) {
+                    return fullpath.toString();
+                }
             }
         }
         return null;
@@ -96,6 +111,26 @@ public static int convertLineNumber(int line, boolean sourceLinesStartAt1, boole
         }
     }
 
+    /**
+     * Convert the source platform's column number to the target platform's column
+     * number.
+     *
+     * @param column
+     *                              the column number from the source platform
+     * @param sourceColumnsStartAt1
+     *                              the source platform's column starts at 1 or not
+     * @param targetColumnStartAt1
+     *                              the target platform's column starts at 1 or not
+     * @return the new column number
+     */
+    public static int convertColumnNumber(int column, boolean sourceColumnsStartAt1, boolean targetColumnStartAt1) {
+        if (sourceColumnsStartAt1) {
+            return targetColumnStartAt1 ? column : column - 1;
+        } else {
+            return targetColumnStartAt1 ? column + 1 : column;
+        }
+    }
+
     /**
      * Convert the source platform's path format to the target platform's path format.
      *
@@ -151,7 +186,33 @@ public static String toUri(String path) {
     }
 
     /**
-     * Generate an error response with the given error message.
+     * Convert a file path to an url string.
+     * @param path
+     *              the file path
+     * @return the url string
+     * @throws MalformedURLException
+     *              if the file path cannot be constructed to an url because of some errors.
+     */
+    public static String toUrl(String path) throws MalformedURLException {
+        File file = new File(path);
+        return file.toURI().toURL().toString();
+    }
+
+    /**
+     * Check a string variable is an uri or not.
+     */
+    public static boolean isUri(String uriString) {
+        try {
+            URI uri = new URI(uriString);
+            return StringUtils.isNotBlank(uri.getScheme());
+        } catch (URISyntaxException | IllegalArgumentException | FileSystemNotFoundException
+            | SecurityException e) {
+            return false;
+        }
+    }
+
+    /**
+     * Populate the response body with the given error message, and mark the success flag to false. At last return the response object back.
      *
      * @param response
      *              the response object
@@ -159,15 +220,17 @@ public static String toUri(String path) {
      *              the error code
      * @param errorMessage
      *              the error message
+     * @return the modified response object.
      */
-    public static void setErrorResponse(Response response, ErrorCode errorCode, String errorMessage) {
+    public static Response setErrorResponse(Response response, ErrorCode errorCode, String errorMessage) {
         response.body = new Responses.ErrorResponseBody(new Types.Message(errorCode.getId(), errorMessage));
         response.message = errorMessage;
         response.success = false;
+        return response;
     }
 
     /**
-     * Generate an error response with the given exception.
+     * Populate the response body with the given exception, and mark the success flag to false. At last return the response object back.
      *
      * @param response
      *              the response object
@@ -175,12 +238,40 @@ public static void setErrorResponse(Response response, ErrorCode errorCode, Stri
      *              the error code
      * @param e
      *              the exception
+     * @return the modified response object.
      */
-    public static void setErrorResponse(Response response, ErrorCode errorCode, Exception e) {
+    public static Response setErrorResponse(Response response, ErrorCode errorCode, Exception e) {
         String errorMessage = e.toString();
         response.body = new Responses.ErrorResponseBody(new Types.Message(errorCode.getId(), errorMessage));
         response.message = errorMessage;
         response.success = false;
+        return response;
+    }
+
+    /**
+     * Generate a CompletableFuture response with the given error message.
+     */
+    public static CompletableFuture<Response> createAsyncErrorResponse(Response response, ErrorCode errorCode, String errorMessage) {
+        return CompletableFuture.completedFuture(setErrorResponse(response, errorCode, errorMessage));
+    }
+
+    /**
+     * Generate a CompletableFuture response with the given exception.
+     */
+    public static CompletableFuture<Response> createAsyncErrorResponse(Response response, ErrorCode errorCode, Exception e) {
+        return CompletableFuture.completedFuture(setErrorResponse(response, errorCode, e));
+    }
+
+    public static CompletionException createCompletionException(String message, ErrorCode errorCode, Throwable cause) {
+        return new CompletionException(new DebugException(message, cause, errorCode.getId()));
+    }
+
+    public static CompletionException createCompletionException(String message, ErrorCode errorCode) {
+        return new CompletionException(new DebugException(message, errorCode.getId()));
+    }
+
+    public static DebugException createUserErrorDebugException(String message, ErrorCode errorCode) {
+        return new DebugException(message, errorCode.getId(), true);
     }
 
     /**
@@ -205,4 +296,72 @@ public static String getSHA256HexDigest(String content) {
         }
         return buf.toString();
     }
+
+    /**
+     * Decode the uri string.
+     * @param uri
+     *          the uri string
+     * @return the decoded uri
+     */
+    public static String decodeURIComponent(String uri) {
+        try {
+            return URLDecoder.decode(uri, StandardCharsets.UTF_8.name());
+        } catch (UnsupportedEncodingException e) {
+            return uri;
+        }
+    }
+
+    /**
+     * Find the mapped lines based on the given line number.
+     *
+     * The line mappings format is as follows:
+     * - [i]: key
+     * - [i+1]: value
+     */
+    public static int[] binarySearchMappedLines(int[] lineMappings, int targetLine) {
+        if (lineMappings == null || lineMappings.length == 0 || lineMappings.length % 2 != 0) {
+            return null;
+        }
+
+        final int MAX = lineMappings.length / 2 - 1;
+        int low = 0;
+        int high = MAX;
+        int found = -1;
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+            int actualMid = mid * 2;
+            if (lineMappings[actualMid] == targetLine) {
+                found = mid;
+                break;
+            }
+
+            if (lineMappings[actualMid] < targetLine) {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+
+        if (found == -1) {
+            return null;
+        }
+
+        // Find the duplicates in the sorted array
+        int left = found;
+        while ((left - 1) >= 0 && lineMappings[(left - 1) * 2] == targetLine) {
+            left--;
+        }
+
+        int right = found;
+        while ((right + 1) <= MAX && lineMappings[(right + 1) * 2] == targetLine) {
+            right++;
+        }
+
+        int[] values = new int[right - left + 1];
+        for (int i = 0; i < values.length; i++) {
+            values[i] = lineMappings[(left + i) * 2 + 1];
+        }
+
+        return values;
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/BreakpointManager.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/BreakpointManager.java
index 049f43fb5..eaf1bb56f 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/BreakpointManager.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/BreakpointManager.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2019 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -14,22 +14,29 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import com.microsoft.java.debug.core.Configuration;
 import com.microsoft.java.debug.core.IBreakpoint;
+import com.microsoft.java.debug.core.IMethodBreakpoint;
+import com.microsoft.java.debug.core.IWatchpoint;
 
-public class BreakpointManager {
+public class BreakpointManager implements IBreakpointManager {
     private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
     /**
      * A collection of breakpoints registered with this manager.
      */
     private List<IBreakpoint> breakpoints;
-    private HashMap<String, HashMap<String, IBreakpoint>> sourceToBreakpoints;
+    private Map<String, HashMap<String, IBreakpoint>> sourceToBreakpoints;
+    private Map<String, IWatchpoint> watchpoints;
+    private Map<String, IMethodBreakpoint> methodBreakpoints;
     private AtomicInteger nextBreakpointId = new AtomicInteger(1);
 
     /**
@@ -38,33 +45,16 @@ public class BreakpointManager {
     public BreakpointManager() {
         this.breakpoints = Collections.synchronizedList(new ArrayList<>(5));
         this.sourceToBreakpoints = new HashMap<>();
+        this.watchpoints = new HashMap<>();
+        this.methodBreakpoints = new HashMap<>();
     }
 
-    /**
-     * Adds breakpoints to breakpoint manager.
-     * Deletes all breakpoints that are no longer listed.
-     * @param source
-     *              source path of breakpoints
-     * @param breakpoints
-     *              full list of breakpoints that locates in this source file
-     * @return the full breakpoint list that locates in the source file
-     */
+    @Override
     public IBreakpoint[] setBreakpoints(String source, IBreakpoint[] breakpoints) {
         return setBreakpoints(source, breakpoints, false);
     }
 
-    /**
-     * Adds breakpoints to breakpoint manager.
-     * Deletes all breakpoints that are no longer listed.
-     * In the case of modified source, delete everything.
-     * @param source
-     *              source path of breakpoints
-     * @param breakpoints
-     *              full list of breakpoints that locates in this source file
-     * @param sourceModified
-     *              the source file are modified or not.
-     * @return the full breakpoint list that locates in the source file
-     */
+    @Override
     public IBreakpoint[] setBreakpoints(String source, IBreakpoint[] breakpoints, boolean sourceModified) {
         List<IBreakpoint> result = new ArrayList<>();
         HashMap<String, IBreakpoint> breakpointMap = this.sourceToBreakpoints.get(source);
@@ -89,12 +79,12 @@ public IBreakpoint[] setBreakpoints(String source, IBreakpoint[] breakpoints, bo
 
         // Compute the breakpoints that are newly added.
         List<IBreakpoint> toAdd = new ArrayList<>();
-        List<Integer> visitedLineNumbers = new ArrayList<>();
+        List<Integer> visitedBreakpoints = new ArrayList<>();
         for (IBreakpoint breakpoint : breakpoints) {
-            IBreakpoint existed = breakpointMap.get(String.valueOf(breakpoint.lineNumber()));
+            IBreakpoint existed = breakpointMap.get(String.valueOf(breakpoint.hashCode()));
             if (existed != null) {
                 result.add(existed);
-                visitedLineNumbers.add(existed.lineNumber());
+                visitedBreakpoints.add(existed.hashCode());
                 continue;
             } else {
                 result.add(breakpoint);
@@ -105,7 +95,7 @@ public IBreakpoint[] setBreakpoints(String source, IBreakpoint[] breakpoints, bo
         // Compute the breakpoints that are no longer listed.
         List<IBreakpoint> toRemove = new ArrayList<>();
         for (IBreakpoint breakpoint : breakpointMap.values()) {
-            if (!visitedLineNumbers.contains(breakpoint.lineNumber())) {
+            if (!visitedBreakpoints.contains(breakpoint.hashCode())) {
                 toRemove.add(breakpoint);
             }
         }
@@ -123,7 +113,7 @@ private void addBreakpointsInternally(String source, IBreakpoint[] breakpoints)
             for (IBreakpoint breakpoint : breakpoints) {
                 breakpoint.putProperty("id", this.nextBreakpointId.getAndIncrement());
                 this.breakpoints.add(breakpoint);
-                breakpointMap.put(String.valueOf(breakpoint.lineNumber()), breakpoint);
+                breakpointMap.put(String.valueOf(breakpoint.hashCode()), breakpoint);
             }
         }
     }
@@ -143,7 +133,7 @@ private void removeBreakpointsInternally(String source, IBreakpoint[] breakpoint
                     // Destroy the breakpoint on the debugee VM.
                     breakpoint.close();
                     this.breakpoints.remove(breakpoint);
-                    breakpointMap.remove(String.valueOf(breakpoint.lineNumber()));
+                    breakpointMap.remove(String.valueOf(breakpoint.hashCode()));
                 } catch (Exception e) {
                     logger.log(Level.SEVERE, String.format("Remove breakpoint exception: %s", e.toString()), e);
                 }
@@ -151,13 +141,12 @@ private void removeBreakpointsInternally(String source, IBreakpoint[] breakpoint
         }
     }
 
+    @Override
     public IBreakpoint[] getBreakpoints() {
         return this.breakpoints.toArray(new IBreakpoint[0]);
     }
 
-    /**
-     * Gets the registered breakpoints at the source file.
-     */
+    @Override
     public IBreakpoint[] getBreakpoints(String source) {
         HashMap<String, IBreakpoint> breakpointMap = this.sourceToBreakpoints.get(source);
         if (breakpointMap == null) {
@@ -166,12 +155,117 @@ public IBreakpoint[] getBreakpoints(String source) {
         return breakpointMap.values().toArray(new IBreakpoint[0]);
     }
 
-    /**
-     * Cleanup all breakpoints and reset the breakpoint id counter.
-     */
-    public void reset() {
-        this.sourceToBreakpoints.clear();
-        this.breakpoints.clear();
-        this.nextBreakpointId.set(1);
+    @Override
+    public IWatchpoint[] setWatchpoints(IWatchpoint[] changedWatchpoints) {
+        List<IWatchpoint> result = new ArrayList<>();
+        List<IWatchpoint> toAdds = new ArrayList<>();
+        List<IWatchpoint> toRemoves = new ArrayList<>();
+
+        Set<String> visitedKeys = new HashSet<>();
+        for (IWatchpoint change : changedWatchpoints) {
+            if (change == null) {
+                result.add(change);
+                continue;
+            }
+
+            String key = getWatchpointKey(change);
+            IWatchpoint cache = watchpoints.get(key);
+            if (cache != null && Objects.equals(cache.accessType(), change.accessType())) {
+                visitedKeys.add(key);
+                result.add(cache);
+            } else {
+                toAdds.add(change);
+                result.add(change);
+            }
+        }
+
+        for (IWatchpoint cache : watchpoints.values()) {
+            if (!visitedKeys.contains(getWatchpointKey(cache))) {
+                toRemoves.add(cache);
+            }
+        }
+
+        for (IWatchpoint toRemove : toRemoves) {
+            try {
+                // Destroy the watch point on the debugee VM.
+                toRemove.close();
+                this.watchpoints.remove(getWatchpointKey(toRemove));
+            } catch (Exception e) {
+                logger.log(Level.SEVERE, String.format("Remove the watch point exception: %s", e.toString()), e);
+            }
+        }
+
+        for (IWatchpoint toAdd : toAdds) {
+            toAdd.putProperty("id", this.nextBreakpointId.getAndIncrement());
+            this.watchpoints.put(getWatchpointKey(toAdd), toAdd);
+        }
+
+        return result.toArray(new IWatchpoint[0]);
+    }
+
+    private String getWatchpointKey(IWatchpoint watchpoint) {
+        return watchpoint.className() + "#" + watchpoint.fieldName();
+    }
+
+    @Override
+    public IWatchpoint[] getWatchpoints() {
+        return this.watchpoints.values().stream().filter(wp -> wp != null).toArray(IWatchpoint[]::new);
+    }
+
+    @Override
+    public IMethodBreakpoint[] getMethodBreakpoints() {
+        return this.methodBreakpoints.values().stream().filter(Objects::nonNull).toArray(IMethodBreakpoint[]::new);
+    }
+
+    @Override
+    public IMethodBreakpoint[] setMethodBreakpoints(IMethodBreakpoint[] breakpoints) {
+        List<IMethodBreakpoint> result = new ArrayList<>();
+        List<IMethodBreakpoint> toAdds = new ArrayList<>();
+        List<IMethodBreakpoint> toRemoves = new ArrayList<>();
+
+        Set<String> visitedKeys = new HashSet<>();
+        for (IMethodBreakpoint change : breakpoints) {
+            if (change == null) {
+                result.add(change);
+                continue;
+            }
+
+            String key = getMethodBreakpointKey(change);
+            IMethodBreakpoint cache = methodBreakpoints.get(key);
+            if (cache != null) {
+                visitedKeys.add(key);
+                result.add(cache);
+            } else {
+                toAdds.add(change);
+                result.add(change);
+            }
+        }
+
+        for (IMethodBreakpoint cache : methodBreakpoints.values()) {
+            if (!visitedKeys.contains(getMethodBreakpointKey(cache))) {
+                toRemoves.add(cache);
+            }
+        }
+
+        for (IMethodBreakpoint toRemove : toRemoves) {
+            try {
+                // Destroy the method breakpoint on the debugee VM.
+                toRemove.close();
+                this.methodBreakpoints.remove(getMethodBreakpointKey(toRemove));
+            } catch (Exception e) {
+                logger.log(Level.SEVERE, String.format("Remove the method breakpoint exception: %s", e.toString()), e);
+            }
+        }
+
+        for (IMethodBreakpoint toAdd : toAdds) {
+            toAdd.putProperty("id", this.nextBreakpointId.getAndIncrement());
+            this.methodBreakpoints.put(getMethodBreakpointKey(toAdd), toAdd);
+        }
+
+        return result.toArray(new IMethodBreakpoint[0]);
+    }
+
+    private String getMethodBreakpointKey(IMethodBreakpoint breakpoint) {
+        return breakpoint.className() + "#" + breakpoint.methodName();
     }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Constants.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Constants.java
index 760241517..2e523aba2 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Constants.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Constants.java
@@ -12,6 +12,7 @@
 package com.microsoft.java.debug.core.adapter;
 
 public final class Constants {
-    public static final String PROJECTNAME = "projectName";
+    public static final String PROJECT_NAME = "projectName";
     public static final String DEBUGGEE_ENCODING = "debuggeeEncoding";
+    public static final String MAIN_CLASS = "mainClass";
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/DebugAdapter.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/DebugAdapter.java
index e2d3ac6d2..8f595151f 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/DebugAdapter.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/DebugAdapter.java
@@ -15,49 +15,65 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiConsumer;
+import java.util.concurrent.CompletableFuture;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import com.microsoft.java.debug.core.Configuration;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
 import com.microsoft.java.debug.core.adapter.handler.AttachRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.BreakpointLocationsRequestHander;
+import com.microsoft.java.debug.core.adapter.handler.CompletionsHandler;
 import com.microsoft.java.debug.core.adapter.handler.ConfigurationDoneRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.DataBreakpointInfoRequestHandler;
 import com.microsoft.java.debug.core.adapter.handler.DisconnectRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.DisconnectRequestWithoutDebuggingHandler;
 import com.microsoft.java.debug.core.adapter.handler.EvaluateRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.ExceptionInfoRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.HotCodeReplaceHandler;
 import com.microsoft.java.debug.core.adapter.handler.InitializeRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.InlineValuesRequestHandler;
 import com.microsoft.java.debug.core.adapter.handler.LaunchRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.ProcessIdHandler;
+import com.microsoft.java.debug.core.adapter.handler.RefreshFramesHandler;
+import com.microsoft.java.debug.core.adapter.handler.RefreshVariablesHandler;
+import com.microsoft.java.debug.core.adapter.handler.RestartFrameHandler;
 import com.microsoft.java.debug.core.adapter.handler.ScopesRequestHandler;
 import com.microsoft.java.debug.core.adapter.handler.SetBreakpointsRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.SetDataBreakpointsRequestHandler;
 import com.microsoft.java.debug.core.adapter.handler.SetExceptionBreakpointsRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.SetFunctionBreakpointsRequestHandler;
 import com.microsoft.java.debug.core.adapter.handler.SetVariableRequestHandler;
 import com.microsoft.java.debug.core.adapter.handler.SourceRequestHandler;
 import com.microsoft.java.debug.core.adapter.handler.StackTraceRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.StepInTargetsRequestHandler;
+import com.microsoft.java.debug.core.adapter.handler.StepRequestHandler;
 import com.microsoft.java.debug.core.adapter.handler.ThreadsRequestHandler;
 import com.microsoft.java.debug.core.adapter.handler.VariablesRequestHandler;
+import com.microsoft.java.debug.core.protocol.IProtocolServer;
+import com.microsoft.java.debug.core.protocol.JsonUtils;
+import com.microsoft.java.debug.core.protocol.Messages;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
 
 public class DebugAdapter implements IDebugAdapter {
     private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
 
-    private BiConsumer<Events.DebugEvent, Boolean> eventConsumer;
-    private IProviderContext providerContext;
     private IDebugAdapterContext debugContext = null;
-    private Map<Command, List<IDebugRequestHandler>> requestHandlers = null;
+    private Map<Command, List<IDebugRequestHandler>> requestHandlersForDebug = null;
+    private Map<Command, List<IDebugRequestHandler>> requestHandlersForNoDebug = null;
 
     /**
      * Constructor.
      */
-    public DebugAdapter(BiConsumer<Events.DebugEvent, Boolean> consumer, IProviderContext providerContext) {
-        eventConsumer = consumer;
-        this.providerContext = providerContext;
-        debugContext = new DebugAdapterContext(this);
-        requestHandlers = new HashMap<>();
+    public DebugAdapter(IProtocolServer server, IProviderContext providerContext) {
+        this.debugContext = new DebugAdapterContext(server, providerContext);
+        requestHandlersForDebug = new HashMap<>();
+        requestHandlersForNoDebug = new HashMap<>();
         initialize();
     }
 
     @Override
-    public Messages.Response dispatchRequest(Messages.Request request) {
+    public CompletableFuture<Messages.Response> dispatchRequest(Messages.Request request) {
         Messages.Response response = new Messages.Response();
         response.request_seq = request.seq;
         response.command = request.command;
@@ -66,78 +82,88 @@ public Messages.Response dispatchRequest(Messages.Request request) {
         Command command = Command.parse(request.command);
         Arguments cmdArgs = JsonUtils.fromJson(request.arguments, command.getArgumentType());
 
-        try {
-            if (debugContext.isVmTerminated()) {
-                AdapterUtils.setErrorResponse(response, ErrorCode.VM_TERMINATED,
-                        String.format("Target VM is already terminated.", request.command));
-                return response;
-            }
-            List<IDebugRequestHandler> handlers = requestHandlers.get(command);
-            if (handlers != null && !handlers.isEmpty()) {
-                for (IDebugRequestHandler handler : handlers) {
-                    handler.handle(command, cmdArgs, response, debugContext);
-                }
-            } else {
-                AdapterUtils.setErrorResponse(response, ErrorCode.UNRECOGNIZED_REQUEST_FAILURE,
-                        String.format("Unrecognized request: { _request: %s }", request.command));
+        if (debugContext.isVmTerminated() && command != Command.DISCONNECT) {
+            return CompletableFuture.completedFuture(response);
+        }
+        List<IDebugRequestHandler> handlers = this.debugContext.getLaunchMode() == LaunchMode.DEBUG
+                ? requestHandlersForDebug.get(command) : requestHandlersForNoDebug.get(command);
+        if (handlers != null && !handlers.isEmpty()) {
+            CompletableFuture<Messages.Response> future = CompletableFuture.completedFuture(response);
+            for (IDebugRequestHandler handler : handlers) {
+                future = future.thenCompose((res) -> {
+                    return handler.handle(command, cmdArgs, res, debugContext);
+                });
             }
-        } catch (Exception e) {
-            logger.log(Level.SEVERE, String.format("DebugSession dispatch exception: %s", e.toString()), e);
-            AdapterUtils.setErrorResponse(response, ErrorCode.UNKNOWN_FAILURE,
-                    e.getMessage() != null ? e.getMessage() : e.toString());
+            return future;
+        } else {
+            final String errorMessage = String.format("Unrecognized request: { _request: %s }", request.command);
+            logger.log(Level.SEVERE, errorMessage);
+            return AdapterUtils.createAsyncErrorResponse(response, ErrorCode.UNRECOGNIZED_REQUEST_FAILURE, errorMessage);
         }
-
-        return response;
     }
 
-    /**
-     * Send event to DA immediately.
-     *
-     * @see ProtocolServer#sendEvent(String, Object)
-     */
-    public void sendEvent(Events.DebugEvent event) {
-        eventConsumer.accept(event, false);
+    protected void initialize() {
+        // Register request handlers.
+        // When there are multiple handlers registered for the same request, follow the rule "first register, first execute".
+        registerHandler(new InitializeRequestHandler());
+        registerHandler(new LaunchRequestHandler());
+
+        // DEBUG mode only
+        registerHandlerForDebug(new AttachRequestHandler());
+        registerHandlerForDebug(new ConfigurationDoneRequestHandler());
+        registerHandlerForDebug(new DisconnectRequestHandler());
+        registerHandlerForDebug(new SetBreakpointsRequestHandler());
+        registerHandlerForDebug(new SetExceptionBreakpointsRequestHandler());
+        registerHandlerForDebug(new SourceRequestHandler());
+        registerHandlerForDebug(new ThreadsRequestHandler());
+        registerHandlerForDebug(new StepRequestHandler());
+        registerHandlerForDebug(new StackTraceRequestHandler());
+        registerHandlerForDebug(new ScopesRequestHandler());
+        registerHandlerForDebug(new VariablesRequestHandler());
+        registerHandlerForDebug(new SetVariableRequestHandler());
+        registerHandlerForDebug(new EvaluateRequestHandler());
+        registerHandlerForDebug(new HotCodeReplaceHandler());
+        registerHandlerForDebug(new RestartFrameHandler());
+        registerHandlerForDebug(new CompletionsHandler());
+        registerHandlerForDebug(new ExceptionInfoRequestHandler());
+        registerHandlerForDebug(new DataBreakpointInfoRequestHandler());
+        registerHandlerForDebug(new SetDataBreakpointsRequestHandler());
+        registerHandlerForDebug(new InlineValuesRequestHandler());
+        registerHandlerForDebug(new RefreshVariablesHandler());
+        registerHandlerForDebug(new ProcessIdHandler());
+        registerHandlerForDebug(new SetFunctionBreakpointsRequestHandler());
+        registerHandlerForDebug(new BreakpointLocationsRequestHander());
+        registerHandlerForDebug(new StepInTargetsRequestHandler());
+        registerHandlerForDebug(new RefreshFramesHandler());
+
+        // NO_DEBUG mode only
+        registerHandlerForNoDebug(new DisconnectRequestWithoutDebuggingHandler());
+        registerHandlerForNoDebug(new ProcessIdHandler());
     }
 
-    /**
-     * Send event to DA after the current dispatching request is resolved.
-     *
-     * @see ProtocolServer#sendEventLater(String, Object)
-     */
-    public void sendEventLater(Events.DebugEvent event) {
-        eventConsumer.accept(event, true);
+    protected void registerHandlerForDebug(IDebugRequestHandler handler) {
+        registerHandler(requestHandlersForDebug, handler);
     }
 
-    public <T extends IProvider> T getProvider(Class<T> clazz) {
-        return providerContext.getProvider(clazz);
+    protected void registerHandlerForNoDebug(IDebugRequestHandler handler) {
+        registerHandler(requestHandlersForNoDebug, handler);
     }
 
-    private void initialize() {
-        // Register request handlers.
-        registerHandler(new InitializeRequestHandler());
-        registerHandler(new LaunchRequestHandler());
-        registerHandler(new AttachRequestHandler());
-        registerHandler(new ConfigurationDoneRequestHandler());
-        registerHandler(new DisconnectRequestHandler());
-        registerHandler(new SetBreakpointsRequestHandler());
-        registerHandler(new SetExceptionBreakpointsRequestHandler());
-        registerHandler(new SourceRequestHandler());
-        registerHandler(new ThreadsRequestHandler());
-        registerHandler(new StackTraceRequestHandler());
-        registerHandler(new ScopesRequestHandler());
-        registerHandler(new VariablesRequestHandler());
-        registerHandler(new SetVariableRequestHandler());
-        registerHandler(new EvaluateRequestHandler());
+    protected void registerHandler(IDebugRequestHandler handler) {
+        registerHandler(requestHandlersForDebug, handler);
+        registerHandler(requestHandlersForNoDebug, handler);
     }
 
-    private void registerHandler(IDebugRequestHandler handler) {
+    private void registerHandler(Map<Command, List<IDebugRequestHandler>> requestHandlers, IDebugRequestHandler handler) {
         for (Command command : handler.getTargetCommands()) {
             List<IDebugRequestHandler> handlerList = requestHandlers.get(command);
             if (handlerList == null) {
                 handlerList = new ArrayList<>();
                 requestHandlers.put(command, handlerList);
             }
+            handler.initialize(debugContext);
             handlerList.add(handler);
         }
     }
-}
\ No newline at end of file
+
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/DebugAdapterContext.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/DebugAdapterContext.java
index 668a90f32..bbf215c67 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/DebugAdapterContext.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/DebugAdapterContext.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -12,50 +12,81 @@
 package com.microsoft.java.debug.core.adapter;
 
 import java.nio.charset.Charset;
+import java.nio.file.Path;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.LinkedHashSet;
 import java.util.Map;
+import java.util.Set;
 
+import com.microsoft.java.debug.core.DebugSettings;
 import com.microsoft.java.debug.core.IDebugSession;
-import com.microsoft.java.debug.core.adapter.Events.DebugEvent;
+import com.microsoft.java.debug.core.DebugSettings.AsyncMode;
 import com.microsoft.java.debug.core.adapter.variables.IVariableFormatter;
 import com.microsoft.java.debug.core.adapter.variables.VariableFormatterFactory;
+import com.microsoft.java.debug.core.protocol.IProtocolServer;
+import com.microsoft.java.debug.core.protocol.Requests.StepFilters;
+
+import org.apache.commons.lang3.ArrayUtils;
 
 public class DebugAdapterContext implements IDebugAdapterContext {
     private static final int MAX_CACHE_ITEMS = 10000;
-    private Map<String, String> sourceMappingCache = Collections.synchronizedMap(new LRUCache<>(MAX_CACHE_ITEMS));
-    private DebugAdapter debugAdapter;
+    private final StepFilters defaultFilters = new StepFilters();
+    private Map<String, Source> sourceMappingCache = Collections.synchronizedMap(new LRUCache<>(MAX_CACHE_ITEMS));
+    private IProviderContext providerContext;
+    private IProtocolServer server;
 
     private IDebugSession debugSession;
     private boolean debuggerLinesStartAt1 = true;
+    // The Java model on debugger uses 0-based column number.
+    private boolean debuggerColumnStartAt1 = false;
     private boolean debuggerPathsAreUri = true;
     private boolean clientLinesStartAt1 = true;
+    private boolean clientColumnsStartAt1 = true;
     private boolean clientPathsAreUri = false;
+    private boolean supportsRunInTerminalRequest;
     private boolean isAttached = false;
     private String[] sourcePaths;
     private Charset debuggeeEncoding;
     private transient boolean vmTerminated;
+    private boolean isVmStopOnEntry = false;
+    private LaunchMode launchMode = LaunchMode.DEBUG;
+    private Process debuggeeProcess;
+    private String mainClass;
+    private StepFilters stepFilters;
+    private Path classpathJar = null;
+    private Path argsfile = null;
+    private boolean isInitialized = false;
+
+    private long shellProcessId = -1;
+    private long processId = -1;
+
+    private boolean localDebugging = true;
+    private long jdwpLatency = 0;
 
     private IdCollection<String> sourceReferences = new IdCollection<>();
     private RecyclableObjectPool<Long, Object> recyclableIdPool = new RecyclableObjectPool<>();
     private IVariableFormatter variableFormatter = VariableFormatterFactory.createVariableFormatter();
 
-    public DebugAdapterContext(DebugAdapter debugAdapter) {
-        this.debugAdapter = debugAdapter;
-    }
+    private IStackFrameManager stackFrameManager = new StackFrameManager();
+    private IExceptionManager exceptionManager = new ExceptionManager();
+    private IBreakpointManager breakpointManager = new BreakpointManager();
+    private IStepResultManager stepResultManager = new StepResultManager();
+    private ThreadCache threadCache = new ThreadCache();
 
-    @Override
-    public void sendEvent(DebugEvent event) {
-        debugAdapter.sendEvent(event);
+    public DebugAdapterContext(IProtocolServer server, IProviderContext providerContext) {
+        this.providerContext = providerContext;
+        this.server = server;
     }
 
     @Override
-    public void sendEventAsync(DebugEvent event) {
-        debugAdapter.sendEventLater(event);
+    public IProtocolServer getProtocolServer() {
+        return server;
     }
 
     @Override
     public <T extends IProvider> T getProvider(Class<T> clazz) {
-        return debugAdapter.getProvider(clazz);
+        return providerContext.getProvider(clazz);
     }
 
     @Override
@@ -78,6 +109,10 @@ public void setDebuggerLinesStartAt1(boolean debuggerLinesStartAt1) {
         this.debuggerLinesStartAt1 = debuggerLinesStartAt1;
     }
 
+    public boolean isDebuggerColumnsStartAt1() {
+        return debuggerColumnStartAt1;
+    }
+
     @Override
     public boolean isDebuggerPathsAreUri() {
         return debuggerPathsAreUri;
@@ -98,6 +133,14 @@ public void setClientLinesStartAt1(boolean clientLinesStartAt1) {
         this.clientLinesStartAt1 = clientLinesStartAt1;
     }
 
+    public boolean isClientColumnsStartAt1() {
+        return clientColumnsStartAt1;
+    }
+
+    public void setClientColumnsStartAt1(boolean clientColumnsStartAt1) {
+        this.clientColumnsStartAt1 = clientColumnsStartAt1;
+    }
+
     @Override
     public boolean isClientPathsAreUri() {
         return clientPathsAreUri;
@@ -108,6 +151,16 @@ public void setClientPathsAreUri(boolean clientPathsAreUri) {
         this.clientPathsAreUri = clientPathsAreUri;
     }
 
+    @Override
+    public void setSupportsRunInTerminalRequest(boolean supportsRunInTerminalRequest) {
+        this.supportsRunInTerminalRequest = supportsRunInTerminalRequest;
+    }
+
+    @Override
+    public boolean supportsRunInTerminalRequest() {
+        return supportsRunInTerminalRequest;
+    }
+
     @Override
     public boolean isAttached() {
         return isAttached;
@@ -159,7 +212,7 @@ public void setVariableFormatter(IVariableFormatter variableFormatter) {
     }
 
     @Override
-    public Map<String, String> getSourceLookupCache() {
+    public Map<String, Source> getSourceLookupCache() {
         return sourceMappingCache;
     }
 
@@ -182,4 +235,187 @@ public void setVmTerminated() {
     public boolean isVmTerminated() {
         return vmTerminated;
     }
+
+    @Override
+    public void setVmStopOnEntry(boolean stopOnEntry) {
+        isVmStopOnEntry = stopOnEntry;
+    }
+
+    @Override
+    public boolean isVmStopOnEntry() {
+        return isVmStopOnEntry;
+    }
+
+    @Override
+    public void setMainClass(String mainClass) {
+        this.mainClass = mainClass;
+    }
+
+    @Override
+    public String getMainClass() {
+        return this.mainClass;
+    }
+
+    @Override
+    public void setStepFilters(StepFilters stepFilters) {
+        // For backward compatibility, merge the classNameFilters to skipClasses.
+        if (stepFilters != null && ArrayUtils.isNotEmpty(stepFilters.classNameFilters)) {
+            Set<String> patterns = new LinkedHashSet<>();
+            if (ArrayUtils.isNotEmpty(stepFilters.skipClasses)) {
+                patterns.addAll(Arrays.asList(stepFilters.skipClasses));
+            }
+
+            patterns.addAll(Arrays.asList(stepFilters.classNameFilters));
+            stepFilters.skipClasses = patterns.toArray(new String[0]);
+        }
+        this.stepFilters = stepFilters;
+    }
+
+    @Override
+    public StepFilters getStepFilters() {
+        if (stepFilters != null) {
+            return stepFilters;
+        } else if (DebugSettings.getCurrent().stepFilters != null) {
+            return DebugSettings.getCurrent().stepFilters;
+        }
+
+        return defaultFilters;
+    }
+
+    @Override
+    public IStackFrameManager getStackFrameManager() {
+        return stackFrameManager;
+    }
+
+    @Override
+    public LaunchMode getLaunchMode() {
+        return launchMode;
+    }
+
+    @Override
+    public void setLaunchMode(LaunchMode launchMode) {
+        this.launchMode = launchMode;
+    }
+
+    @Override
+    public Process getDebuggeeProcess() {
+        return this.debuggeeProcess;
+    }
+
+    @Override
+    public void setDebuggeeProcess(Process debuggeeProcess) {
+        this.debuggeeProcess = debuggeeProcess;
+    }
+
+    @Override
+    public void setClasspathJar(Path classpathJar) {
+        this.classpathJar = classpathJar;
+    }
+
+    @Override
+    public Path getClasspathJar() {
+        return this.classpathJar;
+    }
+
+    @Override
+    public void setArgsfile(Path argsfile) {
+        this.argsfile = argsfile;
+    }
+
+    @Override
+    public Path getArgsfile() {
+        return this.argsfile;
+    }
+
+    @Override
+    public IExceptionManager getExceptionManager() {
+        return this.exceptionManager;
+    }
+
+    @Override
+    public IBreakpointManager getBreakpointManager() {
+        return breakpointManager;
+    }
+
+    @Override
+    public IStepResultManager getStepResultManager() {
+        return stepResultManager;
+    }
+
+    @Override
+    public long getProcessId() {
+        return this.processId;
+    }
+
+    @Override
+    public long getShellProcessId() {
+        return this.shellProcessId;
+    }
+
+    @Override
+    public void setProcessId(long processId) {
+        this.processId = processId;
+    }
+
+    @Override
+    public void setShellProcessId(long shellProcessId) {
+        this.shellProcessId = shellProcessId;
+    }
+
+    @Override
+    public void setThreadCache(ThreadCache cache) {
+        this.threadCache = cache;
+    }
+
+    @Override
+    public ThreadCache getThreadCache() {
+        return this.threadCache;
+    }
+
+    @Override
+    public boolean asyncJDWP() {
+        /**
+         * If we take 1 second as the acceptable latency for DAP requests,
+         * With a single-threaded strategy for handling JDWP requests,
+         * a latency of about 15ms per JDWP request can ensure the responsiveness
+         * for most DAPs. It allows sending 66 JDWP requests within 1 seconds,
+         * which can cover most DAP operations such as breakpoint, threads,
+         * call stack, step and continue.
+         */
+        return asyncJDWP(15);
+    }
+
+    @Override
+    public boolean asyncJDWP(long usableLatency) {
+        return DebugSettings.getCurrent().asyncJDWP == AsyncMode.ON
+            || (DebugSettings.getCurrent().asyncJDWP == AsyncMode.AUTO && this.jdwpLatency > usableLatency);
+    }
+
+    public boolean isLocalDebugging() {
+        return localDebugging;
+    }
+
+    public void setLocalDebugging(boolean local) {
+        this.localDebugging = local;
+    }
+
+    @Override
+    public long getJDWPLatency() {
+        return this.jdwpLatency;
+    }
+
+    @Override
+    public void setJDWPLatency(long baseLatency) {
+        this.jdwpLatency = baseLatency;
+    }
+
+    @Override
+    public boolean isInitialized() {
+        return isInitialized;
+    }
+
+    @Override
+    public void setInitialized(boolean isInitialized) {
+        this.isInitialized = isInitialized;
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ErrorCode.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ErrorCode.java
index bffeb6272..6cfe523cf 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ErrorCode.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ErrorCode.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -11,6 +11,8 @@
 
 package com.microsoft.java.debug.core.adapter;
 
+import java.util.Arrays;
+
 public enum ErrorCode {
     UNKNOWN_FAILURE(1000),
     UNRECOGNIZED_REQUEST_FAILURE(1001),
@@ -25,7 +27,16 @@ public enum ErrorCode {
     EVALUATE_FAILURE(1010),
     EMPTY_DEBUG_SESSION(1011),
     INVALID_ENCODING(1012),
-    VM_TERMINATED(1013);
+    VM_TERMINATED(1013),
+    LAUNCH_IN_TERMINAL_FAILURE(1014),
+    STEP_FAILURE(1015),
+    RESTARTFRAME_FAILURE(1016),
+    COMPLETIONS_FAILURE(1017),
+    EXCEPTION_INFO_FAILURE(1018),
+    EVALUATION_COMPILE_ERROR(2001),
+    EVALUATE_NOT_SUSPENDED_THREAD(2002),
+    HCR_FAILURE(3001),
+    INVALID_DAP_HEADER(3002);
 
     private int id;
 
@@ -36,4 +47,22 @@ public enum ErrorCode {
     public int getId() {
         return id;
     }
+
+    /**
+     * Get the corresponding ErrorCode type by the error code id.
+     * If the error code is not defined in the enum type, return ErrorCode.UNKNOWN_FAILURE.
+     * @param id
+     *             the error code id.
+     * @return the ErrorCode type.
+     */
+    public static ErrorCode parse(int id) {
+        ErrorCode[] found = Arrays.stream(ErrorCode.values()).filter(code -> {
+            return code.getId() == id;
+        }).toArray(ErrorCode[]::new);
+
+        if (found.length > 0) {
+            return found[0];
+        }
+        return ErrorCode.UNKNOWN_FAILURE;
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ExceptionManager.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ExceptionManager.java
new file mode 100644
index 000000000..b12a6b2b8
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ExceptionManager.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+* Copyright (c) 2019 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.microsoft.java.debug.core.JdiExceptionReference;
+
+public class ExceptionManager implements IExceptionManager {
+    private Map<Long, JdiExceptionReference> exceptions = Collections.synchronizedMap(new HashMap<>());
+
+    @Override
+    public JdiExceptionReference getException(long threadId) {
+        return exceptions.get(threadId);
+    }
+
+    @Override
+    public JdiExceptionReference removeException(long threadId) {
+        return exceptions.remove(threadId);
+    }
+
+    @Override
+    public JdiExceptionReference setException(long threadId, JdiExceptionReference exception) {
+        return exceptions.put(threadId, exception);
+    }
+
+    @Override
+    public void removeAllExceptions() {
+        exceptions.clear();
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/HotCodeReplaceEvent.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/HotCodeReplaceEvent.java
new file mode 100644
index 000000000..7046b0ac6
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/HotCodeReplaceEvent.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+public class HotCodeReplaceEvent {
+
+    public enum EventType {
+        ERROR(-1),
+
+        WARNING(-2),
+
+        STARTING(1),
+
+        END(2),
+
+        BUILD_COMPLETE(3);
+
+        private int value;
+
+        private EventType(int value) {
+            this.value = value;
+        }
+
+        public int getValue() {
+            return this.value;
+        }
+    }
+
+    private EventType eventType;
+
+    private String message;
+
+    private Object data;
+
+    public HotCodeReplaceEvent(EventType eventType, String message) {
+        this.eventType = eventType;
+        this.message = message;
+    }
+
+    public HotCodeReplaceEvent(EventType eventType, String message, Object data) {
+        this(eventType, message);
+        this.data = data;
+    }
+
+    public EventType getEventType() {
+        return eventType;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public Object getData() {
+        return data;
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IBreakpointManager.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IBreakpointManager.java
new file mode 100644
index 000000000..196714d52
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IBreakpointManager.java
@@ -0,0 +1,92 @@
+/*******************************************************************************
+* Copyright (c) 2019 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import com.microsoft.java.debug.core.IBreakpoint;
+import com.microsoft.java.debug.core.IMethodBreakpoint;
+import com.microsoft.java.debug.core.IWatchpoint;
+
+public interface IBreakpointManager {
+
+    /**
+     * Update the breakpoints associated with the source file.
+     *
+     * @see #setBreakpoints(String, IBreakpoint[], boolean)
+     * @param source
+     *              source path of breakpoints
+     * @param breakpoints
+     *              full list of breakpoints that locates in this source file
+     * @return the full breakpoint list that locates in the source file
+     */
+    IBreakpoint[] setBreakpoints(String source, IBreakpoint[] breakpoints);
+
+    /**
+     * Update the breakpoints associated with the source file. If the requested breakpoints already registered in the breakpoint manager,
+     * reuse the cached one. Otherwise register the requested breakpoint as a new breakpoint. Besides, delete those not existed any more.
+     *
+     * <p>If the source file is modified, delete all cached breakpoints associated the file first and re-register the new breakpoints.</p>
+     *
+     * @param source
+     *              source path of breakpoints
+     * @param breakpoints
+     *              full list of breakpoints that locates in this source file
+     * @param sourceModified
+     *              the source file is modified or not.
+     * @return the full breakpoint list that locates in the source file
+     */
+    IBreakpoint[] setBreakpoints(String source, IBreakpoint[] breakpoints, boolean sourceModified);
+
+    /**
+     * Update the watchpoint list. If the requested watchpoint already registered in the breakpoint manager,
+     * reuse the cached one. Otherwise register the requested watchpoint as a new watchpoint.
+     * Besides, delete those not existed any more.
+     *
+     * @param watchpoints
+     *                 the watchpoints requested by client
+     * @return the full registered watchpoints list
+     */
+    IWatchpoint[] setWatchpoints(IWatchpoint[] watchpoints);
+
+    /**
+     * Returns all registered breakpoints.
+     */
+    IBreakpoint[] getBreakpoints();
+
+    /**
+     * Returns the registered breakpoints at the source file.
+     */
+    IBreakpoint[] getBreakpoints(String source);
+
+    /**
+     * Returns all registered watchpoints.
+     */
+    IWatchpoint[] getWatchpoints();
+
+    /**
+     * Returns all the registered method breakpoints.
+     */
+    IMethodBreakpoint[] getMethodBreakpoints();
+
+    /**
+     * Update the method breakpoints list. If the requested method breakpoints
+     * already registered in the breakpoint
+     * manager, reuse the cached one. Otherwise register the requested method
+     * breakpoints as a new method breakpoints.
+     * Besides, delete those not existed any more.
+     *
+     * @param methodBreakpoints
+     *                  the method breakpoints requested by client
+     * @return the full registered method breakpoints list
+     */
+    IMethodBreakpoint[] setMethodBreakpoints(IMethodBreakpoint[] methodBreakpoints);
+
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ICompletionsProvider.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ICompletionsProvider.java
new file mode 100644
index 000000000..6597ff07b
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ICompletionsProvider.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2018 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import java.util.List;
+
+import com.microsoft.java.debug.core.protocol.Types.CompletionItem;
+import com.sun.jdi.StackFrame;
+
+public interface ICompletionsProvider extends IProvider {
+
+    /**
+     * Complete the code snippet on the target frame.
+     *
+     * @param frame
+     *            the target frame that the completions on
+     * @param snippet
+     *            the code snippet text
+     * @param line
+     *            the line number of the operation happens inside the snippet
+     * @param column
+     *            the column number of the operation happens inside the snippet
+     * @return a list of {@link CompletionItem}
+     */
+    List<CompletionItem> codeComplete(StackFrame frame, String snippet, int line, int column);
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapter.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapter.java
index 119c0a7e8..72405da2e 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapter.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapter.java
@@ -11,6 +11,10 @@
 
 package com.microsoft.java.debug.core.adapter;
 
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.protocol.Messages;
+
 public interface IDebugAdapter {
-    Messages.Response dispatchRequest(Messages.Request request);
+    CompletableFuture<Messages.Response> dispatchRequest(Messages.Request request);
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapterContext.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapterContext.java
index 801c8b3cc..e65270eef 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapterContext.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapterContext.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2017 Microsoft Corporation and others.
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -12,27 +12,16 @@
 package com.microsoft.java.debug.core.adapter;
 
 import java.nio.charset.Charset;
+import java.nio.file.Path;
 import java.util.Map;
 
 import com.microsoft.java.debug.core.IDebugSession;
 import com.microsoft.java.debug.core.adapter.variables.IVariableFormatter;
+import com.microsoft.java.debug.core.protocol.IProtocolServer;
+import com.microsoft.java.debug.core.protocol.Requests.StepFilters;
 
 public interface IDebugAdapterContext {
-    /**
-     * Send debug event synchronously.
-     *
-     * @param event
-     *            the debug event
-     */
-    void sendEvent(Events.DebugEvent event);
-
-    /**
-     * Send debug event asynchronously.
-     *
-     * @param event
-     *            the debug event
-     */
-    void sendEventAsync(Events.DebugEvent event);
+    IProtocolServer getProtocolServer();
 
     <T extends IProvider> T getProvider(Class<T> clazz);
 
@@ -62,10 +51,20 @@ public interface IDebugAdapterContext {
 
     void setClientLinesStartAt1(boolean clientLinesStartAt1);
 
+    boolean isClientColumnsStartAt1();
+
+    void setClientColumnsStartAt1(boolean clientColumnsStartAt1);
+
+    boolean isDebuggerColumnsStartAt1();
+
     boolean isClientPathsAreUri();
 
     void setClientPathsAreUri(boolean clientPathsAreUri);
 
+    void setSupportsRunInTerminalRequest(boolean supportsRunInTerminalRequest);
+
+    boolean supportsRunInTerminalRequest();
+
     boolean isAttached();
 
     void setAttached(boolean attached);
@@ -86,7 +85,7 @@ public interface IDebugAdapterContext {
 
     void setVariableFormatter(IVariableFormatter variableFormatter);
 
-    Map<String, String> getSourceLookupCache();
+    Map<String, Source> getSourceLookupCache();
 
     void setDebuggeeEncoding(Charset encoding);
 
@@ -95,4 +94,68 @@ public interface IDebugAdapterContext {
     void setVmTerminated();
 
     boolean isVmTerminated();
+
+    void setVmStopOnEntry(boolean stopOnEntry);
+
+    boolean isVmStopOnEntry();
+
+    void setMainClass(String mainClass);
+
+    String getMainClass();
+
+    void setStepFilters(StepFilters stepFilters);
+
+    StepFilters getStepFilters();
+
+    IStackFrameManager getStackFrameManager();
+
+    LaunchMode getLaunchMode();
+
+    void setLaunchMode(LaunchMode launchMode);
+
+    Process getDebuggeeProcess();
+
+    void setDebuggeeProcess(Process debuggeeProcess);
+
+    void setClasspathJar(Path classpathJar);
+
+    Path getClasspathJar();
+
+    void setArgsfile(Path argsfile);
+
+    Path getArgsfile();
+
+    IExceptionManager getExceptionManager();
+
+    IBreakpointManager getBreakpointManager();
+
+    IStepResultManager getStepResultManager();
+
+    void setShellProcessId(long shellProcessId);
+
+    long getShellProcessId();
+
+    void setProcessId(long processId);
+
+    long getProcessId();
+
+    void setThreadCache(ThreadCache cache);
+
+    ThreadCache getThreadCache();
+
+    boolean asyncJDWP();
+
+    boolean asyncJDWP(long usableLatency/**ms*/);
+
+    boolean isLocalDebugging();
+
+    void setLocalDebugging(boolean local);
+
+    long getJDWPLatency();
+
+    void setJDWPLatency(long baseLatency);
+
+    boolean isInitialized();
+
+    void setInitialized(boolean isInitialized);
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapterFactory.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapterFactory.java
new file mode 100644
index 000000000..d392d3b48
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugAdapterFactory.java
@@ -0,0 +1,19 @@
+/*******************************************************************************
+ * Copyright (c) 2023 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import com.microsoft.java.debug.core.protocol.IProtocolServer;
+
+@FunctionalInterface
+public interface IDebugAdapterFactory {
+    public IDebugAdapter create(IProtocolServer server);
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugRequestHandler.java
index 6a588bf11..69ad9cbd6 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IDebugRequestHandler.java
@@ -12,10 +12,19 @@
 package com.microsoft.java.debug.core.adapter;
 
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
 
 public interface IDebugRequestHandler {
     List<Requests.Command> getTargetCommands();
 
-    void handle(Requests.Command command, Requests.Arguments arguments, Messages.Response response, IDebugAdapterContext context);
+    default void initialize(IDebugAdapterContext context) {
+    }
+
+    CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context);
 
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IEvaluationProvider.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IEvaluationProvider.java
new file mode 100644
index 000000000..8cece2f58
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IEvaluationProvider.java
@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2019 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.IEvaluatableBreakpoint;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.Value;
+
+/**
+ * An evaluation engine performs an evaluation of a code snippet or expression
+ * in a specified thread of a debug target. An evaluation engine is associated
+ * with a specific debug target and Java project on creation.
+ */
+public interface IEvaluationProvider extends IProvider {
+    /**
+     * This method provides the event hub the ability to exclude the breakpoint event raised during evaluation.
+     * @param thread the thread to be checked against evaluation work.
+     * @return whether or not the thread is performing evaluation
+     */
+    boolean isInEvaluation(ThreadReference thread);
+
+    /**
+     * Evaluate the expression in the context of the specified stack frame, return the promise which is to be resolved/rejected when
+     * the evaluation finishes.
+     *
+     * @param expression The expression to be evaluated
+     * @param thread The suspended thread the evaluation will be executed at
+     * @param depth The stack frame depth in the suspended thread
+     * @return the evaluation result future
+     */
+    CompletableFuture<Value> evaluate(String expression, ThreadReference thread, int depth);
+
+    /**
+     * Evaluate the expression in the context of the specified 'this' object, return the promise which is to be resolved/rejected when
+     * the evaluation finishes.
+     * @param expression The expression to be evaluated
+     * @param thisContext The 'this' context for the evaluation
+     * @param thread The suspended thread which the evaluation will be executed at
+     * @return the evaluation result future
+     */
+    CompletableFuture<Value> evaluate(String expression, ObjectReference thisContext, ThreadReference thread);
+
+    /**
+     * Evaluate the conditional breakpoint or logpoint at the given thread and return the promise which is to be resolved/rejected when
+     * the evaluation finishes.
+     *
+     * @param breakpoint The evaluatable breakpoint
+     * @param thread The jdi thread to the expression will be executed at
+     * @return the evaluation result future
+     */
+    CompletableFuture<Value> evaluateForBreakpoint(IEvaluatableBreakpoint breakpoint, ThreadReference thread);
+
+    /**
+     * Invoke the specified method with the given arguments at this object and the given thread, and return the result.
+     * The given thread is resumed to perform the method invocation. The thread will suspend in its originallocation when the method invocation is complete.
+     * @param thisContext The 'this' context for the invocation
+     * @param methodName The method to be invoked
+     * @param methodSignature The JNI style signature of the method to be invoked
+     * @param args The arguments of the method, which can be null or empty if there are none
+     * @param thread The thread in which to invoke the method
+     * @param invokeSuper true if the method lookup should begin in thisobject's superclass
+     * @return The result of invoking the method
+     */
+    CompletableFuture<Value> invokeMethod(ObjectReference thisContext, String methodName, String methodSignature,
+            Value[] args, ThreadReference thread, boolean invokeSuper);
+
+    /**
+     * Call this method when the thread is to be resumed by user, it will first cancel ongoing evaluation tasks on specified thread and
+     * ensure the inner states is cleaned.
+     *
+     * @param thread the JDI thread reference where the evaluation task is executing at
+     */
+    void clearState(ThreadReference thread);
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IExceptionManager.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IExceptionManager.java
new file mode 100644
index 000000000..eca1c80bb
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IExceptionManager.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+* Copyright (c) 2019 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import com.microsoft.java.debug.core.JdiExceptionReference;
+
+public interface IExceptionManager {
+    /**
+     * Returns the Exception associated with the thread.
+     */
+    JdiExceptionReference getException(long threadId);
+
+    /**
+     * Removes the Exception associated with the thread. Returns the previous Exception mapping to the thread,
+     * null if no mapping exists.
+     */
+    JdiExceptionReference removeException(long threadId);
+
+    /**
+     * Associates an Exception with the thread. Returns the previous Exception mapping to the thread,
+     * null if no mapping exists before.
+     */
+    JdiExceptionReference setException(long threadId, JdiExceptionReference exception);
+
+    /**
+     * Clear all Exceptions.
+     */
+    void removeAllExceptions();
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IHotCodeReplaceProvider.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IHotCodeReplaceProvider.java
new file mode 100644
index 000000000..0760c432e
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IHotCodeReplaceProvider.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+
+import io.reactivex.Observable;
+
+public interface IHotCodeReplaceProvider extends IProvider {
+    void onClassRedefined(Consumer<List<String>> consumer);
+
+    CompletableFuture<List<String>> redefineClasses();
+
+    Observable<HotCodeReplaceEvent> getEventHub();
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IProvider.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IProvider.java
index 7be0f400d..86c30929c 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IProvider.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IProvider.java
@@ -11,24 +11,23 @@
 
 package com.microsoft.java.debug.core.adapter;
 
-import java.util.HashMap;
 import java.util.Map;
 
 public interface IProvider {
     /**
      * Initialize this provider.
-     * @param options the options
+     *
+     * @param debugContext
+     *            The associated debug context
+     * @param options
+     *            the options
      */
-    default void initialize(Map<String, Object> options) {
-
+    default void initialize(IDebugAdapterContext debugContext, Map<String, Object> options) {
     }
 
     /**
-     * Get the default options for this provider.
-     *
-     * @return The default options.
+     * Close the provider and free all associated resources.
      */
-    default Map<String, Object> getDefaultOptions() {
-        return new HashMap<>();
+    default void close() {
     }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ISourceLookUpProvider.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ISourceLookUpProvider.java
index 12f9756ab..f33742852 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ISourceLookUpProvider.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ISourceLookUpProvider.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2017 Microsoft Corporation and others.
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -8,17 +8,137 @@
  * Contributors:
  *     Microsoft Corporation - initial API and implementation
  *******************************************************************************/
-
 package com.microsoft.java.debug.core.adapter;
 
+import java.util.List;
+import java.util.Objects;
+
 import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.JavaBreakpointLocation;
+import com.microsoft.java.debug.core.protocol.Types.SourceBreakpoint;
 
 public interface ISourceLookUpProvider extends IProvider {
     boolean supportsRealtimeBreakpointVerification();
 
+    /**
+     * Deprecated, please use {@link #getBreakpointLocations(String, SourceBreakpoint[])} instead.
+     */
+    @Deprecated
     String[] getFullyQualifiedName(String uri, int[] lines, int[] columns) throws DebugException;
 
+    /**
+     * Given a set of source breakpoint locations with line and column numbers,
+     * verify if they are valid breakpoint locations. If it's a valid location,
+     * resolve its enclosing class name, method name and signature (for method
+     * breakpoint) and all possible inline breakpoint locations in that line.
+     *
+     * @param sourceUri
+     *                  the source file uri
+     * @param sourceBreakpoints
+     *                  the source breakpoints with line and column numbers
+     * @return Locations of Breakpoints containing context class and method information.
+     */
+    JavaBreakpointLocation[] getBreakpointLocations(String sourceUri, SourceBreakpoint[] sourceBreakpoints) throws DebugException;
+
+    /**
+     * Deprecated, please use {@link #getSource(String, String)} instead.
+     */
+    @Deprecated
     String getSourceFileURI(String fullyQualifiedName, String sourcePath);
 
     String getSourceContents(String uri);
+
+    /**
+     * Retrieves a {@link Source} object representing the source code associated with the given fully qualified class name and source file path.
+     * The implementation of this interface can determine a source is "local" or "remote".
+     * In case of "remote" a follow up "source" request will be issued by the client
+     *
+     * @param fullyQualifiedName
+     *                  the fully qualified class name,
+     *                  e.g., "com.microsoft.java.debug.core.adapter.ISourceLookUpProvider".
+     * @param sourcePath
+     *                  the qualified source file path,
+     *                  e.g., "com/microsoft/java/debug/core/adapter/ISourceLookupProvider.java".
+     * @return A {@link Source} object encapsulating the source file URI obtained from
+     *                  {@link #getSourceFileURI(String, String)} and the source type as {@link SourceType#LOCAL}.
+     */
+    default Source getSource(String fullyQualifiedName, String sourcePath) {
+        return new Source(getSourceFileURI(fullyQualifiedName, sourcePath), SourceType.LOCAL);
+    }
+
+    /**
+     * Returns the Java runtime that the specified project's build path used.
+     * @param projectName
+     *                  the specified project name
+     * @return the Java runtime version the specified project used. null if projectName is empty or doesn't exist.
+     */
+    default String getJavaRuntimeVersion(String projectName) {
+        return null;
+    }
+
+    /**
+     * Return method invocation found in the statement as the given line number of
+     * the source file.
+     *
+     * @param uri The source file where the invocation must be searched.
+     * @param line The line number where the invocation must be searched.
+     *
+     * @return List of found method invocation or empty if not method invocations
+     *         can be found.
+     */
+    List<MethodInvocation> findMethodInvocations(String uri, int line);
+
+    /**
+     * Return the line mappings from the original line to the decompiled line.
+     *
+     * @param uri The uri
+     * @return the line mappings from the original line to the decompiled line.
+     */
+    default int[] getOriginalLineMappings(String uri) {
+        return null;
+    }
+
+    /**
+     * Return the line mappings from the decompiled line to the original line.
+     *
+     * @param uri The uri
+     * @return the line mappings from the decompiled line to the original line.
+     */
+    default int[] getDecompiledLineMappings(String uri) {
+        return null;
+    }
+
+    public static class MethodInvocation {
+        public String expression;
+        public String methodName;
+        public String methodSignature;
+        public String methodGenericSignature;
+        public String declaringTypeName;
+        public int lineStart;
+        public int lineEnd;
+        public int columnStart;
+        public int columnEnd;
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(expression, methodName, methodSignature, methodGenericSignature, declaringTypeName,
+                    lineStart, lineEnd, columnStart, columnEnd);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof MethodInvocation)) {
+                return false;
+            }
+            MethodInvocation other = (MethodInvocation) obj;
+            return Objects.equals(expression, other.expression) && Objects.equals(methodName, other.methodName)
+                    && Objects.equals(methodSignature, other.methodSignature)
+                    && Objects.equals(methodGenericSignature, other.methodGenericSignature)
+                    && Objects.equals(declaringTypeName, other.declaringTypeName) && lineStart == other.lineStart
+                    && lineEnd == other.lineEnd && columnStart == other.columnStart && columnEnd == other.columnEnd;
+        }
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IStackFrameManager.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IStackFrameManager.java
new file mode 100644
index 000000000..8d6c74486
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IStackFrameManager.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
+import com.sun.jdi.StackFrame;
+import com.sun.jdi.ThreadReference;
+
+public interface IStackFrameManager {
+    /**
+     * Get a jdi stack frame from stack frame reference.
+     *
+     * @param ref the stackframe reference
+     * @return the jdi stackframe
+     */
+    StackFrame getStackFrame(StackFrameReference ref);
+
+    /**
+     * Refresh all stackframes from jdi thread.
+     *
+     * @param thread the jdi thread
+     * @return all the stackframes in the specified thread
+     */
+    StackFrame[] reloadStackFrames(ThreadReference thread);
+
+    /**
+     * Refresh all stackframes from jdi thread.
+     *
+     * @param thread the jdi thread
+     * @param force Whether to load the whole frames if the thread's stackframes haven't been cached.
+     * @return all the stackframes in the specified thread
+     */
+    StackFrame[] reloadStackFrames(ThreadReference thread, boolean force);
+
+    /**
+     * Refersh the stackframes starting from the specified depth and length.
+     *
+     * @param thread the jdi thread
+     * @param start the index of the first frame to refresh. Index 0 represents the current frame.
+     * @param length the number of frames to refersh
+     * @return the refreshed stackframes
+     */
+    StackFrame[] reloadStackFrames(ThreadReference thread, int start, int length);
+
+    /**
+     * Clear the stackframes cache from the specified thread.
+     *
+     * @param thread the jdi thread
+     */
+    void clearStackFrames(ThreadReference thread);
+
+    /**
+     * Clear the whole stackframes cache.
+     */
+    void clearStackFrames();
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IStepResultManager.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IStepResultManager.java
new file mode 100644
index 000000000..c19c0ecd6
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IStepResultManager.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+* Copyright (c) 2020 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import com.microsoft.java.debug.core.JdiMethodResult;
+
+public interface IStepResultManager {
+    JdiMethodResult setMethodResult(long threadId, JdiMethodResult methodResult);
+
+    JdiMethodResult getMethodResult(long threadId);
+
+    JdiMethodResult removeMethodResult(long threadId);
+
+    void removeAllMethodResults();
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IVirtualMachineManager.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IVirtualMachineManager.java
new file mode 100644
index 000000000..095c070bf
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/IVirtualMachineManager.java
@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2020 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+public interface IVirtualMachineManager extends com.sun.jdi.VirtualMachineManager {
+    boolean connectVirtualMachine(com.sun.jdi.VirtualMachine vm);
+
+    boolean disconnectVirtualMachine(com.sun.jdi.VirtualMachine vm);
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/LaunchMode.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/LaunchMode.java
new file mode 100644
index 000000000..0c3b4ee48
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/LaunchMode.java
@@ -0,0 +1,17 @@
+/*******************************************************************************
+* Copyright (c) 2018 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+public enum LaunchMode {
+    DEBUG,
+    NO_DEBUG
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ProcessConsole.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ProcessConsole.java
index de066bcaa..3d823df91 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ProcessConsole.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ProcessConsole.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2019 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -17,18 +17,18 @@
 import java.io.InputStreamReader;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.util.stream.Stream;
 
-import io.reactivex.functions.Consumer;
+import com.microsoft.java.debug.core.protocol.Events.OutputEvent.Category;
+
+import io.reactivex.Observable;
+import io.reactivex.schedulers.Schedulers;
 import io.reactivex.subjects.PublishSubject;
 
 public class ProcessConsole {
-    private Process process;
-    private String name;
-    private Charset encoding;
-    private PublishSubject<String> stdoutSubject = PublishSubject.<String>create();
-    private PublishSubject<String> stderrSubject = PublishSubject.<String>create();
-    private Thread stdoutThread = null;
-    private Thread stderrThread = null;
+    private InputStreamObservable stdoutStream;
+    private InputStreamObservable stderrStream;
+    private Observable<ConsoleMessage> observable = null;
 
     public ProcessConsole(Process process) {
         this(process, "Process", StandardCharsets.UTF_8);
@@ -44,76 +44,126 @@ public ProcessConsole(Process process) {
      *              the process encoding format
      */
     public ProcessConsole(Process process, String name, Charset encoding) {
-        this.process = process;
-        this.name = name;
-        this.encoding = encoding;
+        this.stdoutStream = new InputStreamObservable(name + " Stdout Handler", process.getInputStream(), encoding);
+        this.stderrStream = new InputStreamObservable(name + " Stderr Handler", process.getErrorStream(), encoding);
+        Observable<ConsoleMessage> stdout = this.stdoutStream.messages().map((message) -> new ConsoleMessage(message, Category.stdout));
+        Observable<ConsoleMessage> stderr = this.stderrStream.messages().map((message) -> new ConsoleMessage(message, Category.stderr));
+        this.observable = Observable.mergeArrayDelayError(stdout, stderr).observeOn(Schedulers.newThread());
     }
 
     /**
-     * Start two separate threads to monitor the messages from stdout and stderr streams of the target process.
+     * Start monitoring the stdout/stderr streams of the target process.
      */
     public void start() {
-        this.stdoutThread = new Thread(this.name + " Stdout Handler") {
-            public void run() {
-                monitor(process.getInputStream(), stdoutSubject);
-            }
-        };
-        stdoutThread.setDaemon(true);
-        stdoutThread.start();
-
-        this.stderrThread = new Thread(this.name + " Stderr Handler") {
-            public void run() {
-                monitor(process.getErrorStream(), stderrSubject);
-            }
-        };
-        stderrThread.setDaemon(true);
-        stderrThread.start();
+        stdoutStream.start();
+        stderrStream.start();
     }
 
     /**
-     * Stop the process console handlers.
+     * Stop monitoring the process console.
      */
     public void stop() {
-        if (this.stdoutThread != null) {
-            this.stdoutThread.interrupt();
-            this.stdoutThread = null;
-        }
+        stdoutStream.stop();
+        stderrStream.stop();
+    }
 
-        if (this.stderrThread != null) {
-            this.stderrThread.interrupt();
-            this.stderrThread = null;
-        }
+    public Observable<ConsoleMessage> messages() {
+        return observable;
     }
 
-    public void onStdout(Consumer<String> callback) {
-        stdoutSubject.subscribe(callback);
+    public Observable<ConsoleMessage> stdoutMessages() {
+        return this.messages().filter((message) -> message.category == Category.stdout);
     }
 
-    public void onStderr(Consumer<String> callback) {
-        stderrSubject.subscribe(callback);
+    public Observable<ConsoleMessage> stderrMessages() {
+        return this.messages().filter((message) -> message.category == Category.stderr);
     }
 
-    private void monitor(InputStream input, PublishSubject<String> subject) {
-        BufferedReader reader = new BufferedReader(new InputStreamReader(input, encoding));
-        final int BUFFERSIZE = 4096;
-        char[] buffer = new char[BUFFERSIZE];
-        while (true) {
-            try {
-                if (Thread.interrupted()) {
-                    subject.onComplete();
-                    return;
+    /**
+     * Split the stdio message to lines, and return them as a new Observable.
+     */
+    public Observable<ConsoleMessage> lineMessages() {
+        return this.messages().map((message) -> {
+            String[] lines = message.output.split("(?<=\n)");
+            return Stream.of(lines).map((line) -> new ConsoleMessage(line, message.category)).toArray(ConsoleMessage[]::new);
+        }).concatMap((lines) -> Observable.fromArray(lines));
+    }
+
+    public static class InputStreamObservable {
+        private PublishSubject<String> rxSubject = PublishSubject.<String>create();
+        private String name;
+        private InputStream inputStream;
+        private Charset encoding;
+        private Thread loopingThread;
+
+        /**
+         * Constructor.
+         */
+        public InputStreamObservable(String name, InputStream inputStream, Charset encoding) {
+            this.name = name;
+            this.inputStream = inputStream;
+            this.encoding = encoding;
+        }
+
+        /**
+         * Starts the stream.
+         */
+        public void start() {
+            loopingThread = new Thread(name) {
+                public void run() {
+                    monitor(inputStream, rxSubject);
                 }
-                int read = reader.read(buffer, 0, BUFFERSIZE);
-                if (read == -1) {
-                    subject.onComplete();
+            };
+            loopingThread.setDaemon(true);
+            loopingThread.start();
+        }
+
+        /**
+         * Stops the stream.
+         */
+        public void stop() {
+            if (loopingThread != null) {
+                loopingThread.interrupt();
+                loopingThread = null;
+            }
+        }
+
+        private void monitor(InputStream input, PublishSubject<String> subject) {
+            BufferedReader reader = new BufferedReader(encoding == null ? new InputStreamReader(input) : new InputStreamReader(input, encoding));
+            final int BUFFERSIZE = 4096;
+            char[] buffer = new char[BUFFERSIZE];
+            while (true) {
+                try {
+                    if (Thread.interrupted()) {
+                        subject.onComplete();
+                        return;
+                    }
+                    int read = reader.read(buffer, 0, BUFFERSIZE);
+                    if (read == -1) {
+                        subject.onComplete();
+                        return;
+                    }
+
+                    subject.onNext(new String(buffer, 0, read));
+                } catch (IOException e) {
+                    subject.onError(e);
                     return;
                 }
-
-                subject.onNext(new String(buffer, 0, read));
-            } catch (IOException e) {
-                subject.onError(e);
-                return;
             }
         }
+
+        public Observable<String> messages() {
+            return rxSubject;
+        }
+    }
+
+    public static class ConsoleMessage {
+        public String output;
+        public Category category;
+
+        public ConsoleMessage(String message, Category category) {
+            this.output = message;
+            this.category = category;
+        }
     }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ProtocolServer.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ProtocolServer.java
index 172db6ce7..9e503e0af 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ProtocolServer.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ProtocolServer.java
@@ -11,50 +11,33 @@
 
 package com.microsoft.java.debug.core.adapter;
 
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.IOException;
 import java.io.InputStream;
-import java.io.InputStreamReader;
 import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.Reader;
-import java.io.Writer;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
 import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugException;
 import com.microsoft.java.debug.core.UsageDataSession;
+import com.microsoft.java.debug.core.protocol.AbstractProtocolServer;
+import com.microsoft.java.debug.core.protocol.Events.DebugEvent;
+import com.microsoft.java.debug.core.protocol.Events.StoppedEvent;
+import com.microsoft.java.debug.core.protocol.Messages;
+import com.sun.jdi.VMDisconnectedException;
 
-public class ProtocolServer {
+public class ProtocolServer extends AbstractProtocolServer {
     private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
-    private static final int BUFFER_SIZE = 4096;
-    private static final String TWO_CRLF = "\r\n\r\n";
-    private static final Pattern CONTENT_LENGTH_MATCHER = Pattern.compile("Content-Length: (\\d+)");
-    private static final Charset PROTOCOL_ENCODING = StandardCharsets.UTF_8; // vscode protocol uses UTF-8 as encoding format.
-
-    private Reader reader;
-    private Writer writer;
-
-    private ByteBuffer rawData;
-    private boolean terminateSession = false;
-    private int contentLength = -1;
-    private AtomicInteger sequenceNumber = new AtomicInteger(1);
-
-    private boolean isDispatchingData;
-    private ConcurrentLinkedQueue<Messages.Event> eventQueue;
 
     private IDebugAdapter debugAdapter;
-
     private UsageDataSession usageDataSession = new UsageDataSession();
 
+    private Object lock = new Object();
+    private boolean isDispatchingRequest = false;
+    private ConcurrentLinkedQueue<DebugEvent> eventQueue = new ConcurrentLinkedQueue<>();
+
     /**
      * Constructs a protocol server instance based on the given input stream and output stream.
      * @param input
@@ -65,200 +48,131 @@ public class ProtocolServer {
      *              provider context for a series of provider implementation
      */
     public ProtocolServer(InputStream input, OutputStream output, IProviderContext context) {
-        this.reader = new BufferedReader(new InputStreamReader(input, PROTOCOL_ENCODING));
-        this.writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(output, PROTOCOL_ENCODING)));
-        this.contentLength = -1;
-        this.rawData = new ByteBuffer();
-        this.eventQueue = new ConcurrentLinkedQueue<>();
-        this.debugAdapter = new DebugAdapter((debugEvent, willSendLater) -> {
-            // If the protocolServer has been stopped, it'll no longer receive any event.
-            if (!terminateSession) {
-                if (willSendLater) {
-                    this.sendEventLater(debugEvent.type, debugEvent);
-                } else {
-                    this.sendEvent(debugEvent.type, debugEvent);
-                }
-            }
-        }, context);
+        super(input, output);
+        debugAdapter = new DebugAdapter(this, context);
     }
 
     /**
-     * A while-loop to parse input data and send output data constantly.
+     * Constructs a protocol server instance based on the given input stream and output stream.
+     * @param input
+     *              the input stream
+     * @param output
+     *              the output stream
+     * @param debugAdapterFactory
+     *              factory to create debug adapter that implements DAP communication
      */
-    public void start() {
-        usageDataSession.reportStart();
-        char[] buffer = new char[BUFFER_SIZE];
-        try {
-            while (!this.terminateSession) {
-                int read = this.reader.read(buffer, 0, BUFFER_SIZE);
-                if (read == -1) {
-                    break;
-                }
-
-                this.rawData.append(new String(buffer, 0, read).getBytes(PROTOCOL_ENCODING));
-                this.processData();
-            }
-        } catch (IOException e) {
-            logger.log(Level.SEVERE, String.format("Read data from io exception: %s", e.toString()), e);
-        }
+    public ProtocolServer(InputStream input, OutputStream output, IDebugAdapterFactory debugAdapterFactory) {
+        super(input, output);
+        debugAdapter = debugAdapterFactory.create(this);
     }
 
     /**
-     * Sets terminateSession flag to true. And the dispatcher loop will be terminated after current dispatching operation finishes.
+     * A while-loop to parse input data and send output data constantly.
      */
-    public void stop() {
+    @Override
+    public void run() {
+        usageDataSession.reportStart();
+        super.run();
         usageDataSession.reportStop();
-        this.terminateSession = true;
         usageDataSession.submitUsageData();
     }
 
-    /**
-     * Send event to DA immediately.
-     * @param eventType
-     *                 event type
-     * @param body
-     *                 event body
-     */
-    private void sendEvent(String eventType, Object body) {
-        sendMessage(new Messages.Event(eventType, body));
+    @Override
+    public void sendResponse(Messages.Response response) {
+        usageDataSession.recordResponse(response);
+        super.sendResponse(response);
     }
 
-    /**
-     * If the the dispatcher is idle, then send the event immediately.
-     * Else add the new event to an eventQueue first and send them when dispatcher becomes idle again.
-     * @param eventType
-     *              event type
-     * @param body
-     *              event content
-     */
-    private void sendEventLater(String eventType, Object body) {
-        synchronized (this) {
-            if (this.isDispatchingData) {
-                this.eventQueue.offer(new Messages.Event(eventType, body));
-            } else {
-                sendMessage(new Messages.Event(eventType, body));
-            }
-        }
+    @Override
+    public CompletableFuture<Messages.Response> sendRequest(Messages.Request request) {
+        usageDataSession.recordRequest(request);
+        return super.sendRequest(request);
     }
 
-    private void sendMessage(Messages.ProtocolMessage message) {
-        message.seq = this.sequenceNumber.getAndIncrement();
-
-        String jsonMessage = JsonUtils.toJson(message);
-        byte[] jsonBytes = jsonMessage.getBytes(PROTOCOL_ENCODING);
-
-        String header = String.format("Content-Length: %d%s", jsonBytes.length, TWO_CRLF);
-        byte[] headerBytes = header.getBytes(PROTOCOL_ENCODING);
-
-        byte[] data = new byte[headerBytes.length + jsonBytes.length];
-        System.arraycopy(headerBytes, 0, data, 0, headerBytes.length);
-        System.arraycopy(jsonBytes, 0, data, headerBytes.length, jsonBytes.length);
-
-        String utf8Data = new String(data, PROTOCOL_ENCODING);
+    @Override
+    public CompletableFuture<Messages.Response> sendRequest(Messages.Request request, long timeout) {
+        usageDataSession.recordRequest(request);
+        return super.sendRequest(request, timeout);
+    }
 
-        try {
-            logger.fine("\n[[RESPONSE]]\n" + new String(data));
-            this.writer.write(utf8Data);
-            this.writer.flush();
-        } catch (IOException e) {
-            logger.log(Level.SEVERE, String.format("Write data to io exception: %s", e.toString()), e);
+    @Override
+    public void sendEvent(DebugEvent event) {
+        // See the two bugs https://github.com/Microsoft/java-debug/issues/134 and https://github.com/Microsoft/vscode/issues/58327,
+        // it requires the java-debug to send the StoppedEvent after ContinueResponse/StepResponse is received by DA.
+        if (event instanceof StoppedEvent) {
+            sendEventLater(event);
+        } else {
+            super.sendEvent(event);
         }
+
     }
 
-    private void processData() {
-        while (true) {
-            /**
-             * In vscode debug protocol, the content length represents the message's byte length with utf8 format.
-             */
-            if (this.contentLength >= 0) {
-                if (this.rawData.length() >= this.contentLength) {
-                    byte[] buf = this.rawData.removeFirst(this.contentLength);
-                    this.contentLength = -1;
-                    dispatchRequest(new String(buf, PROTOCOL_ENCODING));
-                    continue;
-                }
+    /**
+     * If the the dispatcher is idle, then send the event to the DA immediately.
+     * Else add the new event to an eventQueue first and send them when dispatcher becomes idle again.
+     */
+    private void sendEventLater(DebugEvent event) {
+        synchronized (lock) {
+            if (this.isDispatchingRequest) {
+                this.eventQueue.offer(event);
             } else {
-                String rawMessage = this.rawData.getString(PROTOCOL_ENCODING);
-                int idx = rawMessage.indexOf(TWO_CRLF);
-                if (idx != -1) {
-                    Matcher matcher = CONTENT_LENGTH_MATCHER.matcher(rawMessage);
-                    if (matcher.find()) {
-                        this.contentLength = Integer.parseInt(matcher.group(1));
-                        int headerByteLength = rawMessage.substring(0, idx + TWO_CRLF.length()).getBytes(PROTOCOL_ENCODING).length;
-                        this.rawData.removeFirst(headerByteLength); // Remove the header from the raw message.
-                        continue;
-                    }
-                }
+                super.sendEvent(event);
             }
-            break;
         }
     }
 
-    private void dispatchRequest(String request) {
+    @Override
+    protected void dispatchRequest(Messages.Request request) {
+        usageDataSession.recordRequest(request);
         try {
-            logger.fine("\n[REQUEST]\n" + request);
-            Messages.Request message = JsonUtils.fromJson(request, Messages.Request.class);
-            usageDataSession.recordRequest(message);
-            if (message.type.equals("request")) {
-                synchronized (this) {
-                    this.isDispatchingData = true;
+            synchronized (lock) {
+                this.isDispatchingRequest = true;
+            }
+
+            debugAdapter.dispatchRequest(request).thenCompose((response) -> {
+                CompletableFuture<Void> future = new CompletableFuture<>();
+                if (response != null) {
+                    sendResponse(response);
+                    future.complete(null);
+                } else {
+                    future.completeExceptionally(new DebugException("The request dispatcher should not return null response.",
+                            ErrorCode.UNKNOWN_FAILURE.getId()));
+                }
+                return future;
+            }).exceptionally((ex) -> {
+                Messages.Response response = new Messages.Response(request.seq, request.command);
+                if (ex instanceof CompletionException && ex.getCause() != null) {
+                    ex = ex.getCause();
                 }
 
-                try {
-                    Messages.Response response = this.debugAdapter.dispatchRequest(message);
-                    if (message.command.equals("disconnect")) {
-                        this.stop();
+                if (ex instanceof VMDisconnectedException) {
+                    // mark it success to avoid reporting error on VSCode.
+                    response.success = true;
+                    sendResponse(response);
+                } else {
+                    String exceptionMessage = ex.getMessage() != null ? ex.getMessage() : ex.toString();
+                    ErrorCode errorCode = ex instanceof DebugException ? ErrorCode.parse(((DebugException) ex).getErrorCode()) : ErrorCode.UNKNOWN_FAILURE;
+                    boolean isUserError = ex instanceof DebugException && ((DebugException) ex).isUserError();
+                    if (isUserError) {
+                        usageDataSession.recordUserError(errorCode);
+                    } else {
+                        logger.log(Level.SEVERE, String.format("[error response][%s]: %s", request.command, exceptionMessage), ex);
                     }
-                    sendMessage(response);
-                    usageDataSession.recordResponse(response);
-                } catch (Exception e) {
-                    logger.log(Level.SEVERE, String.format("Dispatch debug protocol error: %s", e.toString()), e);
+
+                    sendResponse(AdapterUtils.setErrorResponse(response,
+                            errorCode,
+                            exceptionMessage));
                 }
-            }
+                return null;
+            }).join();
         } finally {
-            synchronized (this) {
-                this.isDispatchingData = false;
+            synchronized (lock) {
+                this.isDispatchingRequest = false;
             }
 
             while (this.eventQueue.peek() != null) {
-                sendMessage(this.eventQueue.poll());
+                super.sendEvent(this.eventQueue.poll());
             }
         }
     }
-
-    class ByteBuffer {
-        private byte[] buffer;
-
-        public ByteBuffer() {
-            this.buffer = new byte[0];
-        }
-
-        public int length() {
-            return this.buffer.length;
-        }
-
-        public String getString(Charset cs) {
-            return new String(this.buffer, cs);
-        }
-
-        public void append(byte[] b) {
-            append(b, b.length);
-        }
-
-        public void append(byte[] b, int length) {
-            byte[] newBuffer = new byte[this.buffer.length + length];
-            System.arraycopy(buffer, 0, newBuffer, 0, this.buffer.length);
-            System.arraycopy(b, 0, newBuffer, this.buffer.length, length);
-            this.buffer = newBuffer;
-        }
-
-        public byte[] removeFirst(int n) {
-            byte[] b = new byte[n];
-            System.arraycopy(this.buffer, 0, b, 0, n);
-            byte[] newBuffer = new byte[this.buffer.length - n];
-            System.arraycopy(this.buffer, n, newBuffer, 0, this.buffer.length - n);
-            this.buffer = newBuffer;
-            return b;
-        }
-    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Requests.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Requests.java
deleted file mode 100644
index 170c6e885..000000000
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Requests.java
+++ /dev/null
@@ -1,212 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*     Microsoft Corporation - initial API and implementation
-*******************************************************************************/
-
-package com.microsoft.java.debug.core.adapter;
-
-import java.util.Arrays;
-
-/**
- * The request arguments types defined by VSCode Debug Protocol.
- */
-public class Requests {
-
-    public static class ValueFormat {
-        public boolean hex;
-    }
-
-    public static class Arguments {
-
-    }
-
-    public static class InitializeArguments extends Arguments {
-        public String clientID;
-        public String adapterID;
-        public String pathFormat;
-        public boolean linesStartAt1;
-        public boolean columnsStartAt1;
-        public boolean supportsVariableType;
-        public boolean supportsVariablePaging;
-        public boolean supportsRunInTerminalRequest;
-    }
-
-    public static class LaunchArguments extends Arguments {
-        public String type;
-        public String name;
-        public String request;
-        public String projectName;
-        public String mainClass;
-        public String args = "";
-        public String vmArgs = "";
-        public String encoding = "";
-        public String[] classPaths = new String[0];
-        public String[] sourcePaths = new String[0];
-    }
-
-    public static class AttachArguments extends Arguments {
-        public String type;
-        public String name;
-        public String request;
-        public String hostName;
-        public int port;
-        public int timeout = 30000; // Default to 30s.
-        public String[] sourcePaths = new String[0];
-        public String projectName;
-    }
-
-    public static class RestartArguments extends Arguments {
-
-    }
-
-    public static class DisconnectArguments extends Arguments {
-        // If client doesn't set terminateDebuggee attribute at the DisconnectRequest,
-        // the debugger would choose to terminate debuggee by default.
-        public boolean terminateDebuggee = true;
-        public boolean restart;
-    }
-
-    public static class ConfigurationDoneArguments extends Arguments {
-
-    }
-
-    public static class SetBreakpointArguments extends Arguments {
-        public Types.Source source;
-        public int[] lines = new int[0];
-        public Types.SourceBreakpoint[] breakpoints = new Types.SourceBreakpoint[0];
-        public boolean sourceModified = false;
-    }
-
-    public static class StackTraceArguments extends Arguments {
-        public long threadId;
-        public int startFrame;
-        public int levels;
-    }
-
-    public static class SetFunctionBreakpointsArguments extends Arguments {
-        public Types.FunctionBreakpoint[] breakpoints;
-    }
-
-    public static class SetExceptionBreakpointsArguments extends Arguments {
-        public String[] filters = new String[0];
-    }
-
-    public static class ThreadsArguments extends Arguments {
-
-    }
-
-    public static class ContinueArguments extends Arguments {
-        public long threadId;
-    }
-
-    public static class NextArguments extends Arguments {
-        public long threadId;
-    }
-
-    public static class StepInArguments extends Arguments {
-        public long threadId;
-        public int targetId;
-    }
-
-    public static class StepOutArguments extends Arguments {
-        public long threadId;
-    }
-
-    public static class PauseArguments extends Arguments {
-        public long threadId;
-    }
-
-    public static class ScopesArguments extends Arguments {
-        public int frameId;
-    }
-
-    public static class VariablesArguments extends Arguments {
-        public int variablesReference = -1;
-        public String filter;
-        public int start;
-        public int count;
-        public ValueFormat format;
-    }
-
-    public static class SetVariableArguments extends Arguments {
-        public int variablesReference;
-        public String name;
-        public String value;
-        public ValueFormat format;
-    }
-
-    public static class SourceArguments extends Arguments {
-        public int sourceReference;
-    }
-
-    public static class EvaluateArguments extends Arguments {
-        public String expression;
-        public int frameId;
-        public String context;
-        public ValueFormat format;
-    }
-
-    public static enum Command {
-        INITIALIZE("initialize", InitializeArguments.class),
-        LAUNCH("launch", LaunchArguments.class),
-        ATTACH("attach", AttachArguments.class),
-        DISCONNECT("disconnect", DisconnectArguments.class),
-        CONFIGURATIONDONE("configurationDone", ConfigurationDoneArguments.class),
-        NEXT("next", NextArguments.class),
-        CONTINUE("continue", ContinueArguments.class),
-        STEPIN("stepIn", StepInArguments.class),
-        STEPOUT("stepOut", StepOutArguments.class),
-        PAUSE("pause", PauseArguments.class),
-        STACKTRACE("stackTrace", StackTraceArguments.class),
-        SCOPES("scopes", ScopesArguments.class),
-        VARIABLES("variables", VariablesArguments.class),
-        SETVARIABLE("setVariable", SetVariableArguments.class),
-        SOURCE("source", SourceArguments.class),
-        THREADS("threads", ThreadsArguments.class),
-        SETBREAKPOINTS("setBreakpoints", SetBreakpointArguments.class),
-        SETEXCEPTIONBREAKPOINTS("setExceptionBreakpoints", SetExceptionBreakpointsArguments.class),
-        SETFUNCTIONBREAKPOINTS("setFunctionBreakpoints", SetFunctionBreakpointsArguments.class),
-        EVALUATE("evaluate", EvaluateArguments.class),
-        UNSUPPORTED("", Arguments.class);
-
-        private String command;
-        private Class<? extends Arguments> argumentType;
-
-        Command(String command, Class<? extends Arguments> argumentType) {
-            this.command = command;
-            this.argumentType = argumentType;
-        }
-
-        public String toString() {
-            return this.command;
-        }
-
-        public Class<? extends Arguments> getArgumentType() {
-            return this.argumentType;
-        }
-
-        /**
-         * Get the corresponding Command type by the command name.
-         * If the command is not defined in the enum type, return UNSUPPORTED.
-         * @param command
-         *             the command name
-         * @return the Command type
-         */
-        public static Command parse(String command) {
-            Command[] found = Arrays.stream(Command.values()).filter(cmd -> {
-                return cmd.toString().equals(command);
-            }).toArray(Command[]::new);
-
-            if (found.length > 0) {
-                return found[0];
-            }
-            return UNSUPPORTED;
-        }
-    }
-}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Source.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Source.java
new file mode 100644
index 000000000..d00b4cb4c
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Source.java
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+public class Source {
+    public final String uri;
+    public final SourceType type;
+
+    public Source(String uri, SourceType type) {
+        this.uri = uri;
+        this.type = type;
+    }
+
+    public String getUri() {
+        return this.uri;
+    }
+
+    public SourceType getType() {
+        return this.type;
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/SourceType.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/SourceType.java
new file mode 100644
index 000000000..724bf3bda
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/SourceType.java
@@ -0,0 +1,16 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+package com.microsoft.java.debug.core.adapter;
+
+public enum SourceType {
+    REMOTE,
+    LOCAL
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/StackFrameManager.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/StackFrameManager.java
new file mode 100644
index 000000000..518cc7761
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/StackFrameManager.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
+import com.sun.jdi.IncompatibleThreadStateException;
+import com.sun.jdi.StackFrame;
+import com.sun.jdi.ThreadReference;
+
+public class StackFrameManager implements IStackFrameManager {
+    private Map<Long, StackFrame[]> threadStackFrameMap = new HashMap<>();
+
+    @Override
+    public synchronized StackFrame getStackFrame(StackFrameReference ref) {
+        ThreadReference thread = ref.getThread();
+        int depth = ref.getDepth();
+        StackFrame[] frames = threadStackFrameMap.get(thread.uniqueID());
+        return frames == null || frames.length < depth ? null : frames[depth];
+    }
+
+    @Override
+    public synchronized StackFrame[] reloadStackFrames(ThreadReference thread) {
+        return reloadStackFrames(thread, true);
+    }
+
+    @Override
+    public synchronized StackFrame[] reloadStackFrames(ThreadReference thread, boolean force) {
+        return threadStackFrameMap.compute(thread.uniqueID(), (key, old) -> {
+            try {
+                if (old == null || old.length == 0) {
+                    if (force) {
+                        return thread.frames().toArray(new StackFrame[0]);
+                    } else {
+                        return new StackFrame[0];
+                    }
+                } else {
+                    return thread.frames(0, old.length).toArray(new StackFrame[0]);
+                }
+            } catch (IncompatibleThreadStateException e) {
+                return new StackFrame[0];
+            }
+        });
+    }
+
+    @Override
+    public synchronized StackFrame[] reloadStackFrames(ThreadReference thread, int start, int length) {
+        long threadId = thread.uniqueID();
+        StackFrame[] old = threadStackFrameMap.get(threadId);
+        try {
+            StackFrame[] newFrames = thread.frames(start, length).toArray(new StackFrame[0]);
+            if (old == null || (start == 0 && length == old.length)) {
+                threadStackFrameMap.put(threadId, newFrames);
+            } else {
+                int maxLength = Math.max(old.length, start + length);
+                StackFrame[] totalFrames = new StackFrame[maxLength];
+                System.arraycopy(old, 0, totalFrames, 0, old.length);
+                System.arraycopy(newFrames, 0, totalFrames, start, length);
+                threadStackFrameMap.put(threadId, totalFrames);
+            }
+
+            return newFrames;
+        } catch (IncompatibleThreadStateException | IndexOutOfBoundsException  e) {
+            return new StackFrame[0];
+        }
+    }
+
+    @Override
+    public synchronized void clearStackFrames(ThreadReference thread) {
+        threadStackFrameMap.remove(thread.uniqueID());
+    }
+
+    @Override
+    public synchronized void clearStackFrames() {
+        threadStackFrameMap.clear();
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/StepResultManager.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/StepResultManager.java
new file mode 100644
index 000000000..dd3937181
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/StepResultManager.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+* Copyright (c) 2020 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.microsoft.java.debug.core.JdiMethodResult;
+
+public class StepResultManager implements IStepResultManager {
+    private Map<Long, JdiMethodResult> methodResults = Collections.synchronizedMap(new HashMap<>());
+
+    @Override
+    public JdiMethodResult setMethodResult(long threadId, JdiMethodResult methodResult) {
+        return this.methodResults.put(threadId, methodResult);
+    }
+
+    @Override
+    public JdiMethodResult getMethodResult(long threadId) {
+        return this.methodResults.get(threadId);
+    }
+
+    @Override
+    public JdiMethodResult removeMethodResult(long threadId) {
+        return this.methodResults.remove(threadId);
+    }
+
+    @Override
+    public void removeAllMethodResults() {
+        this.methodResults.clear();
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ThreadCache.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ThreadCache.java
new file mode 100644
index 000000000..57d39154e
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/ThreadCache.java
@@ -0,0 +1,162 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.sun.jdi.ThreadReference;
+
+public class ThreadCache {
+    private List<ThreadReference> allThreads = new ArrayList<>();
+    private Map<Long, String> threadNameMap = new ConcurrentHashMap<>();
+    private Map<Long, Boolean> deathThreads = Collections.synchronizedMap(new LinkedHashMap<>() {
+        @Override
+        protected boolean removeEldestEntry(java.util.Map.Entry<Long, Boolean> eldest) {
+            return this.size() > 100;
+        }
+    });
+    private Map<Long, ThreadReference> eventThreads = new ConcurrentHashMap<>();
+    private Map<Long, Set<String>> decompiledClassesByThread = new HashMap<>();
+    private Map<Long, String> threadStoppedReasons = new HashMap<>();
+
+    public synchronized void resetThreads(List<ThreadReference> threads) {
+        allThreads.clear();
+        allThreads.addAll(threads);
+    }
+
+    public synchronized List<ThreadReference> getThreads() {
+        return allThreads;
+    }
+
+    public synchronized ThreadReference getThread(long threadId) {
+        for (ThreadReference thread : allThreads) {
+            if (threadId == thread.uniqueID()) {
+                return thread;
+            }
+        }
+
+        for (ThreadReference thread : eventThreads.values()) {
+            if (threadId == thread.uniqueID()) {
+                return thread;
+            }
+        }
+
+        return null;
+    }
+
+    public void setThreadName(long threadId, String name) {
+        threadNameMap.put(threadId, name);
+    }
+
+    public String getThreadName(long threadId) {
+        return threadNameMap.get(threadId);
+    }
+
+    public void addDeathThread(long threadId) {
+        threadNameMap.remove(threadId);
+        eventThreads.remove(threadId);
+        deathThreads.put(threadId, true);
+    }
+
+    public boolean isDeathThread(long threadId) {
+        return deathThreads.containsKey(threadId);
+    }
+
+    public void addEventThread(ThreadReference thread) {
+        eventThreads.put(thread.uniqueID(), thread);
+    }
+
+    public void addEventThread(ThreadReference thread, String reason) {
+        eventThreads.put(thread.uniqueID(), thread);
+        if (reason != null) {
+            threadStoppedReasons.put(thread.uniqueID(), reason);
+        }
+    }
+
+    public void removeEventThread(long threadId) {
+        eventThreads.remove(threadId);
+    }
+
+    public void clearEventThread() {
+        eventThreads.clear();
+    }
+
+    /**
+     * The visible threads includes:
+     * 1. The currently running threads returned by the JDI API
+     * VirtualMachine.allThreads().
+     * 2. The threads suspended by events such as Breakpoint, Step, Exception etc.
+     *
+     * The part 2 is mainly for virtual threads, since VirtualMachine.allThreads()
+     * does not include virtual threads by default. For those virtual threads
+     * that are suspended, we need to show their call stacks in CALL STACK view.
+     */
+    public List<ThreadReference> visibleThreads(IDebugAdapterContext context) {
+        List<ThreadReference> visibleThreads = new ArrayList<>(context.getDebugSession().getAllThreads());
+        Set<Long> idSet = new HashSet<>();
+        visibleThreads.forEach(thread -> idSet.add(thread.uniqueID()));
+        for (ThreadReference thread : eventThreads.values()) {
+            if (idSet.contains(thread.uniqueID())) {
+                continue;
+            }
+
+            idSet.add(thread.uniqueID());
+            visibleThreads.add(thread);
+        }
+
+        return visibleThreads;
+    }
+
+    public Set<String> getDecompiledClassesByThread(long threadId) {
+        return decompiledClassesByThread.get(threadId);
+    }
+
+    public void setDecompiledClassesByThread(long threadId, Set<String> decompiledClasses) {
+        if (decompiledClasses == null || decompiledClasses.isEmpty()) {
+            decompiledClassesByThread.remove(threadId);
+            return;
+        }
+
+        decompiledClassesByThread.put(threadId, decompiledClasses);
+    }
+
+    public String getThreadStoppedReason(long threadId) {
+        return threadStoppedReasons.get(threadId);
+    }
+
+    public void setThreadStoppedReason(long threadId, String reason) {
+        if (reason == null) {
+            threadStoppedReasons.remove(threadId);
+            return;
+        }
+
+        threadStoppedReasons.put(threadId, reason);
+    }
+
+    public void clearThreadStoppedState(long threadId) {
+        threadStoppedReasons.remove(threadId);
+        decompiledClassesByThread.remove(threadId);
+    }
+
+    public void clearAllThreadStoppedState() {
+        threadStoppedReasons.clear();
+        decompiledClassesByThread.clear();
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Types.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Types.java
deleted file mode 100644
index 73d88bef9..000000000
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Types.java
+++ /dev/null
@@ -1,223 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*     Microsoft Corporation - initial API and implementation
-*******************************************************************************/
-
-package com.microsoft.java.debug.core.adapter;
-
-import java.nio.file.Paths;
-
-/**
- * The data types defined by VSCode Debug Protocol.
- */
-public class Types {
-    public static class Message {
-        public int id;
-        public String format;
-
-        /**
-         * Constructs a message with the given information.
-         * @param id
-         *          message id
-         * @param format
-         *          a format string
-         */
-        public Message(int id, String format) {
-            this.id = id;
-            this.format = format;
-        }
-    }
-
-    public static class StackFrame {
-        public int id;
-        public Source source;
-        public int line;
-        public int column;
-        public String name;
-
-        /**
-         * Constructs a StackFrame with the given information.
-         * @param id
-         *          the stack frame id
-         * @param name
-         *          the stack frame name
-         * @param src
-         *          source info of the stack frame
-         * @param ln
-         *          line number of the stack frame
-         * @param col
-         *          column number of the stack frame
-         */
-        public StackFrame(int id, String name, Source src, int ln, int col) {
-            this.id = id;
-            this.name = name;
-            this.source = src;
-            this.line = ln;
-            this.column = col;
-        }
-    }
-
-    public static class Scope {
-        public String name;
-        public int variablesReference;
-        public boolean expensive;
-
-        /**
-         * Constructor.
-         */
-        public Scope(String name, int rf, boolean exp) {
-            this.name = name;
-            this.variablesReference = rf;
-            this.expensive = exp;
-        }
-    }
-
-    public static class Variable {
-        public String name;
-        public String value;
-        public String type;
-        public int variablesReference;
-        public int indexedVariables;
-        public String evaluateName;
-
-        /**
-         * Constructor.
-         */
-        public Variable(String name, String val, String type, int rf, String evaluateName) {
-            this.name = name;
-            this.value = val;
-            this.type = type;
-            this.variablesReference = rf;
-            this.evaluateName = evaluateName;
-        }
-    }
-
-    public static class Thread {
-        public long id;
-        public String name;
-
-        /**
-         * Constructor.
-         */
-        public Thread(long l, String name) {
-            this.id = l;
-            if (name == null || name.length() == 0) {
-                this.name = String.format("Thread #%d", l);
-            } else {
-                this.name = name;
-            }
-        }
-    }
-
-    public static class Source {
-        public String name;
-        public String path;
-        public int sourceReference;
-
-        public Source() {
-        }
-
-        /**
-         * Constructor.
-         */
-        public Source(String name, String path, int rf) {
-            this.name = name;
-            this.path = path;
-            this.sourceReference = rf;
-        }
-
-        /**
-         * Constructor.
-         */
-        public Source(String path, int rf) {
-            this.name = Paths.get(path).getFileName().toString();
-            this.path = path;
-            this.sourceReference = rf;
-        }
-    }
-
-    public static class Breakpoint {
-        public int id;
-        public boolean verified;
-        public int line;
-        public String message;
-
-        /**
-         * Constructor.
-         */
-        public Breakpoint(int id, boolean verified, int line, String message) {
-            this.id = id;
-            this.verified = verified;
-            this.line = line;
-            this.message = message;
-        }
-    }
-
-    public static class SourceBreakpoint {
-        public int line;
-        public String hitCondition;
-        public String condition;
-
-        public SourceBreakpoint() {
-        }
-
-        /**
-         * Constructor.
-         */
-        public SourceBreakpoint(int line, String condition, String hitCondition) {
-            this.line = line;
-            this.condition = condition;
-            this.hitCondition = hitCondition;
-        }
-    }
-
-    public static class FunctionBreakpoint {
-        public String name;
-        public String condition;
-        public String hitCondition;
-
-        public FunctionBreakpoint() {
-        }
-
-        public FunctionBreakpoint(String name) {
-            this.name = name;
-        }
-    }
-
-    public static class ExceptionBreakpointFilter {
-        public static final String UNCAUGHT_EXCEPTION_FILTER_NAME = "uncaught";
-        public static final String CAUGHT_EXCEPTION_FILTER_NAME = "caught";
-        public static final String UNCAUGHT_EXCEPTION_FILTER_LABEL = "Uncaught Exceptions";
-        public static final String CAUGHT_EXCEPTION_FILTER_LABEL = "Caught Exceptions";
-
-        public String label;
-        public String filter;
-
-        public ExceptionBreakpointFilter(String value, String label) {
-            this.filter = value;
-            this.label = label;
-        }
-
-        public static final ExceptionBreakpointFilter UNCAUGHT_EXCEPTION_FILTER =
-                new ExceptionBreakpointFilter(UNCAUGHT_EXCEPTION_FILTER_NAME, UNCAUGHT_EXCEPTION_FILTER_LABEL);
-        public static final ExceptionBreakpointFilter CAUGHT_EXCEPTION_FILTER =
-                new ExceptionBreakpointFilter(CAUGHT_EXCEPTION_FILTER_NAME, CAUGHT_EXCEPTION_FILTER_LABEL);
-    }
-
-    public static class Capabilities {
-        public boolean supportsConfigurationDoneRequest;
-        public boolean supportsHitConditionalBreakpoints;
-        public boolean supportsEvaluateForHovers;
-        public boolean supportsSetVariable;
-        public boolean supportsRestartRequest;
-        public boolean supportTerminateDebuggee;
-        public boolean supportsDelayedStackTraceLoading;
-        public ExceptionBreakpointFilter[] exceptionBreakpointFilters = new ExceptionBreakpointFilter[0];
-    }
-}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/formatter/ObjectFormatter.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/formatter/ObjectFormatter.java
index ee974f8fe..25a44d27c 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/formatter/ObjectFormatter.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/formatter/ObjectFormatter.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2017 Microsoft Corporation and others.
+ * Copyright (c) 2017-2019 Microsoft Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -39,7 +39,7 @@ public ObjectFormatter(BiFunction<Type, Map<String, Object>, String> typeToStrin
 
     @Override
     public String toString(Object obj, Map<String, Object> options) {
-        return String.format("%s %s", getPrefix((ObjectReference) obj, options),
+        return String.format("%s@%s", getPrefix((ObjectReference) obj, options),
                 getIdPostfix((ObjectReference) obj, options));
     }
 
@@ -74,6 +74,6 @@ protected String getPrefix(ObjectReference value, Map<String, Object> options) {
     }
 
     protected static String getIdPostfix(ObjectReference obj, Map<String, Object> options) {
-        return String.format("(id=%s)", NumericFormatter.formatNumber(obj.uniqueID(), options));
+        return NumericFormatter.formatNumber(obj.uniqueID(), options);
     }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/formatter/StringObjectFormatter.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/formatter/StringObjectFormatter.java
index be5616d36..299f7dd32 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/formatter/StringObjectFormatter.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/formatter/StringObjectFormatter.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2019 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -19,14 +19,13 @@
 
 import org.apache.commons.lang3.StringUtils;
 
-import com.sun.jdi.ObjectReference;
 import com.sun.jdi.StringReference;
 import com.sun.jdi.Type;
 import com.sun.jdi.Value;
 
 public class StringObjectFormatter extends ObjectFormatter implements IValueFormatter {
     public static final String MAX_STRING_LENGTH_OPTION = "max_string_length";
-    private static final int DEFAULT_MAX_STRING_LENGTH = 100;
+    private static final int DEFAULT_MAX_STRING_LENGTH = 0;
     private static final String QUOTE_STRING = "\"";
 
     public StringObjectFormatter() {
@@ -42,10 +41,9 @@ public Map<String, Object> getDefaultOptions() {
 
     @Override
     public String toString(Object value, Map<String, Object> options) {
-        return String.format("\"%s\" %s",
-                StringUtils.abbreviate(((StringReference) value).value(),
-                        getMaxStringLength(options)),
-                getIdPostfix((ObjectReference) value, options));
+        int maxLength = getMaxStringLength(options);
+        return String.format("\"%s\"",
+                maxLength > 0 ? StringUtils.abbreviate(((StringReference) value).value(), maxLength) : ((StringReference) value).value());
     }
 
     @Override
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/AbstractDisconnectRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/AbstractDisconnectRequestHandler.java
new file mode 100644
index 000000000..fd5c68d6c
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/AbstractDisconnectRequestHandler.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+* Copyright (c) 2019 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.IHotCodeReplaceProvider;
+import com.microsoft.java.debug.core.adapter.LaunchMode;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+
+public abstract class AbstractDisconnectRequestHandler implements IDebugRequestHandler {
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.DISCONNECT);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+        context.setVmTerminated();
+        destroyDebugSession(command, arguments, response, context);
+        destroyResource(context);
+        return CompletableFuture.completedFuture(response);
+    }
+
+    /**
+     * Destroy the resources generated by the debug session.
+     *
+     * @param context the debug context
+     */
+    private void destroyResource(IDebugAdapterContext context) {
+        destroyProviders(context);
+        if (shouldDestroyLaunchFiles(context)) {
+            destroyLaunchFiles(context);
+        }
+    }
+
+    private boolean shouldDestroyLaunchFiles(IDebugAdapterContext context) {
+        // Delete the temporary launch files must happen after the debuggee process is fully exited,
+        // otherwise it throws error saying the file is being used by other process.
+        // In Debug mode, the debugger is able to receive VM terminate event. It's sensible to do cleanup.
+        // In noDebug mode, if the debuggee is launched internally by the debugger, the debugger knows
+        // when the debuggee process exited. Should do cleanup. But if the debuggee is launched in the
+        // integrated/external terminal, the debugger lost the contact with the debuggee after it's launched.
+        // Have no idea when the debuggee is exited. So ignore the cleanup.
+        return context.getLaunchMode() == LaunchMode.DEBUG || context.getDebuggeeProcess() != null;
+    }
+
+    private void destroyLaunchFiles(IDebugAdapterContext context) {
+        // Sometimes when the debug session is terminated, the debuggee process is not exited immediately.
+        // Add retry to delete the temporary launch files.
+        int retry = 5;
+        while (retry-- > 0) {
+            try {
+                if (context.getClasspathJar() != null) {
+                    Files.deleteIfExists(context.getClasspathJar());
+                    context.setClasspathJar(null);
+                }
+
+                if (context.getArgsfile() != null) {
+                    Files.deleteIfExists(context.getArgsfile());
+                    context.setArgsfile(null);
+                }
+
+                break;
+            } catch (IOException e) {
+                // do nothing.
+                logger.log(Level.WARNING, "Failed to destory launch files, will retry again.");
+            }
+
+            try {
+                TimeUnit.MILLISECONDS.sleep(100);
+            } catch (InterruptedException e) {
+                // do nothing.
+            }
+        }
+    }
+
+    protected abstract void destroyDebugSession(Command command, Arguments arguments, Response response, IDebugAdapterContext context);
+
+    protected void destroyProviders(IDebugAdapterContext context) {
+        IHotCodeReplaceProvider hcrProvider = context.getProvider(IHotCodeReplaceProvider.class);
+        if (hcrProvider != null) {
+            hcrProvider.close();
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/AttachRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/AttachRequestHandler.java
index 5ee170104..5ab848c8a 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/AttachRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/AttachRequestHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2020 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -14,28 +14,39 @@
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import java.util.logging.Logger;
 
 import com.microsoft.java.debug.core.Configuration;
 import com.microsoft.java.debug.core.DebugUtility;
 import com.microsoft.java.debug.core.IDebugSession;
+import com.microsoft.java.debug.core.UsageDataSession;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
 import com.microsoft.java.debug.core.adapter.Constants;
 import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.ICompletionsProvider;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.adapter.IHotCodeReplaceProvider;
 import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
 import com.microsoft.java.debug.core.adapter.IVirtualMachineManagerProvider;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.AttachArguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.AttachArguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
 import com.sun.jdi.connect.IllegalConnectorArgumentsException;
+import com.sun.jdi.request.EventRequest;
+
+import org.apache.commons.lang3.StringUtils;
 
 public class AttachRequestHandler implements IDebugRequestHandler {
     private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    private VMHandler vmHandler = new VMHandler();
 
     @Override
     public List<Command> getTargetCommands() {
@@ -43,32 +54,91 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
         AttachArguments attachArguments = (AttachArguments) arguments;
         context.setAttached(true);
         context.setSourcePaths(attachArguments.sourcePaths);
         context.setDebuggeeEncoding(StandardCharsets.UTF_8); // Use UTF-8 as debuggee's default encoding format.
+        context.setStepFilters(attachArguments.stepFilters);
+        context.setLocalDebugging(isLocalHost(attachArguments.hostName));
+
+        Map<String, Object> traceInfo = new HashMap<>();
+        traceInfo.put("localAttach", context.isLocalDebugging());
+        traceInfo.put("asyncJDWP", context.asyncJDWP());
 
         IVirtualMachineManagerProvider vmProvider = context.getProvider(IVirtualMachineManagerProvider.class);
-        ISourceLookUpProvider sourceProvider = context.getProvider(ISourceLookUpProvider.class);
-        Map<String, Object> options = sourceProvider.getDefaultOptions();
-        options.put(Constants.DEBUGGEE_ENCODING, context.getDebuggeeEncoding());
-        if (attachArguments.projectName != null) {
-            options.put(Constants.PROJECTNAME, attachArguments.projectName);
+        vmHandler.setVmProvider(vmProvider);
+        IDebugSession debugSession = null;
+        try {
+            try {
+                logger.info(String.format("Trying to attach to remote debuggee VM %s:%d .", attachArguments.hostName, attachArguments.port));
+                debugSession = DebugUtility.attach(vmProvider.getVirtualMachineManager(), attachArguments.hostName, attachArguments.port,
+                        attachArguments.timeout);
+                context.setDebugSession(debugSession);
+                vmHandler.connectVirtualMachine(debugSession.getVM());
+                logger.info("Attaching to debuggee VM succeeded.");
+            } catch (IOException | IllegalConnectorArgumentsException e) {
+                throw AdapterUtils.createCompletionException(
+                    String.format("Failed to attach to remote debuggee VM. Reason: %s", e.toString()),
+                    ErrorCode.ATTACH_FAILURE,
+                    e);
+            }
+
+            Map<String, Object> options = new HashMap<>();
+            options.put(Constants.DEBUGGEE_ENCODING, context.getDebuggeeEncoding());
+            if (attachArguments.projectName != null) {
+                options.put(Constants.PROJECT_NAME, attachArguments.projectName);
+            }
+            // TODO: Clean up the initialize mechanism
+            ISourceLookUpProvider sourceProvider = context.getProvider(ISourceLookUpProvider.class);
+            sourceProvider.initialize(context, options);
+            // If the debugger and debuggee run at the different JVM platforms, show a warning message.
+            if (debugSession != null) {
+                String debuggeeVersion = debugSession.getVM().version();
+                String debuggerVersion = sourceProvider.getJavaRuntimeVersion(attachArguments.projectName);
+                if (StringUtils.isNotBlank(debuggerVersion) && !debuggerVersion.equals(debuggeeVersion)) {
+                    String warnMessage = String.format("[Warn] The debugger and the debuggee are running in different versions of JVMs. "
+                        + "You could see wrong source mapping results.\n"
+                        + "Debugger JVM version: %s\n"
+                        + "Debuggee JVM version: %s", debuggerVersion, debuggeeVersion);
+                    logger.warning(warnMessage);
+                    context.getProtocolServer().sendEvent(Events.OutputEvent.createConsoleOutput(warnMessage));
+                }
+
+                EventRequest request = debugSession.getVM().eventRequestManager().createVMDeathRequest();
+                request.setSuspendPolicy(EventRequest.SUSPEND_NONE);
+                long sent = System.currentTimeMillis();
+                request.enable();
+                long received = System.currentTimeMillis();
+                long latency = received - sent;
+                context.setJDWPLatency(latency);
+                logger.info("Network latency for JDWP command: " + latency + "ms");
+                traceInfo.put("networkLatency", latency);
+            }
+
+            IEvaluationProvider evaluationProvider = context.getProvider(IEvaluationProvider.class);
+            evaluationProvider.initialize(context, options);
+            IHotCodeReplaceProvider hcrProvider = context.getProvider(IHotCodeReplaceProvider.class);
+            hcrProvider.initialize(context, options);
+            ICompletionsProvider completionsProvider = context.getProvider(ICompletionsProvider.class);
+            completionsProvider.initialize(context, options);
+        } finally {
+            UsageDataSession.recordInfo("attach debug info", traceInfo);
         }
-        sourceProvider.initialize(options);
 
-        try {
-            logger.info(String.format("Trying to attach to remote debuggee VM %s:%d .",
-                    attachArguments.hostName, attachArguments.port));
-            IDebugSession debugSession = DebugUtility.attach(vmProvider.getVirtualMachineManager(),
-                    attachArguments.hostName, attachArguments.port, attachArguments.timeout);
-            context.setDebugSession(debugSession);
-            logger.info("Attaching to debuggee VM succeeded.");
-        } catch (IOException | IllegalConnectorArgumentsException e) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.ATTACH_FAILURE,
-                    String.format("Failed to attach to remote debuggee VM. Reason: %s", e.toString()));
+        // Send an InitializedEvent to indicate that the debugger is ready to accept configuration requests
+        // (e.g. SetBreakpointsRequest, SetExceptionBreakpointsRequest).
+        context.getProtocolServer().sendEvent(new Events.InitializedEvent());
+        return CompletableFuture.completedFuture(response);
+    }
+
+    private boolean isLocalHost(String hostName) {
+        if (hostName == null || "localhost".equals(hostName) || "127.0.0.1".equals(hostName)) {
+            return true;
         }
+
+        // TODO: Check the host name of current computer as well.
+        return false;
     }
 
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/BreakpointLocationsRequestHander.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/BreakpointLocationsRequestHander.java
new file mode 100644
index 000000000..57c7ea15e
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/BreakpointLocationsRequestHander.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2022 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import com.microsoft.java.debug.core.IBreakpoint;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.protocol.Requests;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.BreakpointLocationsArguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Types.BreakpointLocation;
+
+/**
+ * The breakpointLocations request returns all possible locations for source breakpoints in a given range.
+ * Clients should only call this request if the corresponding capability supportsBreakpointLocationsRequest is true.
+ */
+public class BreakpointLocationsRequestHander implements IDebugRequestHandler {
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Requests.Command.BREAKPOINTLOCATIONS);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+        BreakpointLocationsArguments bpArgs = (BreakpointLocationsArguments) arguments;
+        String sourceUri = SetBreakpointsRequestHandler.normalizeSourcePath(bpArgs.source, context);
+        // When breakpoint source path is null or an invalid file path, send an ErrorResponse back.
+        if (StringUtils.isBlank(sourceUri)) {
+            throw AdapterUtils.createCompletionException(
+                String.format("Failed to get BreakpointLocations. Reason: '%s' is an invalid path.", bpArgs.source.path),
+                ErrorCode.SET_BREAKPOINT_FAILURE);
+        }
+
+        int debuggerLine = AdapterUtils.convertLineNumber(bpArgs.line, context.isClientLinesStartAt1(), context.isDebuggerLinesStartAt1());
+        IBreakpoint[] breakpoints = context.getBreakpointManager().getBreakpoints(sourceUri);
+        BreakpointLocation[] locations = new BreakpointLocation[0];
+        for (int i = 0; i < breakpoints.length; i++) {
+            if (breakpoints[i].getLineNumber() == debuggerLine && ArrayUtils.isNotEmpty(
+                    breakpoints[i].sourceLocation().availableBreakpointLocations())) {
+                locations = Stream.of(breakpoints[i].sourceLocation().availableBreakpointLocations()).map(location -> {
+                    BreakpointLocation newLocaiton = new BreakpointLocation();
+                    newLocaiton.line = AdapterUtils.convertLineNumber(location.line,
+                                    context.isDebuggerLinesStartAt1(), context.isClientLinesStartAt1());
+                    newLocaiton.column = AdapterUtils.convertColumnNumber(location.column,
+                                    context.isDebuggerColumnsStartAt1(), context.isClientColumnsStartAt1());
+                    newLocaiton.endLine = AdapterUtils.convertLineNumber(location.endLine,
+                                    context.isDebuggerLinesStartAt1(), context.isClientLinesStartAt1());
+                    newLocaiton.endColumn = AdapterUtils.convertColumnNumber(location.endColumn,
+                                    context.isDebuggerColumnsStartAt1(), context.isClientColumnsStartAt1());
+                    return newLocaiton;
+                }).toArray(BreakpointLocation[]::new);
+                break;
+            }
+        }
+
+        response.body = new Responses.BreakpointLocationsResponseBody(locations);
+        return CompletableFuture.completedFuture(response);
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/CompletionsHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/CompletionsHandler.java
new file mode 100644
index 000000000..eba7d5153
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/CompletionsHandler.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+* Copyright (c) 2018 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.ICompletionsProvider;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.CompletionsArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types.CompletionItem;
+import com.sun.jdi.IncompatibleThreadStateException;
+import com.sun.jdi.ThreadReference;
+
+public class CompletionsHandler implements IDebugRequestHandler {
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Requests.Command.COMPLETIONS);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+        CompletionsArguments completionsArgs = (CompletionsArguments) arguments;
+
+        // completions should be illegal when frameId is zero, it is sent when the program is running, while during running we cannot resolve
+        // the completion candidates
+        if (completionsArgs.frameId == 0) {
+            response.body = new Responses.CompletionsResponseBody(Collections.emptyList());
+            return CompletableFuture.completedFuture(response);
+        }
+
+        StackFrameReference stackFrameReference = (StackFrameReference) context.getRecyclableIdPool().getObjectById(completionsArgs.frameId);
+
+        if (stackFrameReference == null) {
+            throw AdapterUtils.createCompletionException(
+                String.format("Completions: cannot find the stack frame with frameID %s", completionsArgs.frameId),
+                ErrorCode.COMPLETIONS_FAILURE
+            );
+        }
+
+        return CompletableFuture.supplyAsync(() -> {
+            try {
+                ICompletionsProvider completionsProvider = context.getProvider(ICompletionsProvider.class);
+                if (completionsProvider != null) {
+                    ThreadReference thread = stackFrameReference.getThread();
+
+                    List<CompletionItem> res = completionsProvider.codeComplete(thread.frame(stackFrameReference.getDepth()), completionsArgs.text,
+                            completionsArgs.line, completionsArgs.column);
+                    response.body = new Responses.CompletionsResponseBody(res);
+                }
+                return response;
+            } catch (IncompatibleThreadStateException e) {
+                throw AdapterUtils.createCompletionException(
+                    String.format("Cannot provide code completions because of %s.", e.toString()),
+                    ErrorCode.COMPLETIONS_FAILURE,
+                    e
+                );
+            }
+        });
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ConfigurationDoneRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ConfigurationDoneRequestHandler.java
index 78bff27fe..308adddb6 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ConfigurationDoneRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ConfigurationDoneRequestHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -13,30 +13,39 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Logger;
 
+import com.microsoft.java.debug.core.Configuration;
 import com.microsoft.java.debug.core.DebugEvent;
+import com.microsoft.java.debug.core.DebugUtility;
 import com.microsoft.java.debug.core.IDebugSession;
+import com.microsoft.java.debug.core.JdiExceptionReference;
 import com.microsoft.java.debug.core.UsageDataSession;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
 import com.microsoft.java.debug.core.adapter.ErrorCode;
-import com.microsoft.java.debug.core.adapter.Events;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.adapter.IVirtualMachineManagerProvider;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
 import com.sun.jdi.ThreadReference;
 import com.sun.jdi.event.BreakpointEvent;
 import com.sun.jdi.event.Event;
 import com.sun.jdi.event.ExceptionEvent;
-import com.sun.jdi.event.StepEvent;
 import com.sun.jdi.event.ThreadDeathEvent;
 import com.sun.jdi.event.ThreadStartEvent;
 import com.sun.jdi.event.VMDeathEvent;
 import com.sun.jdi.event.VMDisconnectEvent;
+import com.sun.jdi.request.EventRequest;
 import com.sun.jdi.event.VMStartEvent;
 
 public class ConfigurationDoneRequestHandler implements IDebugRequestHandler {
+    protected static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    private VMHandler vmHandler = new VMHandler();
 
     @Override
     public List<Command> getTargetCommands() {
@@ -44,18 +53,20 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
         IDebugSession debugSession = context.getDebugSession();
+        vmHandler.setVmProvider(context.getProvider(IVirtualMachineManagerProvider.class));
         if (debugSession != null) {
             // This is a global event handler to handle the JDI Event from Virtual Machine.
-            debugSession.eventHub().events().subscribe(debugEvent -> {
+            debugSession.getEventHub().events().subscribe(debugEvent -> {
                 handleDebugEvent(debugEvent, debugSession, context);
             });
             // configuration is done, and start debug session.
             debugSession.start();
+            return CompletableFuture.completedFuture(response);
         } else {
-            context.sendEventAsync(new Events.TerminatedEvent());
-            AdapterUtils.setErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION, "Failed to launch debug session, the debugger will exit.");
+            context.getProtocolServer().sendEvent(new Events.TerminatedEvent());
+            return AdapterUtils.createAsyncErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION, "Failed to launch debug session, the debugger will exit.");
         }
     }
 
@@ -63,38 +74,55 @@ private void handleDebugEvent(DebugEvent debugEvent, IDebugSession debugSession,
         Event event = debugEvent.event;
         boolean isImportantEvent = true;
         if (event instanceof VMStartEvent) {
-            // do nothing.
+            if (context.isVmStopOnEntry()) {
+                DebugUtility.stopOnEntry(debugSession, context.getMainClass()).thenAccept(threadId -> {
+                    context.getProtocolServer().sendEvent(new Events.StoppedEvent("entry", threadId));
+                    context.getThreadCache().setThreadStoppedReason(threadId, "entry");
+                });
+            }
         } else if (event instanceof VMDeathEvent) {
+            vmHandler.disconnectVirtualMachine(event.virtualMachine());
             context.setVmTerminated();
-            context.sendEventAsync(new Events.ExitedEvent(0));
+            context.getProtocolServer().sendEvent(new Events.ExitedEvent(0));
         } else if (event instanceof VMDisconnectEvent) {
-            context.setVmTerminated();
-            context.sendEventAsync(new Events.TerminatedEvent());
-            // Terminate eventHub thread.
-            try {
-                debugSession.eventHub().close();
-            } catch (Exception e) {
-                // do nothing.
+            vmHandler.disconnectVirtualMachine(event.virtualMachine());
+            if (context.isAttached()) {
+                context.setVmTerminated();
+                context.getProtocolServer().sendEvent(new Events.TerminatedEvent());
+                // Terminate eventHub thread.
+                try {
+                    debugSession.getEventHub().close();
+                } catch (Exception e) {
+                    // do nothing.
+                }
+            } else {
+                // Skip it when the debugger is in launch mode, because LaunchRequestHandler will handle the event there.
             }
         } else if (event instanceof ThreadStartEvent) {
             ThreadReference startThread = ((ThreadStartEvent) event).thread();
             Events.ThreadEvent threadEvent = new Events.ThreadEvent("started", startThread.uniqueID());
-            context.sendEventAsync(threadEvent);
+            context.getProtocolServer().sendEvent(threadEvent);
         } else if (event instanceof ThreadDeathEvent) {
             ThreadReference deathThread = ((ThreadDeathEvent) event).thread();
             Events.ThreadEvent threadDeathEvent = new Events.ThreadEvent("exited", deathThread.uniqueID());
-            context.sendEventAsync(threadDeathEvent);
+            context.getProtocolServer().sendEvent(threadDeathEvent);
+            context.getThreadCache().addDeathThread(deathThread.uniqueID());
         } else if (event instanceof BreakpointEvent) {
-            ThreadReference bpThread = ((BreakpointEvent) event).thread();
-            context.sendEventAsync(new Events.StoppedEvent("breakpoint", bpThread.uniqueID()));
-            debugEvent.shouldResume = false;
-        } else if (event instanceof StepEvent) {
-            ThreadReference stepThread = ((StepEvent) event).thread();
-            context.sendEventAsync(new Events.StoppedEvent("step", stepThread.uniqueID()));
-            debugEvent.shouldResume = false;
+            // ignore since SetBreakpointsRequestHandler has already handled
         } else if (event instanceof ExceptionEvent) {
             ThreadReference thread = ((ExceptionEvent) event).thread();
-            context.sendEventAsync(new Events.StoppedEvent("exception", thread.uniqueID()));
+            IEvaluationProvider engine = context.getProvider(IEvaluationProvider.class);
+            if (engine.isInEvaluation(thread)) {
+                return;
+            }
+
+            JdiExceptionReference jdiException = new JdiExceptionReference(((ExceptionEvent) event).exception(),
+                    ((ExceptionEvent) event).catchLocation() == null);
+            context.getExceptionManager().setException(thread.uniqueID(), jdiException);
+            context.getThreadCache().addEventThread(thread, "exception");
+            boolean allThreadsStopped = event.request() != null
+                    && event.request().suspendPolicy() == EventRequest.SUSPEND_ALL;
+            context.getProtocolServer().sendEvent(new Events.StoppedEvent("exception", thread.uniqueID(), allThreadsStopped));
             debugEvent.shouldResume = false;
         } else {
             isImportantEvent = false;
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/DataBreakpointInfoRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/DataBreakpointInfoRequestHandler.java
new file mode 100644
index 000000000..2d9b6c30d
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/DataBreakpointInfoRequestHandler.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+* Copyright (c) 2019 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
+import com.microsoft.java.debug.core.adapter.variables.VariableProxy;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.DataBreakpointInfoArguments;
+import com.microsoft.java.debug.core.protocol.Responses.DataBreakpointInfoResponseBody;
+import com.microsoft.java.debug.core.protocol.Types.DataBreakpointAccessType;
+import com.sun.jdi.Field;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ReferenceType;
+
+public class DataBreakpointInfoRequestHandler implements IDebugRequestHandler {
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.DATABREAKPOINTINFO);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+        DataBreakpointInfoArguments dataBpArgs = (DataBreakpointInfoArguments) arguments;
+        if (dataBpArgs.variablesReference > 0) {
+            Object container = context.getRecyclableIdPool().getObjectById(dataBpArgs.variablesReference);
+            if (container instanceof VariableProxy) {
+                if (!(((VariableProxy) container).getProxiedVariable() instanceof StackFrameReference)) {
+                    ObjectReference containerObj = (ObjectReference) ((VariableProxy) container).getProxiedVariable();
+                    ReferenceType type = containerObj.referenceType();
+                    Field field = type.fieldByName(dataBpArgs.name);
+                    if (field != null) {
+                        String fullyQualifiedName = type.name();
+                        String dataId = String.format("%s#%s", fullyQualifiedName, dataBpArgs.name);
+                        String description = String.format("%s.%s : %s", getSimpleName(fullyQualifiedName), dataBpArgs.name, getSimpleName(field.typeName()));
+                        response.body = new DataBreakpointInfoResponseBody(dataId, description,
+                            DataBreakpointAccessType.values(), true);
+                    }
+                }
+            }
+        }
+        return CompletableFuture.completedFuture(response);
+    }
+
+    private String getSimpleName(String typeName) {
+        if (StringUtils.isBlank(typeName)) {
+            return "";
+        }
+
+        String[] names = typeName.split("\\.");
+        return names[names.length - 1];
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/DisconnectRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/DisconnectRequestHandler.java
index dc7e22181..c38af257e 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/DisconnectRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/DisconnectRequestHandler.java
@@ -11,35 +11,29 @@
 
 package com.microsoft.java.debug.core.adapter.handler;
 
-import java.util.Arrays;
-import java.util.List;
-
 import com.microsoft.java.debug.core.IDebugSession;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
-import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.DisconnectArguments;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.DisconnectArguments;
 
-public class DisconnectRequestHandler implements IDebugRequestHandler {
+public class DisconnectRequestHandler extends AbstractDisconnectRequestHandler {
 
     @Override
-    public List<Command> getTargetCommands() {
-        return Arrays.asList(Command.DISCONNECT);
-    }
-
-    @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public void destroyDebugSession(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
         DisconnectArguments disconnectArguments = (DisconnectArguments) arguments;
         IDebugSession debugSession = context.getDebugSession();
         if (debugSession != null) {
             if (disconnectArguments.terminateDebuggee && !context.isAttached()) {
-                debugSession.terminate();
+                try {
+                    debugSession.terminate();
+                } finally {
+                    debugSession.detach();
+                }
             } else {
                 debugSession.detach();
             }
         }
     }
-
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/DisconnectRequestWithoutDebuggingHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/DisconnectRequestWithoutDebuggingHandler.java
new file mode 100644
index 000000000..59d750bcd
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/DisconnectRequestWithoutDebuggingHandler.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+* Copyright (c) 2018-2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.Optional;
+
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.DisconnectArguments;
+
+public class DisconnectRequestWithoutDebuggingHandler extends AbstractDisconnectRequestHandler {
+
+    @Override
+    public void destroyDebugSession(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+        DisconnectArguments disconnectArguments = (DisconnectArguments) arguments;
+        Process debuggeeProcess = context.getDebuggeeProcess();
+        if (debuggeeProcess != null && disconnectArguments.terminateDebuggee) {
+            debuggeeProcess.destroy();
+        } else if (context.getProcessId() > 0 && disconnectArguments.terminateDebuggee) {
+            Optional<ProcessHandle> debuggeeHandle = ProcessHandle.of(context.getProcessId());
+            if (debuggeeHandle.isPresent()) {
+                debuggeeHandle.get().destroy();
+            }
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/EvaluateRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/EvaluateRequestHandler.java
index 18a04e8ff..d135ee5b2 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/EvaluateRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/EvaluateRequestHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -14,38 +14,42 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.ExecutionException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 import org.apache.commons.lang3.StringUtils;
 
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.DebugSettings;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
 import com.microsoft.java.debug.core.adapter.ErrorCode;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.EvaluateArguments;
-import com.microsoft.java.debug.core.adapter.Responses;
-import com.microsoft.java.debug.core.adapter.formatter.NumericFormatEnum;
-import com.microsoft.java.debug.core.adapter.formatter.NumericFormatter;
-import com.microsoft.java.debug.core.adapter.formatter.SimpleTypeFormatter;
-import com.microsoft.java.debug.core.adapter.variables.JdiObjectProxy;
-import com.microsoft.java.debug.core.adapter.variables.Variable;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.adapter.variables.IVariableFormatter;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructure;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructureManager;
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
+import com.microsoft.java.debug.core.adapter.variables.VariableDetailUtils;
 import com.microsoft.java.debug.core.adapter.variables.VariableProxy;
 import com.microsoft.java.debug.core.adapter.variables.VariableUtils;
-import com.sun.jdi.AbsentInformationException;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.EvaluateArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
 import com.sun.jdi.ArrayReference;
-import com.sun.jdi.Field;
+import com.sun.jdi.IntegerValue;
 import com.sun.jdi.ObjectReference;
-import com.sun.jdi.PrimitiveValue;
-import com.sun.jdi.StackFrame;
-import com.sun.jdi.ThreadReference;
 import com.sun.jdi.Value;
+import com.sun.jdi.VoidValue;
 
 public class EvaluateRequestHandler implements IDebugRequestHandler {
-    private final Pattern simpleExprPattern = Pattern.compile("[A-Za-z0-9_.\\s]+");
+    protected static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
 
     @Override
     public List<Command> getTargetCommands() {
@@ -53,136 +57,151 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
         EvaluateArguments evalArguments = (EvaluateArguments) arguments;
-        if (StringUtils.isBlank(evalArguments.expression)) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.ARGUMENT_MISSING,
-                    "EvaluateRequest: property 'expression' is missing, null, or empty");
-            return;
-        }
-
-        // This should be false by default(currently true for test).
-        // User will need to explicitly turn it on by configuring launch.json
-        final boolean showStaticVariables = true;
-        // TODO: when vscode protocol support customize settings of value format, showFullyQualifiedNames should be one of the options.
-        boolean showFullyQualifiedNames = true;
+        final boolean showStaticVariables = DebugSettings.getCurrent().showStaticVariables;
         Map<String, Object> options = context.getVariableFormatter().getDefaultOptions();
-        if (evalArguments.format != null && evalArguments.format.hex) {
-            options.put(NumericFormatter.NUMERIC_FORMAT_OPTION, NumericFormatEnum.HEX);
-        }
-        if (showFullyQualifiedNames) {
-            options.put(SimpleTypeFormatter.QUALIFIED_CLASS_NAME_OPTION, showFullyQualifiedNames);
-        }
+        VariableUtils.applyFormatterOptions(options, evalArguments.format != null && evalArguments.format.hex);
         String expression = evalArguments.expression;
 
-        if (StringUtils.isBlank(expression)) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.EVALUATE_FAILURE, "Failed to evaluate. Reason: Empty expression cannot be evaluated.");
-            return;
+        // Async mode is supposed to be performant, then disable the advanced features like hover evaluation.
+        if (context.asyncJDWP(VariablesRequestHandler.USABLE_JDWP_LATENCY)
+            && context.getJDWPLatency() > VariablesRequestHandler.USABLE_JDWP_LATENCY
+            && "hover".equals(evalArguments.context)) {
+            return CompletableFuture.completedFuture(response);
         }
 
-        if (!simpleExprPattern.matcher(expression).matches()) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.EVALUATE_FAILURE,
-                    "Failed to evaluate. Reason: Complex expression is not supported currently.");
-            return;
+        if (StringUtils.isBlank(expression)) {
+            throw new CompletionException(AdapterUtils.createUserErrorDebugException(
+                "Failed to evaluate. Reason: Empty expression cannot be evaluated.",
+                ErrorCode.EVALUATION_COMPILE_ERROR));
         }
-
-        JdiObjectProxy<StackFrame> stackFrameProxy = (JdiObjectProxy<StackFrame>) context.getRecyclableIdPool().getObjectById(evalArguments.frameId);
-        if (stackFrameProxy == null) {
-            // stackFrameProxy is null means the stackframe is continued by user manually,
-            AdapterUtils.setErrorResponse(response, ErrorCode.EVALUATE_FAILURE, "Failed to evaluate. Reason: Cannot evaluate because the thread is resumed.");
-            return;
+        StackFrameReference stackFrameReference = (StackFrameReference) context.getRecyclableIdPool().getObjectById(evalArguments.frameId);
+        if (stackFrameReference == null) {
+            // stackFrameReference is null means the given thread is running
+            throw new CompletionException(AdapterUtils.createUserErrorDebugException(
+                    "Evaluation failed because the thread is not suspended.",
+                    ErrorCode.EVALUATE_NOT_SUSPENDED_THREAD));
         }
 
-        // split a.b.c => ["a", "b", "c"]
-        List<String> referenceExpressions = Arrays.stream(StringUtils.split(expression, '.'))
-                .filter(StringUtils::isNotBlank).map(StringUtils::trim).collect(Collectors.toList());
-
-        // get first level of value from stack frame
-        Variable firstLevelValue = null;
-        boolean inStaticMethod = stackFrameProxy.getProxiedObject().location().method().isStatic();
-        String firstExpression = referenceExpressions.get(0);
-        // handle special case of 'this'
-        if (firstExpression.equals("this") && !inStaticMethod) {
-            firstLevelValue = VariableUtils.getThisVariable(stackFrameProxy.getProxiedObject());
-        }
-        if (firstLevelValue == null) {
+        return CompletableFuture.supplyAsync(() -> {
+            IEvaluationProvider engine = context.getProvider(IEvaluationProvider.class);
             try {
-                // local variables first, that means
-                // if both local variable and static variable are found, use local variable
-                List<Variable> localVariables = VariableUtils.listLocalVariables(stackFrameProxy.getProxiedObject());
-                List<Variable> matchedLocal = localVariables.stream()
-                        .filter(localVariable -> localVariable.name.equals(firstExpression)).collect(Collectors.toList());
-                if (!matchedLocal.isEmpty()) {
-                    firstLevelValue = matchedLocal.get(0);
-                } else {
-                    List<Variable> staticVariables = VariableUtils.listStaticVariables(stackFrameProxy.getProxiedObject());
-                    List<Variable> matchedStatic = staticVariables.stream()
-                            .filter(staticVariable -> staticVariable.name.equals(firstExpression)).collect(Collectors.toList());
-                    if (matchedStatic.isEmpty()) {
-                        AdapterUtils.setErrorResponse(response, ErrorCode.EVALUATE_FAILURE,
-                                String.format("Failed to evaluate. Reason: Cannot find the variable: %s.", referenceExpressions.get(0)));
-                        return;
+                Value value = engine.evaluate(expression, stackFrameReference.getThread(), stackFrameReference.getDepth()).get();
+                IVariableFormatter variableFormatter = context.getVariableFormatter();
+                if (value instanceof VoidValue) {
+                    response.body = new Responses.EvaluateResponseBody(value.toString(), 0, "<void>", 0);
+                    return response;
+                }
+                long threadId = stackFrameReference.getThread().uniqueID();
+                if (value instanceof ObjectReference) {
+                    VariableProxy varProxy = new VariableProxy(stackFrameReference.getThread(), "eval", value, null, expression);
+                    int indexedVariables = -1;
+                    Value sizeValue = null;
+                    if (value instanceof ArrayReference) {
+                        indexedVariables = ((ArrayReference) value).length();
+                    } else if (value instanceof ObjectReference && supportsLogicStructureView(context, evalArguments.context) && engine != null) {
+                        try {
+                            JavaLogicalStructure structure = JavaLogicalStructureManager.getLogicalStructure((ObjectReference) value);
+                            if (structure != null && structure.getSizeExpression() != null) {
+                                sizeValue = structure.getSize((ObjectReference) value, stackFrameReference.getThread(), engine);
+                                if (sizeValue != null && sizeValue instanceof IntegerValue) {
+                                    indexedVariables = ((IntegerValue) sizeValue).value();
+                                }
+                            }
+                        } catch (Exception e) {
+                            logger.log(Level.INFO, "Failed to get the logical size of the variable", e);
+                        }
+                    }
+                    int referenceId = 0;
+                    if (indexedVariables > 0 || (indexedVariables < 0 && value instanceof ObjectReference)) {
+                        referenceId = context.getRecyclableIdPool().addObject(threadId, varProxy);
+                    }
+
+                    boolean hasErrors = false;
+                    String valueString = null;
+                    try {
+                        valueString = variableFormatter.valueToString(value, options);
+                    } catch (OutOfMemoryError e) {
+                        hasErrors = true;
+                        logger.log(Level.SEVERE, "Failed to convert the value of a large object to a string", e);
+                        valueString = "<Unable to display the value of a large object>";
+                    }  catch (Exception e) {
+                        hasErrors = true;
+                        logger.log(Level.SEVERE, "Failed to resolve the variable value", e);
+                        valueString = "<Failed to resolve the variable value due to \"" + e.getMessage() + "\">";
+                    }
+
+                    String detailsString = null;
+                    if (hasErrors) {
+                        // If failed to resolve the variable value, skip the details info as well.
+                    } else if (sizeValue != null) {
+                        detailsString = "size=" + variableFormatter.valueToString(sizeValue, options);
+                    } else if (supportsToStringView(context, evalArguments.context)) {
+                        try {
+                            detailsString = VariableDetailUtils.formatDetailsValue(value, stackFrameReference.getThread(), variableFormatter, options, engine);
+                        } catch (OutOfMemoryError e) {
+                            logger.log(Level.SEVERE, "Failed to compute the toString() value of a large object", e);
+                            detailsString = "<Unable to display the details of a large object>";
+                        } catch (Exception e) {
+                            logger.log(Level.SEVERE, "Failed to compute the toString() value", e);
+                            detailsString = "<Failed to resolve the variable details due to \"" + e.getMessage() + "\">";
+                        }
+                    }
+
+                    if ("clipboard".equals(evalArguments.context) && detailsString != null) {
+                        response.body = new Responses.EvaluateResponseBody(detailsString, -1, "String", 0);
+                    } else {
+                        String typeString = "";
+                        try {
+                            typeString = variableFormatter.typeToString(value == null ? null : value.type(), options);
+                        } catch (Exception e) {
+                            logger.log(Level.SEVERE, "Failed to resolve the variable type", e);
+                            typeString = "";
+                        }
+                        response.body = new Responses.EvaluateResponseBody((detailsString == null) ? valueString : valueString + " " + detailsString,
+                                referenceId, typeString, Math.max(indexedVariables, 0));
                     }
-                    firstLevelValue = matchedStatic.get(0);
+                    return response;
+                }
+                // for primitive value
+                response.body = new Responses.EvaluateResponseBody(variableFormatter.valueToString(value, options), 0,
+                        variableFormatter.typeToString(value == null ? null : value.type(), options), 0);
+                return response;
+            } catch (InterruptedException | ExecutionException e) {
+                Throwable cause = e;
+                if (e instanceof ExecutionException && e.getCause() != null) {
+                    cause = e.getCause();
                 }
 
-            } catch (AbsentInformationException e) {
-                // ignore
+                if (cause instanceof DebugException) {
+                    throw new CompletionException(cause);
+                }
+                throw AdapterUtils.createCompletionException(
+                    String.format("Cannot evaluate because of %s.", cause.toString()),
+                    ErrorCode.EVALUATE_FAILURE,
+                    cause);
             }
-        }
+        });
+    }
 
-        if (firstLevelValue == null) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.EVALUATE_FAILURE,
-                    String.format("Failed to evaluate. Reason: Cannot find variable with name '%s'.", referenceExpressions.get(0)));
-            return;
-        }
-        ThreadReference thread = stackFrameProxy.getProxiedObject().thread();
-        Value currentValue = firstLevelValue.value;
-
-        for (int i = 1; i < referenceExpressions.size(); i++) {
-            String fieldName = referenceExpressions.get(i);
-            if (currentValue == null) {
-                AdapterUtils.setErrorResponse(response, ErrorCode.EVALUATE_FAILURE, "Failed to evaluate. Reason: Evaluation encounters NPE error.");
-                return;
-            }
-            if (currentValue instanceof PrimitiveValue) {
-                AdapterUtils.setErrorResponse(response, ErrorCode.EVALUATE_FAILURE,
-                        String.format("Failed to evaluate. Reason: Cannot find the field: %s.", fieldName));
-                return;
-            }
-            if (currentValue instanceof ArrayReference) {
-                AdapterUtils.setErrorResponse(response, ErrorCode.EVALUATE_FAILURE,
-                        String.format("Failed to evaluate. Reason: Evaluating array elements is not supported currently.", fieldName));
-                return;
-            }
-            ObjectReference obj = (ObjectReference) currentValue;
-            Field field = obj.referenceType().fieldByName(fieldName);
-            if (field == null) {
-                AdapterUtils.setErrorResponse(response, ErrorCode.EVALUATE_FAILURE,
-                        String.format("Failed to evaluate. Reason: Cannot find the field: %s.", fieldName));
-                return;
-            }
-            if (field.isStatic()) {
-                AdapterUtils.setErrorResponse(response, ErrorCode.EVALUATE_FAILURE,
-                        String.format("Failed to evaluate. Reason: Cannot find the field: %s.", fieldName));
-                return;
-            }
-            currentValue = obj.getValue(field);
+    private boolean supportsLogicStructureView(IDebugAdapterContext context, String evalContext) {
+        if (!"watch".equals(evalContext)) {
+            return true;
         }
 
-        int referenceId = 0;
-        if (currentValue instanceof ObjectReference && VariableUtils.hasChildren(currentValue, showStaticVariables)) {
-            // save the evaluated value in object pool, because like java.lang.String, the evaluated object will have sub structures
-            // we need to set up the id map.
-            VariableProxy varProxy = new VariableProxy(thread.uniqueID(), "Local", (ObjectReference) currentValue);
-            referenceId = context.getRecyclableIdPool().addObject(thread.uniqueID(), varProxy);
-        }
-        int indexedVariables = 0;
-        if (currentValue instanceof ArrayReference) {
-            indexedVariables = ((ArrayReference) currentValue).length();
+        return (!context.asyncJDWP(VariablesRequestHandler.USABLE_JDWP_LATENCY)
+            || context.getJDWPLatency() <= VariablesRequestHandler.USABLE_JDWP_LATENCY)
+            && DebugSettings.getCurrent().showLogicalStructure;
+    }
+
+    private boolean supportsToStringView(IDebugAdapterContext context, String evalContext) {
+        if (!"watch".equals(evalContext)) {
+            return true;
         }
-        response.body = new Responses.EvaluateResponseBody(context.getVariableFormatter().valueToString(currentValue, options),
-                referenceId, context.getVariableFormatter().typeToString(currentValue == null ? null : currentValue.type(), options),
-                indexedVariables);
+
+        return (!context.asyncJDWP(VariablesRequestHandler.USABLE_JDWP_LATENCY)
+            || context.getJDWPLatency() <= VariablesRequestHandler.USABLE_JDWP_LATENCY)
+            && DebugSettings.getCurrent().showToString;
     }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ExceptionInfoRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ExceptionInfoRequestHandler.java
new file mode 100644
index 000000000..5e065edd0
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ExceptionInfoRequestHandler.java
@@ -0,0 +1,103 @@
+/*******************************************************************************
+* Copyright (c) 2019-2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugUtility;
+import com.microsoft.java.debug.core.JdiExceptionReference;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.ExceptionInfoArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types.ExceptionBreakMode;
+import com.sun.jdi.ClassNotLoadedException;
+import com.sun.jdi.IncompatibleThreadStateException;
+import com.sun.jdi.InvalidTypeException;
+import com.sun.jdi.InvocationException;
+import com.sun.jdi.Method;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.Value;
+
+public class ExceptionInfoRequestHandler implements IDebugRequestHandler {
+    protected static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.EXCEPTIONINFO);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+        ExceptionInfoArguments exceptionInfoArgs = (ExceptionInfoArguments) arguments;
+        ThreadReference thread = context.getThreadCache().getThread(exceptionInfoArgs.threadId);
+        if (thread == null) {
+            thread = DebugUtility.getThread(context.getDebugSession(), exceptionInfoArgs.threadId);
+        }
+
+        if (thread == null) {
+            throw AdapterUtils.createCompletionException("Thread " + exceptionInfoArgs.threadId + " doesn't exist.", ErrorCode.EXCEPTION_INFO_FAILURE);
+        }
+
+        JdiExceptionReference jdiException = context.getExceptionManager().getException(exceptionInfoArgs.threadId);
+        if (jdiException == null) {
+            throw AdapterUtils.createCompletionException("No exception exists in thread " + exceptionInfoArgs.threadId, ErrorCode.EXCEPTION_INFO_FAILURE);
+        }
+
+        Method toStringMethod = null;
+        for (Method method : jdiException.exception.referenceType().allMethods()) {
+            if (Objects.equals("toString", method.name()) && Objects.equals("()Ljava/lang/String;", method.signature())) {
+                toStringMethod = method;
+                break;
+            }
+        }
+
+        String typeName = jdiException.exception.type().name();
+        String exceptionToString = typeName;
+        if (toStringMethod != null) {
+            try {
+                Value returnValue = jdiException.exception.invokeMethod(thread, toStringMethod, Collections.EMPTY_LIST, ObjectReference.INVOKE_SINGLE_THREADED);
+                exceptionToString = returnValue.toString();
+            } catch (InvalidTypeException | ClassNotLoadedException | IncompatibleThreadStateException
+                    | InvocationException e) {
+                logger.log(Level.SEVERE, String.format("Failed to get the return value of the method Exception.toString(): %s", e.toString(), e));
+            } finally {
+                try {
+                    // See bug https://github.com/microsoft/vscode-java-debug/issues/767:
+                    // The operation exception.invokeMethod above will resume the thread, that will cause
+                    // the previously cached stack frames for this thread to be invalid.
+                    context.getStackFrameManager().reloadStackFrames(thread);
+                } catch (Exception e) {
+                    // do nothing.
+                }
+            }
+        }
+
+        response.body = new Responses.ExceptionInfoResponse(typeName, exceptionToString,
+                jdiException.isUncaught ? ExceptionBreakMode.USERUNHANDLED : ExceptionBreakMode.ALWAYS);
+        return CompletableFuture.completedFuture(response);
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/HotCodeReplaceHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/HotCodeReplaceHandler.java
new file mode 100644
index 000000000..fa65e978b
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/HotCodeReplaceHandler.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+* Copyright (c) 2017-2019 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.adapter.HotCodeReplaceEvent;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.IHotCodeReplaceProvider;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.Events.HotCodeReplaceEvent.ChangeType;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Responses;
+
+public class HotCodeReplaceHandler implements IDebugRequestHandler {
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Requests.Command.REDEFINECLASSES);
+    }
+
+    @Override
+    public void initialize(IDebugAdapterContext context) {
+        IDebugRequestHandler.super.initialize(context);
+        IHotCodeReplaceProvider provider = context.getProvider(IHotCodeReplaceProvider.class);
+        provider.getEventHub()
+            .subscribe(event -> {
+                if (event.getEventType() == HotCodeReplaceEvent.EventType.BUILD_COMPLETE) {
+                    context.getProtocolServer().sendEvent(new Events.HotCodeReplaceEvent(ChangeType.BUILD_COMPLETE, event.getMessage()));
+                } else if (event.getEventType() == HotCodeReplaceEvent.EventType.STARTING) {
+                    context.getProtocolServer().sendEvent(new Events.HotCodeReplaceEvent(ChangeType.STARTING, event.getMessage()));
+                } else if (event.getEventType() == HotCodeReplaceEvent.EventType.END) {
+                    context.getProtocolServer().sendEvent(new Events.HotCodeReplaceEvent(ChangeType.END, event.getMessage()));
+                } else if (event.getEventType() == HotCodeReplaceEvent.EventType.ERROR) {
+                    context.getProtocolServer().sendEvent(new Events.HotCodeReplaceEvent(ChangeType.ERROR, event.getMessage()));
+                } else if (event.getEventType() == HotCodeReplaceEvent.EventType.WARNING) {
+                    context.getProtocolServer().sendEvent(new Events.HotCodeReplaceEvent(ChangeType.WARNING, event.getMessage()));
+                }
+            });
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+
+        IHotCodeReplaceProvider provider = context.getProvider(IHotCodeReplaceProvider.class);
+
+        return provider.redefineClasses().thenCompose(classNames -> {
+            response.body = new Responses.RedefineClassesResponse(classNames.toArray(new String[0]));
+            return CompletableFuture.completedFuture(response);
+        }).exceptionally(ex -> {
+            String errorMessage = ex.getCause() != null ? ex.getCause().getMessage() : ex.getMessage();
+            response.body = new Responses.RedefineClassesResponse(new String[0], errorMessage);
+            return response;
+        });
+    }
+
+}
\ No newline at end of file
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ILaunchDelegate.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ILaunchDelegate.java
new file mode 100644
index 000000000..ac12a09d5
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ILaunchDelegate.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2018 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.io.IOException;
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.LaunchArguments;
+import com.sun.jdi.connect.IllegalConnectorArgumentsException;
+import com.sun.jdi.connect.VMStartException;
+
+public interface ILaunchDelegate {
+    void postLaunch(LaunchArguments launchArguments, IDebugAdapterContext context);
+
+    void preLaunch(LaunchArguments launchArguments, IDebugAdapterContext context);
+
+    CompletableFuture<Response> launchInTerminal(LaunchArguments launchArguments, Response response, IDebugAdapterContext context);
+
+    Process launch(LaunchArguments launchArguments, IDebugAdapterContext context)
+            throws IOException, IllegalConnectorArgumentsException, VMStartException;
+
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/InitializeRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/InitializeRequestHandler.java
index 34444536d..6b9245166 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/InitializeRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/InitializeRequestHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2017 Microsoft Corporation and others.
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -13,13 +13,13 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 
-import com.microsoft.java.debug.core.adapter.Events;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
-import com.microsoft.java.debug.core.adapter.Messages;
-import com.microsoft.java.debug.core.adapter.Requests;
-import com.microsoft.java.debug.core.adapter.Types;
+import com.microsoft.java.debug.core.protocol.Messages;
+import com.microsoft.java.debug.core.protocol.Requests;
+import com.microsoft.java.debug.core.protocol.Types;
 
 public class InitializeRequestHandler implements IDebugRequestHandler {
     @Override
@@ -28,10 +28,11 @@ public List<Requests.Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Requests.Command command, Requests.Arguments argument, Messages.Response response,
+    public CompletableFuture<Messages.Response> handle(Requests.Command command, Requests.Arguments argument, Messages.Response response,
                        IDebugAdapterContext context) {
         Requests.InitializeArguments initializeArguments = (Requests.InitializeArguments) argument;
         context.setClientLinesStartAt1(initializeArguments.linesStartAt1);
+        context.setClientColumnsStartAt1(initializeArguments.columnsStartAt1);
         String pathFormat = initializeArguments.pathFormat;
         if (pathFormat != null) {
             switch (pathFormat) {
@@ -42,20 +43,31 @@ public void handle(Requests.Command command, Requests.Arguments argument, Messag
                     context.setClientPathsAreUri(false);
             }
         }
-
-        // Send an InitializedEvent
-        context.sendEventAsync(new Events.InitializedEvent());
+        context.setSupportsRunInTerminalRequest(initializeArguments.supportsRunInTerminalRequest);
 
         Types.Capabilities caps = new Types.Capabilities();
         caps.supportsConfigurationDoneRequest = true;
         caps.supportsHitConditionalBreakpoints = true;
+        caps.supportsConditionalBreakpoints = true;
         caps.supportsSetVariable = true;
         caps.supportTerminateDebuggee = true;
+        caps.supportsCompletionsRequest = true;
+        caps.supportsRestartFrame = true;
+        caps.supportsLogPoints = true;
+        caps.supportsEvaluateForHovers = true;
         Types.ExceptionBreakpointFilter[] exceptionFilters = {
             Types.ExceptionBreakpointFilter.UNCAUGHT_EXCEPTION_FILTER,
             Types.ExceptionBreakpointFilter.CAUGHT_EXCEPTION_FILTER,
         };
         caps.exceptionBreakpointFilters = exceptionFilters;
+        caps.supportsExceptionInfoRequest = true;
+        caps.supportsDataBreakpoints = true;
+        caps.supportsFunctionBreakpoints = true;
+        caps.supportsClipboardContext = true;
+        caps.supportsBreakpointLocationsRequest = true;
+        caps.supportsStepInTargetsRequest = true;
         response.body = caps;
+        context.setInitialized(true);
+        return CompletableFuture.completedFuture(response);
     }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/InlineValuesRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/InlineValuesRequestHandler.java
new file mode 100644
index 000000000..21f77ee5a
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/InlineValuesRequestHandler.java
@@ -0,0 +1,257 @@
+/*******************************************************************************
+* Copyright (c) 2021 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.adapter.IStackFrameManager;
+import com.microsoft.java.debug.core.adapter.variables.IVariableFormatter;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructure;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructureManager;
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
+import com.microsoft.java.debug.core.adapter.variables.Variable;
+import com.microsoft.java.debug.core.adapter.variables.VariableDetailUtils;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.InlineVariable;
+import com.microsoft.java.debug.core.protocol.Requests.InlineValuesArguments;
+import com.sun.jdi.ArrayReference;
+import com.sun.jdi.Field;
+import com.sun.jdi.IntegerValue;
+import com.sun.jdi.Method;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.StackFrame;
+import com.sun.jdi.Value;
+
+import org.apache.commons.lang3.math.NumberUtils;
+
+public class InlineValuesRequestHandler implements IDebugRequestHandler {
+    protected static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.INLINEVALUES);
+    }
+
+    /**
+     * This request only resolves the values for those non-local variables, such as
+     * field variables and captured variables from outer scope. Because the values
+     * of local variables in current stackframe are usually expanded by Variables View
+     * by default, inline values can reuse these values directly. However, for field
+     * variables and variables captured from external scopes, they are hidden as properties
+     * of 'this' variable and require additional evaluation to get their values.
+     */
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+        InlineValuesArguments inlineValuesArgs = (InlineValuesArguments) arguments;
+        final int variableCount = inlineValuesArgs == null || inlineValuesArgs.variables == null ? 0 : inlineValuesArgs.variables.length;
+        InlineVariable[] inlineVariables = inlineValuesArgs.variables;
+        StackFrameReference stackFrameReference = (StackFrameReference) context.getRecyclableIdPool().getObjectById(inlineValuesArgs.frameId);
+        if (stackFrameReference == null) {
+            logger.log(Level.SEVERE, String.format("InlineValues failed: invalid stackframe id %d.", inlineValuesArgs.frameId));
+            response.body = new Responses.InlineValuesResponse(null);
+            return CompletableFuture.completedFuture(response);
+        }
+
+        // Async mode is supposed to be performant, then disable the advanced features like inline values.
+        if (context.getJDWPLatency() > VariablesRequestHandler.USABLE_JDWP_LATENCY
+            && context.asyncJDWP(VariablesRequestHandler.USABLE_JDWP_LATENCY)) {
+            response.body = new Responses.InlineValuesResponse(null);
+            return CompletableFuture.completedFuture(response);
+        }
+
+        IStackFrameManager stackFrameManager = context.getStackFrameManager();
+        StackFrame frame = stackFrameManager.getStackFrame(stackFrameReference);
+        if (frame == null) {
+            logger.log(Level.SEVERE, String.format("InlineValues failed: stale stackframe id %d.", inlineValuesArgs.frameId));
+            response.body = new Responses.InlineValuesResponse(null);
+            return CompletableFuture.completedFuture(response);
+        }
+
+        Variable[] values = new Variable[variableCount];
+        try {
+            if (isLambdaFrame(frame)) {
+                // Lambda expression stores the captured variables from 'outer' scope in a synthetic stackframe below the lambda frame.
+                StackFrame syntheticLambdaFrame = stackFrameReference.getThread().frame(stackFrameReference.getDepth() + 1);
+                resolveValuesFromThisVariable(syntheticLambdaFrame.thisObject(), inlineVariables, values, true);
+            }
+
+            resolveValuesFromThisVariable(frame.thisObject(), inlineVariables, values, false);
+        } catch (Exception ex) {
+            // do nothig
+        }
+
+        Types.Variable[] result = new Types.Variable[variableCount];
+        IVariableFormatter variableFormatter = context.getVariableFormatter();
+        Map<String, Object> formatterOptions = variableFormatter.getDefaultOptions();
+        Map<InlineVariable, Types.Variable> calculatedValues = new HashMap<>();
+        IEvaluationProvider evaluationEngine = context.getProvider(IEvaluationProvider.class);
+        for (int i = 0; i < variableCount; i++) {
+            if (values[i] == null) {
+                continue;
+            }
+
+            if (calculatedValues.containsKey(inlineVariables[i])) {
+                result[i] = calculatedValues.get(inlineVariables[i]);
+                continue;
+            }
+
+            Value value = values[i].value;
+            String name = values[i].name;
+            int indexedVariables = -1;
+            Value sizeValue = null;
+            if (value instanceof ArrayReference) {
+                indexedVariables = ((ArrayReference) value).length();
+            } else if (value instanceof ObjectReference && DebugSettings.getCurrent().showLogicalStructure && evaluationEngine != null) {
+                try {
+                    JavaLogicalStructure structure = JavaLogicalStructureManager.getLogicalStructure((ObjectReference) value);
+                    if (structure != null && structure.getSizeExpression() != null) {
+                        sizeValue = structure.getSize((ObjectReference) value, frame.thread(), evaluationEngine);
+                        if (sizeValue != null && sizeValue instanceof IntegerValue) {
+                            indexedVariables = ((IntegerValue) sizeValue).value();
+                        }
+                    }
+                } catch (CancellationException | IllegalArgumentException | InterruptedException | ExecutionException | UnsupportedOperationException e) {
+                    logger.log(Level.INFO,
+                            String.format("Failed to get the logical size for the type %s.", value.type().name()), e);
+                }
+            }
+
+            Types.Variable formattedVariable = new Types.Variable(name, variableFormatter.valueToString(value, formatterOptions));
+            formattedVariable.indexedVariables = Math.max(indexedVariables, 0);
+            String detailsValue = null;
+            if (sizeValue != null) {
+                detailsValue = "size=" + variableFormatter.valueToString(sizeValue, formatterOptions);
+            } else if (DebugSettings.getCurrent().showToString) {
+                detailsValue = VariableDetailUtils.formatDetailsValue(value, frame.thread(), variableFormatter, formatterOptions, evaluationEngine);
+            }
+
+            if (detailsValue != null) {
+                formattedVariable.value = formattedVariable.value + " " + detailsValue;
+            }
+
+            result[i] = formattedVariable;
+            calculatedValues.put(inlineVariables[i], formattedVariable);
+        }
+
+        response.body = new Responses.InlineValuesResponse(result);
+        return CompletableFuture.completedFuture(response);
+    }
+
+    private static boolean isCapturedLocalVariable(String fieldName, String variableName) {
+        String capturedVariableName = "val$" + variableName;
+        return Objects.equals(fieldName, capturedVariableName)
+            || (fieldName.startsWith(capturedVariableName + "$") && NumberUtils.isDigits(fieldName.substring(capturedVariableName.length() + 1)));
+    }
+
+    private static boolean isCapturedThisVariable(String fieldName) {
+        if (fieldName.startsWith("this$")) {
+            String suffix = fieldName.substring(5).replaceAll("\\$+$", "");
+            return NumberUtils.isDigits(suffix);
+        }
+
+        return false;
+    }
+
+    private static boolean isLambdaFrame(StackFrame frame) {
+        Method method = frame.location().method();
+        return method.isSynthetic() && method.name().startsWith("lambda$");
+    }
+
+    private void resolveValuesFromThisVariable(ObjectReference thisObj, InlineVariable[] unresolvedVariables, Variable[] result,
+        boolean isSyntheticLambdaFrame) {
+        if (thisObj == null) {
+            return;
+        }
+
+        int unresolved = 0;
+        for (Variable item : result) {
+            if (item == null) {
+                unresolved++;
+            }
+        }
+
+        try {
+            ReferenceType type = thisObj.referenceType();
+            String typeName = type.name();
+            ObjectReference enclosingInstance = null;
+            for (Field field : type.allFields()) {
+                String fieldName = field.name();
+                boolean isSyntheticField = field.isSynthetic();
+                Value fieldValue = null;
+                for (int i = 0; i < unresolvedVariables.length; i++) {
+                    if (result[i] != null) {
+                        continue;
+                    }
+
+                    InlineVariable inlineVariable = unresolvedVariables[i];
+                    boolean isInlineFieldVariable = (inlineVariable.declaringClass != null);
+                    boolean isMatch = false;
+                    if (isSyntheticLambdaFrame) {
+                        isMatch = !isInlineFieldVariable && Objects.equals(fieldName, inlineVariable.expression);
+                    } else {
+                        boolean isMatchedField = isInlineFieldVariable
+                            && Objects.equals(fieldName, inlineVariable.expression)
+                            && Objects.equals(typeName, inlineVariable.declaringClass);
+                        boolean isMatchedCapturedVariable = !isInlineFieldVariable
+                            && isSyntheticField
+                            && isCapturedLocalVariable(fieldName, inlineVariable.expression);
+                        isMatch = isMatchedField || isMatchedCapturedVariable;
+
+                        if (!isMatch && isSyntheticField && enclosingInstance == null && isCapturedThisVariable(fieldName)) {
+                            Value value = thisObj.getValue(field);
+                            if (value instanceof ObjectReference) {
+                                enclosingInstance = (ObjectReference) value;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (isMatch) {
+                        fieldValue = fieldValue == null ? thisObj.getValue(field) : fieldValue;
+                        result[i] = new Variable(inlineVariable.expression, fieldValue);
+                        unresolved--;
+                    }
+                }
+
+                if (unresolved <= 0) {
+                    break;
+                }
+            }
+
+            if (unresolved > 0 && enclosingInstance != null) {
+                resolveValuesFromThisVariable(enclosingInstance, unresolvedVariables, result, isSyntheticLambdaFrame);
+            }
+        } catch (Exception ex) {
+            // do nothing
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchRequestHandler.java
index c1f775259..e5662f936 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchRequestHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2018-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -11,37 +11,64 @@
 
 package com.microsoft.java.debug.core.adapter.handler;
 
+import java.io.File;
 import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
 import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.CharsetEncoder;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
+import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.StringUtils;
 
 import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.DebugSettings;
 import com.microsoft.java.debug.core.DebugUtility;
 import com.microsoft.java.debug.core.IDebugSession;
+import com.microsoft.java.debug.core.LaunchException;
+import com.microsoft.java.debug.core.UsageDataSession;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
-import com.microsoft.java.debug.core.adapter.Constants;
 import com.microsoft.java.debug.core.adapter.ErrorCode;
-import com.microsoft.java.debug.core.adapter.Events;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
-import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
-import com.microsoft.java.debug.core.adapter.IVirtualMachineManagerProvider;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
+import com.microsoft.java.debug.core.adapter.LaunchMode;
 import com.microsoft.java.debug.core.adapter.ProcessConsole;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.LaunchArguments;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.Events.OutputEvent;
+import com.microsoft.java.debug.core.protocol.Events.OutputEvent.Category;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.CONSOLE;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.LaunchArguments;
+import com.microsoft.java.debug.core.protocol.Requests.ShortenApproach;
+import com.microsoft.java.debug.core.protocol.Types;
 import com.sun.jdi.connect.IllegalConnectorArgumentsException;
 import com.sun.jdi.connect.VMStartException;
+import com.sun.jdi.event.VMDisconnectEvent;
 
 public class LaunchRequestHandler implements IDebugRequestHandler {
-    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    protected static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    protected static final long RUNINTERMINAL_TIMEOUT = 10 * 1000;
+    protected ILaunchDelegate activeLaunchHandler;
+    private CompletableFuture<Boolean> waitForDebuggeeConsole = new CompletableFuture<>();
 
     @Override
     public List<Command> getTargetCommands() {
@@ -49,70 +76,323 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
-        LaunchArguments launchArguments = (LaunchArguments) arguments;
-        if (StringUtils.isBlank(launchArguments.mainClass) || launchArguments.classPaths == null
-                || launchArguments.classPaths.length == 0) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.ARGUMENT_MISSING,
-                    String.format("Failed to launch debuggee VM. Missing mainClass or classPath options in launch configuration"));
-            return;
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+        if (!context.isInitialized()) {
+            final String errorMessage = "'launch' request is rejected since the debug session has not been initialized yet.";
+            logger.log(Level.SEVERE, errorMessage);
+            return CompletableFuture.completedFuture(
+                AdapterUtils.setErrorResponse(response, ErrorCode.LAUNCH_FAILURE, errorMessage));
         }
+        LaunchArguments launchArguments = (LaunchArguments) arguments;
+        Map<String, Object> traceInfo = new HashMap<>();
+        traceInfo.put("asyncJDWP", context.asyncJDWP());
+        traceInfo.put("noDebug", launchArguments.noDebug);
+        traceInfo.put("console", launchArguments.console);
+        UsageDataSession.recordInfo("launch debug info", traceInfo);
 
-        context.setAttached(false);
-        context.setSourcePaths(launchArguments.sourcePaths);
+        activeLaunchHandler = launchArguments.noDebug ? new LaunchWithoutDebuggingDelegate((daContext) -> handleTerminatedEvent(daContext))
+                : new LaunchWithDebuggingDelegate();
+        return handleLaunchCommand(arguments, response, context);
+    }
 
-        if (StringUtils.isBlank(launchArguments.encoding)) {
-            context.setDebuggeeEncoding(StandardCharsets.UTF_8);
-        } else {
+    protected CompletableFuture<Response> handleLaunchCommand(Arguments arguments, Response response, IDebugAdapterContext context) {
+        LaunchArguments launchArguments = (LaunchArguments) arguments;
+        // validation
+        if (StringUtils.isBlank(launchArguments.mainClass)
+                || ArrayUtils.isEmpty(launchArguments.modulePaths) && ArrayUtils.isEmpty(launchArguments.classPaths)) {
+            throw AdapterUtils.createCompletionException(
+                "Failed to launch debuggee VM. Missing mainClass or modulePaths/classPaths options in launch configuration.",
+                ErrorCode.ARGUMENT_MISSING);
+        }
+        if (StringUtils.isNotBlank(launchArguments.encoding)) {
             if (!Charset.isSupported(launchArguments.encoding)) {
-                AdapterUtils.setErrorResponse(response, ErrorCode.INVALID_ENCODING,
-                        String.format("Failed to launch debuggee VM. 'encoding' options in launch configuration is not recognized."));
-                return;
+                throw AdapterUtils.createCompletionException(
+                    "Failed to launch debuggee VM. 'encoding' options in the launch configuration is not recognized.",
+                    ErrorCode.INVALID_ENCODING);
             }
-
             context.setDebuggeeEncoding(Charset.forName(launchArguments.encoding));
+            if (StringUtils.isBlank(launchArguments.vmArgs)) {
+                launchArguments.vmArgs = String.format("-Dfile.encoding=%s", context.getDebuggeeEncoding().name());
+            } else {
+                // if vmArgs already has the file.encoding settings, duplicate options for jvm will not cause an error, the right most value wins
+                launchArguments.vmArgs = String.format("%s -Dfile.encoding=%s", launchArguments.vmArgs, context.getDebuggeeEncoding().name());
+            }
+        }
+
+        context.setLaunchMode(launchArguments.noDebug ? LaunchMode.NO_DEBUG : LaunchMode.DEBUG);
+
+        activeLaunchHandler.preLaunch(launchArguments, context);
+
+        // Use the specified cli style to launch the program.
+        if (launchArguments.shortenCommandLine == ShortenApproach.JARMANIFEST) {
+            if (ArrayUtils.isNotEmpty(launchArguments.classPaths)) {
+                try {
+                    Path tempfile = LaunchUtils.generateClasspathJar(launchArguments.classPaths);
+                    launchArguments.vmArgs += " -cp \"" + tempfile.toAbsolutePath().toString() + "\"";
+                    launchArguments.classPaths = new String[0];
+                    context.setClasspathJar(tempfile);
+                } catch (IllegalArgumentException | MalformedURLException ex) {
+                    logger.log(Level.SEVERE, String.format("Failed to launch the program with jarmanifest style: %s", ex.toString(), ex));
+                    throw AdapterUtils.createCompletionException("Failed to launch the program with jarmanifest style: " + ex.toString(),
+                            ErrorCode.LAUNCH_FAILURE, ex);
+                } catch (IOException e) {
+                    logger.log(Level.SEVERE, String.format("Failed to create a temp classpath.jar: %s", e.toString()), e);
+                }
+            }
+        } else if (launchArguments.shortenCommandLine == ShortenApproach.ARGFILE) {
+            try {
+                /**
+                 * See the JDK spec https://docs.oracle.com/en/java/javase/18/docs/specs/man/java.html#java-command-line-argument-files.
+                 * The argument file must contain only ASCII characters or characters in system default encoding that's ASCII friendly.
+                 */
+                Charset systemCharset = LaunchUtils.getSystemCharset();
+                CharsetEncoder encoder = systemCharset.newEncoder();
+                String vmArgsForShorten = null;
+                String[] classPathsForShorten = null;
+                String[] modulePathsForShorten = null;
+                if (StringUtils.isNotBlank(launchArguments.vmArgs)) {
+                    if (!encoder.canEncode(launchArguments.vmArgs)) {
+                        logger.warning(String.format("Cannot generate the 'vmArgs' argument into the argfile because it contains characters "
+                            + "that cannot be encoded in the system charset '%s'.", systemCharset.displayName()));
+                    } else {
+                        vmArgsForShorten = launchArguments.vmArgs;
+                    }
+                }
+
+                if (ArrayUtils.isNotEmpty(launchArguments.classPaths)) {
+                    if (!encoder.canEncode(String.join(File.pathSeparator, launchArguments.classPaths))) {
+                        logger.warning(String.format("Cannot generate the '-cp' argument into the argfile because it contains characters "
+                            + "that cannot be encoded in the system charset '%s'.", systemCharset.displayName()));
+                    } else {
+                        classPathsForShorten = launchArguments.classPaths;
+                    }
+                }
+
+                if (ArrayUtils.isNotEmpty(launchArguments.modulePaths)) {
+                    if (!encoder.canEncode(String.join(File.pathSeparator, launchArguments.modulePaths))) {
+                        logger.warning(String.format("Cannot generate the '--module-path' argument into the argfile because it contains characters "
+                            + "that cannot be encoded in the system charset '%s'.", systemCharset.displayName()));
+                    } else {
+                        modulePathsForShorten = launchArguments.modulePaths;
+                    }
+                }
+
+                if (vmArgsForShorten != null || classPathsForShorten != null || modulePathsForShorten != null) {
+                    Path tempfile = LaunchUtils.generateArgfile(vmArgsForShorten, classPathsForShorten, modulePathsForShorten, systemCharset);
+                    launchArguments.vmArgs = (vmArgsForShorten == null ? launchArguments.vmArgs : "")
+                                                + " \"@" + tempfile.toAbsolutePath().toString() + "\"";
+                    launchArguments.classPaths = (classPathsForShorten == null ? launchArguments.classPaths : new String[0]);
+                    launchArguments.modulePaths = (modulePathsForShorten == null ? launchArguments.modulePaths : new String[0]);
+                    context.setArgsfile(tempfile);
+                }
+            } catch (IOException e) {
+                logger.log(Level.SEVERE, String.format("Failed to create a temp argfile: %s", e.toString()), e);
+            }
         }
 
+        return launch(launchArguments, response, context).thenCompose(res -> {
+            long processId = context.getProcessId();
+            long shellProcessId = context.getShellProcessId();
+            if (context.getDebuggeeProcess() != null) {
+                processId = context.getDebuggeeProcess().pid();
+            }
+
+            // If processId or shellProcessId exist, send a notification to client.
+            if (processId > 0 || shellProcessId > 0) {
+                context.getProtocolServer().sendEvent(new Events.ProcessIdNotification(processId, shellProcessId));
+            }
+
+            LaunchUtils.releaseTempLaunchFile(context.getClasspathJar());
+            LaunchUtils.releaseTempLaunchFile(context.getArgsfile());
+            if (res.success) {
+                activeLaunchHandler.postLaunch(launchArguments, context);
+            }
+
+            IDebugSession debugSession = context.getDebugSession();
+            if (debugSession != null) {
+                debugSession.getEventHub().events()
+                    .filter((debugEvent) -> debugEvent.event instanceof VMDisconnectEvent)
+                    .subscribe((debugEvent) -> {
+                        context.setVmTerminated();
+                        // Terminate eventHub thread.
+                        try {
+                            debugSession.getEventHub().close();
+                        } catch (Exception e) {
+                            // do nothing.
+                        }
+
+                        handleTerminatedEvent(context);
+                    });
+            }
+            return CompletableFuture.completedFuture(res);
+        });
+    }
+
+    protected void handleTerminatedEvent(IDebugAdapterContext context) {
+        CompletableFuture.runAsync(() -> {
+            try {
+                waitForDebuggeeConsole.get(5, TimeUnit.SECONDS);
+            } catch (InterruptedException | ExecutionException | TimeoutException e) {
+                // do nothing.
+            }
+
+            context.getProtocolServer().sendEvent(new Events.TerminatedEvent());
+        });
+    }
 
-        if (StringUtils.isBlank(launchArguments.vmArgs)) {
-            launchArguments.vmArgs = String.format("-Dfile.encoding=%s", context.getDebuggeeEncoding().name());
+    /**
+     * Construct the Java command lines based on the given launch arguments.
+     * @param launchArguments - The launch arguments
+     * @param serverMode - whether to enable the debug port with server mode
+     * @param address - the debug port
+     * @return the command arrays
+     */
+    public static String[] constructLaunchCommands(LaunchArguments launchArguments, boolean serverMode, String address) {
+        List<String> launchCmds = new ArrayList<>();
+        if (launchArguments.launcherScript != null) {
+            launchCmds.add(launchArguments.launcherScript);
+        }
+
+        if (StringUtils.isNotBlank(launchArguments.javaExec)) {
+            launchCmds.add(launchArguments.javaExec);
         } else {
-            // if vmArgs already has the file.encoding settings, duplicate options for jvm will not cause an error, the right most value wins
-            launchArguments.vmArgs = String.format("%s -Dfile.encoding=%s", launchArguments.vmArgs, context.getDebuggeeEncoding().name());
+            final String javaHome = StringUtils.isNotEmpty(DebugSettings.getCurrent().javaHome) ? DebugSettings.getCurrent().javaHome
+                    : System.getProperty("java.home");
+            launchCmds.add(Paths.get(javaHome, "bin", "java").toString());
+        }
+        if (StringUtils.isNotEmpty(address)) {
+            launchCmds.add(String.format("-agentlib:jdwp=transport=dt_socket,server=%s,suspend=y,address=%s", serverMode ? "y" : "n", address));
+        }
+        if (StringUtils.isNotBlank(launchArguments.vmArgs)) {
+            launchCmds.addAll(DebugUtility.parseArguments(launchArguments.vmArgs));
+        }
+        if (ArrayUtils.isNotEmpty(launchArguments.modulePaths)) {
+            launchCmds.add("--module-path");
+            launchCmds.add(String.join(File.pathSeparator, launchArguments.modulePaths));
+        }
+        if (ArrayUtils.isNotEmpty(launchArguments.classPaths)) {
+            launchCmds.add("-cp");
+            launchCmds.add(String.join(File.pathSeparator, launchArguments.classPaths));
+        }
+        // For java 9 project, should specify "-m $MainClass".
+        String[] mainClasses = launchArguments.mainClass.split("/");
+        if (mainClasses.length == 2) {
+            launchCmds.add("-m");
+        }
+        launchCmds.add(launchArguments.mainClass);
+        if (StringUtils.isNotBlank(launchArguments.args)) {
+            launchCmds.addAll(DebugUtility.parseArguments(launchArguments.args));
         }
+        return launchCmds.toArray(new String[0]);
+    }
 
+    protected CompletableFuture<Response> launch(LaunchArguments launchArguments, Response response, IDebugAdapterContext context) {
+        logger.info("Trying to launch Java Program with options:\n" + String.format("main-class: %s\n", launchArguments.mainClass)
+                + String.format("args: %s\n", launchArguments.args)
+                + String.format("module-path: %s\n", StringUtils.join(launchArguments.modulePaths, File.pathSeparator))
+                + String.format("class-path: %s\n", StringUtils.join(launchArguments.classPaths, File.pathSeparator))
+                + String.format("vmArgs: %s", launchArguments.vmArgs));
 
-        IVirtualMachineManagerProvider vmProvider = context.getProvider(IVirtualMachineManagerProvider.class);
-        ISourceLookUpProvider sourceProvider = context.getProvider(ISourceLookUpProvider.class);
-        Map<String, Object> options = sourceProvider.getDefaultOptions();
-        options.put(Constants.DEBUGGEE_ENCODING, context.getDebuggeeEncoding());
-        if (launchArguments.projectName != null) {
-            options.put(Constants.PROJECTNAME, launchArguments.projectName);
+        if (context.supportsRunInTerminalRequest()
+                && (launchArguments.console == CONSOLE.integratedTerminal || launchArguments.console == CONSOLE.externalTerminal)) {
+            waitForDebuggeeConsole.complete(true);
+            return activeLaunchHandler.launchInTerminal(launchArguments, response, context);
         }
-        sourceProvider.initialize(options);
 
+        CompletableFuture<Response> resultFuture = new CompletableFuture<>();
         try {
-            logger.info(String.format("Trying to launch Java Program with options \"%s -cp %s %s %s\" .",
-                    launchArguments.vmArgs, StringUtils.join(launchArguments.classPaths, ";"), launchArguments.mainClass, launchArguments.args));
-            IDebugSession debugSession = DebugUtility.launch(vmProvider.getVirtualMachineManager(),
-                    launchArguments.mainClass, launchArguments.args, launchArguments.vmArgs, Arrays.asList(launchArguments.classPaths));
-            context.setDebugSession(debugSession);
-            logger.info("Launching debuggee VM succeeded.");
-
-            ProcessConsole debuggeeConsole = new ProcessConsole(debugSession.process(), "Debuggee", context.getDebuggeeEncoding());
-            debuggeeConsole.onStdout((output) -> {
-                // When DA receives a new OutputEvent, it just shows that on Debug Console and doesn't affect the DA's dispatching workflow.
-                // That means the debugger can send OutputEvent to DA at any time.
-                context.sendEvent(Events.OutputEvent.createStdoutOutput(output));
-            });
-
-            debuggeeConsole.onStderr((err) -> {
-                context.sendEvent(Events.OutputEvent.createStderrOutput(err));
-            });
+            Process debuggeeProcess = activeLaunchHandler.launch(launchArguments, context);
+            context.setDebuggeeProcess(debuggeeProcess);
+            ProcessConsole debuggeeConsole = new ProcessConsole(debuggeeProcess, "Debuggee", context.getDebuggeeEncoding());
+            debuggeeConsole.lineMessages()
+                .map((message) -> convertToOutputEvent(message.output, message.category, context))
+                .doFinally(() -> waitForDebuggeeConsole.complete(true))
+                .subscribe((event) -> context.getProtocolServer().sendEvent(event));
             debuggeeConsole.start();
+            resultFuture.complete(response);
+        } catch (LaunchException e) {
+            if (StringUtils.isNotBlank(e.getStdout())) {
+                OutputEvent event = convertToOutputEvent(e.getStdout(), Category.stdout, context);
+                context.getProtocolServer().sendEvent(event);
+            }
+            if (StringUtils.isNotBlank(e.getStderr())) {
+                OutputEvent event = convertToOutputEvent(e.getStderr(), Category.stderr, context);
+                context.getProtocolServer().sendEvent(event);
+            }
+
+            resultFuture.completeExceptionally(
+                    new DebugException(
+                            String.format("Failed to launch debuggee VM. Reason: %s", e.getMessage()),
+                            ErrorCode.LAUNCH_FAILURE.getId()
+                    )
+            );
         } catch (IOException | IllegalConnectorArgumentsException | VMStartException e) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.LAUNCH_FAILURE,
-                    String.format("Failed to launch debuggee VM. Reason: %s", e.toString()));
+            resultFuture.completeExceptionally(
+                    new DebugException(
+                            String.format("Failed to launch debuggee VM. Reason: %s", e.toString()),
+                            ErrorCode.LAUNCH_FAILURE.getId()
+                    )
+            );
         }
+
+        return resultFuture;
+    }
+
+    private static final Pattern STACKTRACE_PATTERN = Pattern.compile("\\s+at\\s+([\\w$\\.]+\\/)?(([\\w$]+\\.)+[<\\w$>]+)\\(([\\w-$]+\\.java:\\d+)\\)");
+
+    private static OutputEvent convertToOutputEvent(String message, Category category, IDebugAdapterContext context) {
+        Matcher matcher = STACKTRACE_PATTERN.matcher(message);
+        if (matcher.find()) {
+            String methodField = matcher.group(2);
+            String locationField = matcher.group(matcher.groupCount());
+            String fullyQualifiedName = methodField.substring(0, methodField.lastIndexOf("."));
+            String packageName = fullyQualifiedName.lastIndexOf(".") > -1 ? fullyQualifiedName.substring(0, fullyQualifiedName.lastIndexOf(".")) : "";
+            String[] locations = locationField.split(":");
+            String sourceName = locations[0];
+            int lineNumber = Integer.parseInt(locations[1]);
+            String sourcePath = StringUtils.isBlank(packageName) ? sourceName
+                    : packageName.replace('.', File.separatorChar) + File.separatorChar + sourceName;
+            Types.Source source = null;
+            try {
+                source = StackTraceRequestHandler.convertDebuggerSourceToClient(fullyQualifiedName, sourceName, sourcePath, context);
+            } catch (URISyntaxException e) {
+                // do nothing.
+            }
+
+            return new OutputEvent(category, message, source, lineNumber);
+        }
+
+        return new OutputEvent(category, message);
+    }
+
+    protected static String[] constructEnvironmentVariables(LaunchArguments launchArguments) {
+        String[] envVars = null;
+        if (launchArguments.env != null && !launchArguments.env.isEmpty()) {
+            Map<String, String> environment = new HashMap<>(System.getenv());
+            List<String> duplicated = new ArrayList<>();
+            for (Entry<String, String> entry : launchArguments.env.entrySet()) {
+                if (environment.containsKey(entry.getKey())) {
+                    duplicated.add(entry.getKey());
+                }
+                environment.put(entry.getKey(), entry.getValue());
+            }
+            // For duplicated variables, show a warning message.
+            if (!duplicated.isEmpty()) {
+                logger.warning(String.format("There are duplicated environment variables. The values specified in launch.json will be used. "
+                        + "Here are the duplicated entries: %s.", String.join(",", duplicated)));
+            }
+
+            envVars = new String[environment.size()];
+            int i = 0;
+            for (Entry<String, String> entry : environment.entrySet()) {
+                envVars[i++] = entry.getKey() + "=" + entry.getValue();
+            }
+        }
+        return envVars;
+    }
+
+    public static String parseMainClassWithoutModuleName(String mainClass) {
+        int index = mainClass.indexOf('/');
+        return mainClass.substring(index + 1);
     }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchUtils.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchUtils.java
new file mode 100644
index 000000000..7370328b2
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchUtils.java
@@ -0,0 +1,392 @@
+/*******************************************************************************
+* Copyright (c) 2021-2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.math.BigInteger;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.jar.Attributes;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.SystemUtils;
+
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+
+public class LaunchUtils {
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    private static Set<Path> tempFilesInUse = new HashSet<>();
+    private static final Charset SYSTEM_CHARSET;
+
+    static {
+        Charset result = null;
+        try {
+            // JEP 400: Java 17+ populates this system property.
+            String encoding = System.getProperty("native.encoding"); //$NON-NLS-1$
+            if (encoding != null && !encoding.isBlank()) {
+                result = Charset.forName(encoding);
+            } else {
+                // JVM internal property, works on older JVM's too
+                encoding = System.getProperty("sun.jnu.encoding"); //$NON-NLS-1$
+                if (encoding != null && !encoding.isBlank()) {
+                    result = Charset.forName(encoding);
+                }
+            }
+        } catch (Exception e) {
+            logger.log(Level.SEVERE, "Error occurs during resolving system encoding", e);
+        }
+        if (result == null) {
+            // This is always UTF-8 on Java >= 18.
+            result = Charset.defaultCharset();
+        }
+        SYSTEM_CHARSET = result;
+    }
+
+    public static Charset getSystemCharset() {
+        return SYSTEM_CHARSET;
+    }
+
+    /**
+     * Generate the classpath parameters to a temporary classpath.jar.
+     * @param classPaths - the classpath parameters
+     * @return the file path of the generate classpath.jar
+     * @throws IOException Some errors occur during generating the classpath.jar
+     */
+    public static synchronized Path generateClasspathJar(String[] classPaths) throws IOException {
+        List<String> classpathUrls = new ArrayList<>();
+        for (String classpath : classPaths) {
+            classpathUrls.add(AdapterUtils.toUrl(classpath));
+        }
+
+        Manifest manifest = new Manifest();
+        Attributes attributes = manifest.getMainAttributes();
+        attributes.put(Attributes.Name.MANIFEST_VERSION, "1.0");
+        // In jar manifest, the absolute path C:\a.jar should be converted to the url style file:///C:/a.jar
+        String classpathValue = String.join(" ", classpathUrls);
+        attributes.put(Attributes.Name.CLASS_PATH, classpathValue);
+        String baseName = "cp_" + getSha256(classpathValue);
+        cleanupTempFiles(baseName, ".jar");
+        Path tempfile = createTempFile(baseName, ".jar");
+        JarOutputStream jar = new JarOutputStream(new FileOutputStream(tempfile.toFile()), manifest);
+        jar.close();
+        lockTempLaunchFile(tempfile);
+
+        return tempfile;
+    }
+
+    /**
+     * Generate the classpath parameters to a temporary argfile file.
+     * @param classPaths - the classpath parameters
+     * @param modulePaths - the modulepath parameters
+     * @return the file path of the generated argfile
+     * @throws IOException Some errors occur during generating the argfile
+     */
+    public static synchronized Path generateArgfile(String vmArgs, String[] classPaths, String[] modulePaths, Charset encoding) throws IOException {
+        String argfile = "";
+        if (StringUtils.isNotBlank(vmArgs)) {
+            argfile += vmArgs;
+        }
+
+        if (ArrayUtils.isNotEmpty(classPaths)) {
+            argfile += " -cp \"" + String.join(File.pathSeparator, classPaths) + "\"";
+        }
+
+        if (ArrayUtils.isNotEmpty(modulePaths)) {
+            argfile += " --module-path \"" + String.join(File.pathSeparator, modulePaths) + "\"";
+        }
+
+        argfile = argfile.replace("\\", "\\\\");
+        String baseName = "cp_" + getSha256(argfile);
+        cleanupTempFiles(baseName, ".argfile");
+        Path tempfile = createTempFile(baseName, ".argfile");
+        Files.writeString(tempfile, argfile, encoding);
+        lockTempLaunchFile(tempfile);
+
+        return tempfile;
+    }
+
+    public static void lockTempLaunchFile(Path tempFile) {
+        if (tempFile != null) {
+            tempFilesInUse.add(tempFile);
+        }
+    }
+
+    public static void releaseTempLaunchFile(Path tempFile) {
+        if (tempFile != null) {
+            tempFilesInUse.remove(tempFile);
+        }
+    }
+
+    public static ProcessHandle findJavaProcessInTerminalShell(long shellPid, String javaCommand, int timeout/*ms*/) {
+        ProcessHandle shellProcess = ProcessHandle.of(shellPid).orElse(null);
+        if (shellProcess != null) {
+            int retry = 0;
+            final int INTERVAL = 20/*ms*/;
+            final int maxRetries = timeout / INTERVAL;
+            final boolean isCygwinShell = isCygwinShell(shellProcess.info().command().orElse(null));
+            while (retry <= maxRetries) {
+                Optional<ProcessHandle> subProcessHandle = shellProcess.descendants().filter(proc -> {
+                    String command = proc.info().command().orElse("");
+                    return Objects.equals(command, javaCommand) || command.endsWith("\\java.exe") || command.endsWith("/java");
+                }).findFirst();
+
+                if (subProcessHandle.isPresent()) {
+                    if (retry > 0) {
+                        logger.info("Retried " + retry + " times to find Java subProcess.");
+                    }
+                    logger.info("shellPid: " + shellPid + ", javaPid: " + subProcessHandle.get().pid());
+                    return subProcessHandle.get();
+                } else if (isCygwinShell) {
+                    long javaPid = findJavaProcessByCygwinPsCommand(shellProcess, javaCommand);
+                    if (javaPid > 0) {
+                        if (retry > 0) {
+                            logger.info("Retried " + retry + " times to find Java subProcess.");
+                        }
+                        logger.info("[Cygwin Shell] shellPid: " + shellPid + ", javaPid: " + javaPid);
+                        return ProcessHandle.of(javaPid).orElse(null);
+                    }
+                }
+
+                retry++;
+                if (retry > maxRetries) {
+                    break;
+                }
+
+                try {
+                    Thread.sleep(INTERVAL);
+                } catch (InterruptedException e) {
+                    // do nothing
+                }
+            }
+
+            logger.info("Retried " + retry + " times but failed to find Java subProcess of shell pid " + shellPid);
+        }
+
+        return null;
+    }
+
+    private static long findJavaProcessByCygwinPsCommand(ProcessHandle shellProcess, String javaCommand) {
+        String psCommand = detectPsCommandPath(shellProcess.info().command().orElse(null));
+        if (psCommand == null) {
+            return -1;
+        }
+
+        BufferedReader psReader = null;
+        List<PsProcess> psProcs = new ArrayList<>();
+        List<PsProcess> javaCandidates = new ArrayList<>();
+        try {
+            String[] headers = null;
+            int pidIndex = -1;
+            int ppidIndex = -1;
+            int winpidIndex = -1;
+            String line;
+            String javaExeName = Paths.get(javaCommand).toFile().getName().replaceFirst("\\.exe$", "");
+
+            Process p = Runtime.getRuntime().exec(new String[] {psCommand, "-l"});
+            psReader = new BufferedReader(new InputStreamReader(p.getInputStream()));
+            /**
+             * Here is a sample output when running ps command in Cygwin/MINGW64 shell.
+             *       PID    PPID    PGID     WINPID   TTY         UID    STIME COMMAND
+             *      1869       1    1869       7852  cons2       4096 15:29:27 /usr/bin/bash
+             *      2271       1    2271      30820  cons4       4096 19:38:30 /usr/bin/bash
+             *      1812       1    1812      21540  cons1       4096 15:05:03 /usr/bin/bash
+             *      2216       1    2216      11328  cons3       4096 19:38:18 /usr/bin/bash
+             *      1720       1    1720       5404  cons0       4096 13:46:42 /usr/bin/bash
+             *      2269    2216    2269       6676  cons3       4096 19:38:21 /c/Program Files/Microsoft/jdk-11.0.14.9-hotspot/bin/java
+             *      1911    1869    1869      29708  cons2       4096 15:29:31 /c/Program Files/nodejs/node
+             *      2315    2271    2315      18064  cons4       4096 19:38:34 /usr/bin/ps
+             */
+            while ((line = psReader.readLine()) != null) {
+                String[] cols = line.strip().split("\\s+");
+                if (headers == null) {
+                    headers = cols;
+                    pidIndex = ArrayUtils.indexOf(headers, "PID");
+                    ppidIndex = ArrayUtils.indexOf(headers, "PPID");
+                    winpidIndex = ArrayUtils.indexOf(headers, "WINPID");
+                    if (pidIndex < 0 || ppidIndex < 0 || winpidIndex < 0) {
+                        logger.warning("Failed to find Java process because ps command is not the standard Cygwin ps command.");
+                        return -1;
+                    }
+                } else if (cols.length >= headers.length) {
+                    long pid = Long.parseLong(cols[pidIndex]);
+                    long ppid = Long.parseLong(cols[ppidIndex]);
+                    long winpid = Long.parseLong(cols[winpidIndex]);
+                    PsProcess process = new PsProcess(pid, ppid, winpid);
+                    psProcs.add(process);
+                    if (cols[cols.length - 1].endsWith("/" + javaExeName) || cols[cols.length - 1].endsWith("/java")) {
+                        javaCandidates.add(process);
+                    }
+                }
+            }
+        } catch (Exception err) {
+            logger.log(Level.WARNING, "Failed to find Java process by Cygwin ps command.", err);
+        } finally {
+            if (psReader != null) {
+                try {
+                    psReader.close();
+                } catch (IOException e) {
+                    // ignore
+                }
+            }
+        }
+
+        if (!javaCandidates.isEmpty()) {
+            Set<Long> descendantWinpids = shellProcess.descendants().map(proc -> proc.pid()).collect(Collectors.toSet());
+            long shellWinpid = shellProcess.pid();
+            for (PsProcess javaCandidate: javaCandidates) {
+                if (descendantWinpids.contains(javaCandidate.winpid)) {
+                    return javaCandidate.winpid;
+                }
+
+                for (PsProcess psProc : psProcs) {
+                    if (javaCandidate.ppid != psProc.pid) {
+                        continue;
+                    }
+
+                    if (descendantWinpids.contains(psProc.winpid) || psProc.winpid == shellWinpid) {
+                        return javaCandidate.winpid;
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        return -1;
+    }
+
+    private static boolean isCygwinShell(String shellPath) {
+        if (!SystemUtils.IS_OS_WINDOWS || shellPath == null) {
+            return false;
+        }
+
+        String lowerShellPath = shellPath.toLowerCase();
+        return lowerShellPath.endsWith("git\\bin\\bash.exe")
+            || lowerShellPath.endsWith("git\\usr\\bin\\bash.exe")
+            || lowerShellPath.endsWith("mintty.exe")
+            || lowerShellPath.endsWith("cygwin64\\bin\\bash.exe")
+            || (lowerShellPath.endsWith("bash.exe") && detectPsCommandPath(shellPath) != null)
+            || (lowerShellPath.endsWith("sh.exe") && detectPsCommandPath(shellPath) != null);
+    }
+
+    private static String detectPsCommandPath(String shellPath) {
+        if (shellPath == null) {
+            return null;
+        }
+
+        Path psPath = Paths.get(shellPath, "..\\ps.exe");
+        if (!Files.exists(psPath)) {
+            psPath = Paths.get(shellPath, "..\\..\\usr\\bin\\ps.exe");
+            if (!Files.exists(psPath)) {
+                psPath = null;
+            }
+        }
+
+        if (psPath == null) {
+            return null;
+        }
+
+        return psPath.normalize().toString();
+    }
+
+    private static Path tmpdir = null;
+
+    private static synchronized Path getTmpDir() throws IOException {
+        if (tmpdir == null) {
+            Path tmpfile = Files.createTempFile("", UUID.randomUUID().toString());
+            tmpdir = tmpfile.getParent();
+            try {
+                Files.deleteIfExists(tmpfile);
+            } catch (Exception ex) {
+                // do nothing
+            }
+        }
+
+        return tmpdir;
+    }
+
+    private static void cleanupTempFiles(String baseName, String suffix) throws IOException {
+        for (int i = 0; ; i++) {
+            Path tempFile = getTmpDir().resolve(baseName + (i == 0 ? "" : i) + suffix);
+            if (tempFilesInUse.contains(tempFile)) {
+                continue;
+            } else if (!Files.exists(tempFile)) {
+                break;
+            } else {
+                try {
+                    // delete the old temp file
+                    Files.deleteIfExists(tempFile);
+                } catch (Exception e) {
+                    // do nothing
+                }
+            }
+        }
+    }
+
+    private static Path createTempFile(String baseName, String suffix) throws IOException {
+        // loop until the temp file can be created
+        for (int i = 0; ; i++) {
+            Path tempFile = getTmpDir().resolve(baseName + (i == 0 ? "" : i) + suffix);
+            if (!Files.exists(tempFile)) {
+                return Files.createFile(tempFile);
+            }
+        }
+    }
+
+    private static String getSha256(String input) {
+        try {
+            MessageDigest md = MessageDigest.getInstance("SHA-256");
+            byte[] messageDigest = md.digest(input.getBytes());
+            // Use only first 16 bytes to keep filename shorter
+            byte[] truncated = new byte[16];
+            System.arraycopy(messageDigest, 0, truncated, 0, 16);
+            BigInteger hash = new BigInteger(1, truncated);
+            return hash.toString(Character.MAX_RADIX);
+        } catch (NoSuchAlgorithmException e) {
+            return Integer.toString(input.hashCode(), Character.MAX_RADIX);
+        }
+    }
+
+    private static class PsProcess {
+        long pid;
+        long ppid;
+        long winpid;
+
+        public PsProcess(long pid, long ppid, long winpid) {
+            this.pid = pid;
+            this.ppid = ppid;
+            this.winpid = winpid;
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchWithDebuggingDelegate.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchWithDebuggingDelegate.java
new file mode 100644
index 000000000..2962294a0
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchWithDebuggingDelegate.java
@@ -0,0 +1,249 @@
+/*******************************************************************************
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.logging.Logger;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.SystemUtils;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.DebugSession;
+import com.microsoft.java.debug.core.DebugUtility;
+import com.microsoft.java.debug.core.IDebugSession;
+import com.microsoft.java.debug.core.adapter.Constants;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.ICompletionsProvider;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.adapter.IHotCodeReplaceProvider;
+import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
+import com.microsoft.java.debug.core.adapter.IVirtualMachineManagerProvider;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.JsonUtils;
+import com.microsoft.java.debug.core.protocol.Messages.Request;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.CONSOLE;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.LaunchArguments;
+import com.microsoft.java.debug.core.protocol.Requests.RunInTerminalRequestArguments;
+import com.microsoft.java.debug.core.protocol.Responses.RunInTerminalResponseBody;
+import com.sun.jdi.VirtualMachine;
+import com.sun.jdi.connect.Connector;
+import com.sun.jdi.connect.IllegalConnectorArgumentsException;
+import com.sun.jdi.connect.ListeningConnector;
+import com.sun.jdi.connect.TransportTimeoutException;
+import com.sun.jdi.connect.VMStartException;
+
+public class LaunchWithDebuggingDelegate implements ILaunchDelegate {
+
+    protected static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    private static final int ATTACH_TERMINAL_TIMEOUT = 20 * 1000;
+    protected static final long RUNINTERMINAL_TIMEOUT = 10 * 1000;
+    private VMHandler vmHandler = new VMHandler();
+
+    @Override
+    public CompletableFuture<Response> launchInTerminal(LaunchArguments launchArguments, Response response, IDebugAdapterContext context) {
+        CompletableFuture<Response> resultFuture = new CompletableFuture<>();
+
+        IVirtualMachineManagerProvider vmProvider = context.getProvider(IVirtualMachineManagerProvider.class);
+        vmHandler.setVmProvider(vmProvider);
+        final String launchInTerminalErrorFormat = "Failed to launch debuggee in terminal. Reason: %s";
+
+        try {
+            List<ListeningConnector> connectors = vmProvider.getVirtualMachineManager().listeningConnectors();
+            ListeningConnector listenConnector = connectors.get(0);
+            Map<String, Connector.Argument> args = listenConnector.defaultArguments();
+            ((Connector.IntegerArgument) args.get("timeout")).setValue(ATTACH_TERMINAL_TIMEOUT);
+            String address = listenConnector.startListening(args);
+
+            final String[] names = launchArguments.mainClass.split("[/\\.]");
+            final String terminalName = "Debug: " + names[names.length - 1];
+            String[] cmds = LaunchRequestHandler.constructLaunchCommands(launchArguments, false, address);
+            RunInTerminalRequestArguments requestArgs = null;
+            if (launchArguments.console == CONSOLE.integratedTerminal) {
+                requestArgs = RunInTerminalRequestArguments.createIntegratedTerminal(
+                        cmds,
+                        launchArguments.cwd,
+                        launchArguments.env,
+                        terminalName);
+            } else {
+                requestArgs = RunInTerminalRequestArguments.createExternalTerminal(
+                        cmds,
+                        launchArguments.cwd,
+                        launchArguments.env,
+                        terminalName);
+            }
+            Request request = new Request(Command.RUNINTERMINAL.getName(),
+                    (JsonObject) JsonUtils.toJsonTree(requestArgs, RunInTerminalRequestArguments.class));
+
+            // Notes: In windows (reference to https://support.microsoft.com/en-us/help/830473/command-prompt-cmd--exe-command-line-string-limitation),
+            // when launching the program in cmd.exe, if the command line length exceed the threshold value (8191 characters),
+            // it will be automatically truncated so that launching in terminal failed. Especially, for maven project, the class path contains
+            // the local .m2 repository path, it may exceed the limit.
+            context.getProtocolServer().sendRequest(request, RUNINTERMINAL_TIMEOUT)
+                .whenComplete((runResponse, ex) -> {
+                    if (runResponse != null) {
+                        if (runResponse.success) {
+                            try {
+                                try {
+                                    RunInTerminalResponseBody terminalResponse = JsonUtils.fromJson(
+                                        JsonUtils.toJson(runResponse.body), RunInTerminalResponseBody.class);
+                                    context.setProcessId(terminalResponse.processId);
+                                    context.setShellProcessId(terminalResponse.shellProcessId);
+                                } catch (JsonSyntaxException e) {
+                                    logger.severe("Failed to resolve runInTerminal response: " + e.toString());
+                                }
+                                VirtualMachine vm = listenConnector.accept(args);
+                                vmHandler.connectVirtualMachine(vm);
+                                context.setDebugSession(new DebugSession(vm));
+                                logger.info("Launching debuggee in terminal console succeeded.");
+                                if (context.getShellProcessId() > 0) {
+                                    ProcessHandle debuggeeProcess = LaunchUtils.findJavaProcessInTerminalShell(context.getShellProcessId(), cmds[0], 0);
+                                    if (debuggeeProcess != null) {
+                                        context.setProcessId(debuggeeProcess.pid());
+                                    }
+                                }
+                                resultFuture.complete(response);
+                            } catch (TransportTimeoutException e) {
+                                int commandLength = StringUtils.length(launchArguments.cwd) + 1;
+                                for (String cmd : cmds) {
+                                    commandLength += StringUtils.length(cmd) + 1;
+                                }
+
+                                final int threshold = SystemUtils.IS_OS_WINDOWS ? 8092 : 32 * 1024;
+                                String errorMessage = String.format(launchInTerminalErrorFormat, e.toString());
+                                if (commandLength >= threshold) {
+                                    errorMessage = "Failed to launch debuggee in terminal. The possible reason is the command line too long. "
+                                            + "More details: " + e.toString();
+                                    logger.severe(errorMessage
+                                            + "\r\n"
+                                            + "The estimated command line length is " + commandLength + ". "
+                                            + "Try to enable shortenCommandLine option in the debug launch configuration.");
+                                }
+
+                                resultFuture.completeExceptionally(
+                                        new DebugException(
+                                                errorMessage,
+                                                ErrorCode.LAUNCH_IN_TERMINAL_FAILURE.getId()
+                                        )
+                                );
+                            } catch (IOException | IllegalConnectorArgumentsException e) {
+                                resultFuture.completeExceptionally(
+                                        new DebugException(
+                                                String.format(launchInTerminalErrorFormat, e.toString()),
+                                                ErrorCode.LAUNCH_IN_TERMINAL_FAILURE.getId()
+                                        )
+                                );
+                            }
+                        } else {
+                            resultFuture.completeExceptionally(
+                                    new DebugException(
+                                            String.format(launchInTerminalErrorFormat, runResponse.message),
+                                            ErrorCode.LAUNCH_IN_TERMINAL_FAILURE.getId()
+                                    )
+                            );
+                        }
+                    } else {
+                        if (ex instanceof CompletionException && ex.getCause() != null) {
+                            ex = ex.getCause();
+                        }
+                        String errorMessage = String.format(launchInTerminalErrorFormat, ex != null ? ex.toString() : "Null response");
+                        resultFuture.completeExceptionally(
+                                new DebugException(
+                                        String.format(launchInTerminalErrorFormat, errorMessage),
+                                        ErrorCode.LAUNCH_IN_TERMINAL_FAILURE.getId()
+                                )
+                        );
+                    }
+                });
+        } catch (IOException | IllegalConnectorArgumentsException e) {
+            resultFuture.completeExceptionally(
+                    new DebugException(
+                            String.format(launchInTerminalErrorFormat, e.toString()),
+                            ErrorCode.LAUNCH_IN_TERMINAL_FAILURE.getId()
+                    )
+            );
+        }
+
+        return resultFuture;
+    }
+
+    @Override
+    public Process launch(LaunchArguments launchArguments, IDebugAdapterContext context)
+            throws IOException, IllegalConnectorArgumentsException, VMStartException {
+        IVirtualMachineManagerProvider vmProvider = context.getProvider(IVirtualMachineManagerProvider.class);
+        vmHandler.setVmProvider(vmProvider);
+
+        IDebugSession debugSession = DebugUtility.launch(
+                vmProvider.getVirtualMachineManager(),
+                launchArguments.mainClass,
+                launchArguments.args,
+                launchArguments.vmArgs,
+                Arrays.asList(launchArguments.modulePaths),
+                Arrays.asList(launchArguments.classPaths),
+                launchArguments.cwd,
+                LaunchRequestHandler.constructEnvironmentVariables(launchArguments),
+                launchArguments.javaExec);
+        context.setDebugSession(debugSession);
+        vmHandler.connectVirtualMachine(debugSession.getVM());
+
+        logger.info("Launching debuggee VM succeeded.");
+        return debugSession.process();
+    }
+
+    @Override
+    public void postLaunch(LaunchArguments launchArguments, IDebugAdapterContext context) {
+        Map<String, Object> options = new HashMap<>();
+        options.put(Constants.DEBUGGEE_ENCODING, context.getDebuggeeEncoding());
+        if (launchArguments.projectName != null) {
+            options.put(Constants.PROJECT_NAME, launchArguments.projectName);
+        }
+        if (launchArguments.mainClass != null) {
+            options.put(Constants.MAIN_CLASS, launchArguments.mainClass);
+        }
+
+        // TODO: Clean up the initialize mechanism
+        ISourceLookUpProvider sourceProvider = context.getProvider(ISourceLookUpProvider.class);
+        sourceProvider.initialize(context, options);
+        IEvaluationProvider evaluationProvider = context.getProvider(IEvaluationProvider.class);
+        evaluationProvider.initialize(context, options);
+        IHotCodeReplaceProvider hcrProvider = context.getProvider(IHotCodeReplaceProvider.class);
+        hcrProvider.initialize(context, options);
+        ICompletionsProvider completionsProvider = context.getProvider(ICompletionsProvider.class);
+        completionsProvider.initialize(context, options);
+
+        // send an InitializedEvent to indicate that the debugger is ready to accept
+        // configuration requests (e.g. SetBreakpointsRequest, SetExceptionBreakpointsRequest).
+        context.getProtocolServer().sendEvent(new Events.InitializedEvent());
+    }
+
+    @Override
+    public void preLaunch(LaunchArguments launchArguments, IDebugAdapterContext context) {
+        // debug only
+        context.setAttached(false);
+        context.setSourcePaths(launchArguments.sourcePaths);
+        context.setVmStopOnEntry(launchArguments.stopOnEntry);
+        context.setMainClass(LaunchRequestHandler.parseMainClassWithoutModuleName(launchArguments.mainClass));
+        context.setStepFilters(launchArguments.stepFilters);
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchWithoutDebuggingDelegate.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchWithoutDebuggingDelegate.java
new file mode 100644
index 000000000..82a481718
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/LaunchWithoutDebuggingDelegate.java
@@ -0,0 +1,168 @@
+/*******************************************************************************
+* Copyright (c) 2018-2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.function.Consumer;
+import java.util.logging.Logger;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.JsonUtils;
+import com.microsoft.java.debug.core.protocol.Messages.Request;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.CONSOLE;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.LaunchArguments;
+import com.microsoft.java.debug.core.protocol.Requests.RunInTerminalRequestArguments;
+import com.microsoft.java.debug.core.protocol.Responses.RunInTerminalResponseBody;
+import com.sun.jdi.connect.IllegalConnectorArgumentsException;
+import com.sun.jdi.connect.VMStartException;
+
+public class LaunchWithoutDebuggingDelegate implements ILaunchDelegate {
+    protected static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    protected static final long RUNINTERMINAL_TIMEOUT = 10 * 1000;
+    private Consumer<IDebugAdapterContext> terminateHandler;
+
+    public LaunchWithoutDebuggingDelegate(Consumer<IDebugAdapterContext> terminateHandler) {
+        this.terminateHandler = terminateHandler;
+    }
+
+    @Override
+    public Process launch(LaunchArguments launchArguments, IDebugAdapterContext context)
+            throws IOException, IllegalConnectorArgumentsException, VMStartException {
+        String[] cmds = LaunchRequestHandler.constructLaunchCommands(launchArguments, false, null);
+        File workingDir = null;
+        if (launchArguments.cwd != null && Files.isDirectory(Paths.get(launchArguments.cwd))) {
+            workingDir = new File(launchArguments.cwd);
+        }
+        Process debuggeeProcess = Runtime.getRuntime().exec(cmds, LaunchRequestHandler.constructEnvironmentVariables(launchArguments),
+                workingDir);
+        new Thread() {
+            public void run() {
+                try {
+                    debuggeeProcess.waitFor();
+                } catch (InterruptedException ignore) {
+                    logger.warning(String.format("Current thread is interrupted. Reason: %s", ignore.toString()));
+                    debuggeeProcess.destroy();
+                } finally {
+                    terminateHandler.accept(context);
+                }
+            }
+        }.start();
+        logger.info("Launching debuggee proccess succeeded.");
+        return debuggeeProcess;
+    }
+
+    @Override
+    public void postLaunch(LaunchArguments launchArguments, IDebugAdapterContext context) {
+        // For NO_DEBUG launch mode, the debugger does not respond to requests like
+        // SetBreakpointsRequest,
+        // but the front end keeps sending them according to the Debug Adapter Protocol.
+        // To avoid receiving them, a workaround is not to send InitializedEvent back to
+        // the front end.
+        // See https://github.com/Microsoft/vscode/issues/55850#issuecomment-412819676
+        return;
+    }
+
+    @Override
+    public CompletableFuture<Response> launchInTerminal(LaunchArguments launchArguments, Response response,
+            IDebugAdapterContext context) {
+        CompletableFuture<Response> resultFuture = new CompletableFuture<>();
+
+        final String launchInTerminalErrorFormat = "Failed to launch debuggee in terminal. Reason: %s";
+
+        final String[] names = launchArguments.mainClass.split("[/\\.]");
+        final String terminalName = "Run: " + names[names.length - 1];
+        String[] cmds = LaunchRequestHandler.constructLaunchCommands(launchArguments, false, null);
+        RunInTerminalRequestArguments requestArgs = null;
+        if (launchArguments.console == CONSOLE.integratedTerminal) {
+            requestArgs = RunInTerminalRequestArguments.createIntegratedTerminal(cmds, launchArguments.cwd,
+                    launchArguments.env, terminalName);
+        } else {
+            requestArgs = RunInTerminalRequestArguments.createExternalTerminal(cmds, launchArguments.cwd,
+                    launchArguments.env, terminalName);
+        }
+        Request request = new Request(Command.RUNINTERMINAL.getName(),
+                (JsonObject) JsonUtils.toJsonTree(requestArgs, RunInTerminalRequestArguments.class));
+
+        // Notes: In windows (reference to
+        // https://support.microsoft.com/en-us/help/830473/command-prompt-cmd--exe-command-line-string-limitation),
+        // when launching the program in cmd.exe, if the command line length exceed the
+        // threshold value (8191 characters),
+        // it will be automatically truncated so that launching in terminal failed.
+        // Especially, for maven project, the class path contains
+        // the local .m2 repository path, it may exceed the limit.
+        context.getProtocolServer().sendRequest(request, RUNINTERMINAL_TIMEOUT).whenComplete((runResponse, ex) -> {
+            if (runResponse != null) {
+                if (runResponse.success) {
+                    ProcessHandle debuggeeProcess = null;
+                    try {
+                        RunInTerminalResponseBody terminalResponse = JsonUtils.fromJson(
+                            JsonUtils.toJson(runResponse.body), RunInTerminalResponseBody.class);
+                        context.setProcessId(terminalResponse.processId);
+                        context.setShellProcessId(terminalResponse.shellProcessId);
+
+                        if (terminalResponse.processId > 0) {
+                            debuggeeProcess = ProcessHandle.of(terminalResponse.processId).orElse(null);
+                        } else if (terminalResponse.shellProcessId > 0) {
+                            debuggeeProcess = LaunchUtils.findJavaProcessInTerminalShell(terminalResponse.shellProcessId, cmds[0], 3000);
+                        }
+
+                        if (debuggeeProcess != null) {
+                            context.setProcessId(debuggeeProcess.pid());
+                            debuggeeProcess.onExit().thenAcceptAsync(proc -> {
+                                context.getProtocolServer().sendEvent(new Events.TerminatedEvent());
+                            });
+                        }
+                    } catch (JsonSyntaxException e) {
+                        logger.severe("Failed to resolve runInTerminal response: " + e.toString());
+                    }
+
+                    if (debuggeeProcess == null || !debuggeeProcess.isAlive()) {
+                        context.getProtocolServer().sendEvent(new Events.TerminatedEvent());
+                    }
+                    resultFuture.complete(response);
+                } else {
+                    resultFuture.completeExceptionally(
+                            new DebugException(String.format(launchInTerminalErrorFormat, runResponse.message),
+                                    ErrorCode.LAUNCH_IN_TERMINAL_FAILURE.getId()));
+                }
+            } else {
+                if (ex instanceof CompletionException && ex.getCause() != null) {
+                    ex = ex.getCause();
+                }
+                String errorMessage = String.format(launchInTerminalErrorFormat,
+                        ex != null ? ex.toString() : "Null response");
+                resultFuture.completeExceptionally(
+                        new DebugException(String.format(launchInTerminalErrorFormat, errorMessage),
+                                ErrorCode.LAUNCH_IN_TERMINAL_FAILURE.getId()));
+            }
+        });
+        return resultFuture;
+    }
+
+    @Override
+    public void preLaunch(LaunchArguments launchArguments, IDebugAdapterContext context) {
+        context.setSourcePaths(launchArguments.sourcePaths);
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ProcessIdHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ProcessIdHandler.java
new file mode 100644
index 000000000..d3eb5ad13
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ProcessIdHandler.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Responses.ProcessIdResponseBody;
+
+public class ProcessIdHandler implements IDebugRequestHandler {
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.PROCESSID);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+        long processId = context.getProcessId();
+        long shellProcessId = context.getShellProcessId();
+        if (context.getDebuggeeProcess() != null) {
+            processId = context.getDebuggeeProcess().pid();
+        }
+
+        response.body = new ProcessIdResponseBody(processId, shellProcessId);
+        return CompletableFuture.completedFuture(response);
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/RefreshFramesHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/RefreshFramesHandler.java
new file mode 100644
index 000000000..b91daaf80
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/RefreshFramesHandler.java
@@ -0,0 +1,136 @@
+/*******************************************************************************
+* Copyright (c) 2023 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.AsyncJdwpUtils;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.protocol.Events.StoppedEvent;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.RefreshFramesArguments;
+import com.sun.jdi.ObjectCollectedException;
+import com.sun.jdi.ThreadReference;
+
+public class RefreshFramesHandler implements IDebugRequestHandler {
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.REFRESHFRAMES);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+        RefreshFramesArguments refreshArgs = (RefreshFramesArguments) arguments;
+        String[] affectedRootPaths = refreshArgs == null ? null : refreshArgs.affectedRootPaths;
+        List<Long> pausedThreads = getPausedThreads(context);
+        for (long threadId : pausedThreads) {
+            if (affectedRootPaths == null || affectedRootPaths.length == 0) {
+                refreshFrames(threadId, context);
+                continue;
+            }
+
+            Set<String> decompiledClasses = context.getThreadCache().getDecompiledClassesByThread(threadId);
+            if (decompiledClasses == null || decompiledClasses.isEmpty()) {
+                continue;
+            }
+
+            if (anyInAffectedRootPaths(decompiledClasses, affectedRootPaths)) {
+                refreshFrames(threadId, context);
+            }
+        }
+
+        return CompletableFuture.completedFuture(response);
+    }
+
+    List<Long> getPausedThreads(IDebugAdapterContext context) {
+        List<Long> results = new ArrayList<>();
+        List<CompletableFuture<Long>> futures = new ArrayList<>();
+        List<ThreadReference> threads = context.getThreadCache().visibleThreads(context);
+        for (ThreadReference thread : threads) {
+            if (context.asyncJDWP()) {
+                futures.add(AsyncJdwpUtils.supplyAsync(() -> {
+                    try {
+                        if (thread.isSuspended()) {
+                            return thread.uniqueID();
+                        }
+                    } catch (ObjectCollectedException ex) {
+                        // Ignore it if the thread is garbage collected.
+                    }
+
+                    return -1L;
+                }));
+            } else {
+                try {
+                    if (thread.isSuspended()) {
+                        results.add(thread.uniqueID());
+                    }
+                } catch (ObjectCollectedException ex) {
+                    // Ignore it if the thread is garbage collected.
+                }
+            }
+        }
+
+        List<Long> awaitedResutls = AsyncJdwpUtils.await(futures);
+        for (Long threadId : awaitedResutls) {
+            if (threadId > 0) {
+                results.add(threadId);
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * See https://github.com/microsoft/vscode/issues/188606,
+     * VS Code doesn't provide a simple way to refetch the stack frames.
+     * We're going to resend a thread stopped event to trick the client
+     * into refetching the thread stack frames.
+     */
+    void refreshFrames(long threadId, IDebugAdapterContext context) {
+        StoppedEvent stoppedEvent = new StoppedEvent(context.getThreadCache().getThreadStoppedReason(threadId), threadId);
+        stoppedEvent.preserveFocusHint = true;
+        context.getProtocolServer().sendEvent(stoppedEvent);
+    }
+
+    boolean anyInAffectedRootPaths(Collection<String> classes, String[] affectedRootPaths) {
+        if (affectedRootPaths == null || affectedRootPaths.length == 0) {
+            return true;
+        }
+
+        for (String classUri : classes) {
+            // decompiled class uri is like 'jdt://contents/rt.jar/java.io/PrintStream.class?=1.helloworld/%5C/usr%5C/lib%5C/jvm%5C/
+            // java-8-oracle%5C/jre%5C/lib%5C/rt.jar%3Cjava.io(PrintStream.class'.
+            if (classUri.startsWith("jdt://contents/")) {
+                String jarName = classUri.substring("jdt://contents/".length());
+                int sep = jarName.indexOf("/");
+                jarName = sep >= 0 ? jarName.substring(0, sep) : jarName;
+                for (String affectedRootPath : affectedRootPaths) {
+                    if (affectedRootPath.endsWith("/" + jarName) || affectedRootPath.endsWith("\\" + jarName)) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/RefreshVariablesHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/RefreshVariablesHandler.java
new file mode 100644
index 000000000..01214b615
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/RefreshVariablesHandler.java
@@ -0,0 +1,50 @@
+/*******************************************************************************
+* Copyright (c) 2021 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.protocol.Events.InvalidatedAreas;
+import com.microsoft.java.debug.core.protocol.Events.InvalidatedEvent;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.RefreshVariablesArguments;
+
+public class RefreshVariablesHandler implements IDebugRequestHandler {
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.REFRESHVARIABLES);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+        RefreshVariablesArguments refreshArgs = (RefreshVariablesArguments) arguments;
+        if (refreshArgs != null) {
+            DebugSettings.getCurrent().showHex = refreshArgs.showHex;
+            DebugSettings.getCurrent().showQualifiedNames = refreshArgs.showQualifiedNames;
+            DebugSettings.getCurrent().showStaticVariables = refreshArgs.showStaticVariables;
+            DebugSettings.getCurrent().showLogicalStructure = refreshArgs.showLogicalStructure;
+            DebugSettings.getCurrent().showToString = refreshArgs.showToString;
+        }
+
+        context.getProtocolServer().sendEvent(new InvalidatedEvent(InvalidatedAreas.VARIABLES));
+        return CompletableFuture.completedFuture(response);
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/RestartFrameHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/RestartFrameHandler.java
new file mode 100644
index 000000000..26ebefaee
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/RestartFrameHandler.java
@@ -0,0 +1,132 @@
+/*******************************************************************************
+* Copyright (c) 2017 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.DebugUtility;
+import com.microsoft.java.debug.core.StackFrameUtility;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.Events.UserNotificationEvent.NotificationType;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.RestartFrameArguments;
+import com.sun.jdi.IncompatibleThreadStateException;
+import com.sun.jdi.StackFrame;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.request.EventRequest;
+import com.sun.jdi.request.StepRequest;
+
+/**
+ * Support Eclipse's `Drop To Frame` action, which is restartFrame in VSCode's
+ * debug.
+ */
+public class RestartFrameHandler implements IDebugRequestHandler {
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Requests.Command.RESTARTFRAME);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+        RestartFrameArguments restartFrameArgs = (RestartFrameArguments) arguments;
+        StackFrameReference stackFrameReference = (StackFrameReference) context.getRecyclableIdPool().getObjectById(restartFrameArgs.frameId);
+
+        if (stackFrameReference == null) {
+            throw AdapterUtils.createCompletionException(
+                String.format("RestartFrame: cannot find the stack frame with frameID %s", restartFrameArgs.frameId),
+                ErrorCode.RESTARTFRAME_FAILURE);
+        }
+
+        if (canRestartFrame(context, stackFrameReference)) {
+            try {
+                ThreadReference reference = stackFrameReference.getThread();
+                popStackFrames(context, stackFrameReference);
+                stepInto(context, reference);
+            } catch (DebugException de) {
+                context.getProtocolServer().sendEvent(new Events.UserNotificationEvent(NotificationType.ERROR, de.getMessage()));
+                throw AdapterUtils.createCompletionException(
+                    String.format("Failed to restart stack frame. Reason: %s", de.getMessage()),
+                    ErrorCode.RESTARTFRAME_FAILURE,
+                    de);
+            }
+            return CompletableFuture.completedFuture(response);
+        } else {
+            context.getProtocolServer().sendEvent(new Events.UserNotificationEvent(NotificationType.ERROR, "Current stack frame doesn't support restart."));
+            throw AdapterUtils.createCompletionException("Current stack frame doesn't support restart.", ErrorCode.RESTARTFRAME_FAILURE);
+        }
+    }
+
+    private boolean canRestartFrame(IDebugAdapterContext context, StackFrameReference frameReference) {
+        if (!context.getDebugSession().getVM().canPopFrames()) {
+            return false;
+        }
+        ThreadReference reference = frameReference.getThread();
+        int totalFrames;
+        try {
+            totalFrames = reference.frameCount();
+        } catch (IncompatibleThreadStateException e) {
+            return false;
+        }
+
+        // The frame cannot be the bottom one of the call stack:
+        if (totalFrames <= frameReference.getDepth() + 1) {
+            return false;
+        }
+
+        StackFrame[] frames = context.getStackFrameManager().reloadStackFrames(reference, 0, frameReference.getDepth() + 2);
+        if (frames.length == 0) {
+            return false;
+        }
+
+        // Cannot restart frame involved with native call stacks:
+        for (int i = 0; i <= frameReference.getDepth() + 1; i++) {
+            if (StackFrameUtility.isNative(frames[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private void popStackFrames(IDebugAdapterContext context, StackFrameReference stackFrameRef) throws DebugException {
+        StackFrame frame = context.getStackFrameManager().getStackFrame(stackFrameRef);
+        if (frame == null) {
+            return;
+        }
+        StackFrameUtility.pop(frame);
+    }
+
+    private void stepInto(IDebugAdapterContext context, ThreadReference thread) {
+        StepRequest request = DebugUtility.createStepIntoRequest(thread, context.getStepFilters().allowClasses, context.getStepFilters().skipClasses);
+        context.getDebugSession().getEventHub().stepEvents().filter(debugEvent -> request.equals(debugEvent.event.request())).take(1).subscribe(debugEvent -> {
+            debugEvent.shouldResume = false;
+            // Have to send two events to keep the UI sync with the step in operations:
+            context.getProtocolServer().sendEvent(new Events.ContinuedEvent(thread.uniqueID()));
+            boolean allThreadsStopped = request.suspendPolicy() == EventRequest.SUSPEND_ALL;
+            context.getProtocolServer().sendEvent(new Events.StoppedEvent("restartframe", thread.uniqueID(), allThreadsStopped));
+            context.getThreadCache().setThreadStoppedReason(thread.uniqueID(), "restartframe");
+        });
+        request.enable();
+        thread.resume();
+    }
+}
\ No newline at end of file
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ScopesRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ScopesRequestHandler.java
index 7409991d7..e7b1a9485 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ScopesRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ScopesRequestHandler.java
@@ -14,18 +14,19 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.ScopesArguments;
-import com.microsoft.java.debug.core.adapter.Responses;
-import com.microsoft.java.debug.core.adapter.Types;
-import com.microsoft.java.debug.core.adapter.variables.JdiObjectProxy;
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
 import com.microsoft.java.debug.core.adapter.variables.VariableProxy;
-import com.sun.jdi.StackFrame;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.ScopesArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types;
+import com.sun.jdi.ThreadReference;
 
 public class ScopesRequestHandler implements IDebugRequestHandler {
 
@@ -35,20 +36,20 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
         ScopesArguments scopesArgs = (ScopesArguments) arguments;
         List<Types.Scope> scopes = new ArrayList<>();
-        JdiObjectProxy<StackFrame> stackFrameProxy = (JdiObjectProxy<StackFrame>) context.getRecyclableIdPool().getObjectById(scopesArgs.frameId);
-        if (stackFrameProxy == null) {
+        StackFrameReference stackFrameReference = (StackFrameReference) context.getRecyclableIdPool().getObjectById(scopesArgs.frameId);
+        if (stackFrameReference == null) {
             response.body = new Responses.ScopesResponseBody(scopes);
-            return;
+            return CompletableFuture.completedFuture(response);
         }
-        StackFrame stackFrame = stackFrameProxy.getProxiedObject();
-        VariableProxy localScope = new VariableProxy(stackFrame.thread().uniqueID(), "Local", stackFrame);
-        int localScopeId = context.getRecyclableIdPool().addObject(stackFrame.thread().uniqueID(), localScope);
+        ThreadReference thread = stackFrameReference.getThread();
+        VariableProxy localScope = new VariableProxy(thread, "Local", stackFrameReference, null, null);
+        int localScopeId = context.getRecyclableIdPool().addObject(thread.uniqueID(), localScope);
         scopes.add(new Types.Scope(localScope.getScope(), localScopeId, false));
 
         response.body = new Responses.ScopesResponseBody(scopes);
+        return CompletableFuture.completedFuture(response);
     }
-
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetBreakpointsRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetBreakpointsRequestHandler.java
index acc16d24b..0f171486e 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetBreakpointsRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetBreakpointsRequestHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -14,28 +14,55 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Stream;
 
 import org.apache.commons.io.FilenameUtils;
 import org.apache.commons.lang3.StringUtils;
 
+import com.microsoft.java.debug.core.Configuration;
 import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.DebugSettings.Switch;
 import com.microsoft.java.debug.core.IBreakpoint;
+import com.microsoft.java.debug.core.IDebugSession;
+import com.microsoft.java.debug.core.IEvaluatableBreakpoint;
+import com.microsoft.java.debug.core.JavaBreakpointLocation;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
-import com.microsoft.java.debug.core.adapter.BreakpointManager;
 import com.microsoft.java.debug.core.adapter.ErrorCode;
-import com.microsoft.java.debug.core.adapter.Events;
+import com.microsoft.java.debug.core.adapter.HotCodeReplaceEvent.EventType;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.adapter.IHotCodeReplaceProvider;
 import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.SetBreakpointArguments;
-import com.microsoft.java.debug.core.adapter.Responses;
-import com.microsoft.java.debug.core.adapter.Types;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.SetBreakpointArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types;
+import com.sun.jdi.BooleanValue;
+import com.sun.jdi.Field;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.StringReference;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.VMDisconnectedException;
+import com.sun.jdi.Value;
+import com.sun.jdi.event.BreakpointEvent;
+import com.sun.jdi.event.Event;
+import com.sun.jdi.event.StepEvent;
+import com.sun.jdi.request.EventRequest;
 
 public class SetBreakpointsRequestHandler implements IDebugRequestHandler {
-    private BreakpointManager manager = new BreakpointManager();
+
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+
+    private boolean registered = false;
 
     @Override
     public List<Command> getTargetCommands() {
@@ -43,14 +70,84 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public void initialize(IDebugAdapterContext context) {
+        IDebugRequestHandler.super.initialize(context);
+        IHotCodeReplaceProvider provider = context.getProvider(IHotCodeReplaceProvider.class);
+        provider.getEventHub()
+            .filter(event -> event.getEventType() == EventType.END)
+            .subscribe(event -> {
+                try {
+                    List<String> classNames = (List<String>) event.getData();
+                    reinstallBreakpoints(context, classNames);
+                } catch (Exception e) {
+                    logger.severe(e.toString());
+                }
+            });
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
         if (context.getDebugSession() == null) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION, "Empty debug session.");
-            return;
+            return AdapterUtils.createAsyncErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION, "Empty debug session.");
+        }
+
+        if (!registered) {
+            registered = true;
+            registerBreakpointHandler(context);
         }
 
         SetBreakpointArguments bpArguments = (SetBreakpointArguments) arguments;
-        String clientPath = bpArguments.source.path;
+        String sourcePath = normalizeSourcePath(bpArguments.source, context);
+        // When breakpoint source path is null or an invalid file path, send an ErrorResponse back.
+        if (StringUtils.isBlank(sourcePath)) {
+            throw AdapterUtils.createCompletionException(
+                String.format("Failed to setBreakpoint. Reason: '%s' is an invalid path.", bpArguments.source.path),
+                ErrorCode.SET_BREAKPOINT_FAILURE);
+        }
+
+        try {
+            List<Types.Breakpoint> res = new ArrayList<>();
+            IBreakpoint[] toAdds = this.convertClientBreakpointsToDebugger(sourcePath, bpArguments.breakpoints, context);
+            // See the VSCode bug https://github.com/Microsoft/vscode/issues/36471.
+            // The source uri sometimes is encoded by VSCode, the debugger will decode it to keep the uri consistent.
+            IBreakpoint[] added = context.getBreakpointManager()
+                                         .setBreakpoints(AdapterUtils.decodeURIComponent(sourcePath), toAdds, bpArguments.sourceModified);
+            for (int i = 0; i < bpArguments.breakpoints.length; i++) {
+                added[i].setAsync(context.asyncJDWP());
+                // For newly added breakpoint, should install it to debuggee first.
+                if (toAdds[i] == added[i] && added[i].className() != null) {
+                    added[i].install().thenAccept(bp -> {
+                        Events.BreakpointEvent bpEvent = new Events.BreakpointEvent("changed", this.convertDebuggerBreakpointToClient(bp, context));
+                        context.getProtocolServer().sendEvent(bpEvent);
+                    });
+                } else if (added[i].className() != null) {
+                    if (toAdds[i].getHitCount() != added[i].getHitCount()) {
+                        // Update hitCount condition.
+                        added[i].setHitCount(toAdds[i].getHitCount());
+                    }
+
+                    if (!StringUtils.equals(toAdds[i].getLogMessage(), added[i].getLogMessage())) {
+                        added[i].setLogMessage(toAdds[i].getLogMessage());
+                    }
+
+                    if (!StringUtils.equals(toAdds[i].getCondition(), added[i].getCondition())) {
+                        added[i].setCondition(toAdds[i].getCondition());
+                    }
+
+                }
+                res.add(this.convertDebuggerBreakpointToClient(added[i], context));
+            }
+            response.body = new Responses.SetBreakpointsResponseBody(res);
+            return CompletableFuture.completedFuture(response);
+        } catch (DebugException e) {
+            throw AdapterUtils.createCompletionException(
+                String.format("Failed to setBreakpoint. Reason: '%s'", e.toString()),
+                ErrorCode.SET_BREAKPOINT_FAILURE);
+        }
+    }
+
+    public static String normalizeSourcePath(Types.Source source, IDebugAdapterContext context) {
+        String clientPath = source.path;
         if (AdapterUtils.isWindows()) {
             // VSCode may send drive letters with inconsistent casing which will mess up the key
             // in the BreakpointManager. See https://github.com/Microsoft/vscode/issues/6268
@@ -64,69 +161,210 @@ public void handle(Command command, Arguments arguments, Response response, IDeb
             }
         }
         String sourcePath = clientPath;
-        if (bpArguments.source.sourceReference != 0 && context.getSourceUri(bpArguments.source.sourceReference) != null) {
-            sourcePath = context.getSourceUri(bpArguments.source.sourceReference);
-        } else {
-            sourcePath = AdapterUtils.convertPath(clientPath, context.isClientPathsAreUri(), context.isDebuggerPathsAreUri());
+        if (source.sourceReference != 0 && context.getSourceUri(source.sourceReference) != null) {
+            sourcePath = context.getSourceUri(source.sourceReference);
+        } else if (StringUtils.isNotBlank(clientPath)) {
+            // See the bug https://github.com/Microsoft/vscode/issues/30996
+            // Source.path in the SetBreakpointArguments could be a file system path or uri.
+            sourcePath = AdapterUtils.convertPath(clientPath, AdapterUtils.isUri(clientPath), context.isDebuggerPathsAreUri());
         }
 
-        // When breakpoint source path is null or an invalid file path, send an ErrorResponse back.
-        if (sourcePath == null) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.SET_BREAKPOINT_FAILURE,
-                    String.format("Failed to setBreakpoint. Reason: '%s' is an invalid path.", bpArguments.source.path));
-            return;
+        return sourcePath;
+    }
+
+    private IBreakpoint getAssociatedEvaluatableBreakpoint(IDebugAdapterContext context, BreakpointEvent event) {
+        return Arrays.asList(context.getBreakpointManager().getBreakpoints()).stream().filter(
+            bp -> {
+                return bp instanceof IEvaluatableBreakpoint
+                    && ((IEvaluatableBreakpoint) bp).containsEvaluatableExpression()
+                    && bp.requests().contains(event.request());
+            }
+        ).findFirst().orElse(null);
+    }
+
+    private void registerBreakpointHandler(IDebugAdapterContext context) {
+        IDebugSession debugSession = context.getDebugSession();
+        if (debugSession != null) {
+            debugSession.getEventHub().events().filter(debugEvent -> debugEvent.event instanceof BreakpointEvent).subscribe(debugEvent -> {
+                Event event = debugEvent.event;
+                if (debugEvent.eventSet.size() > 1 && debugEvent.eventSet.stream().anyMatch(t -> t instanceof StepEvent)) {
+                    // The StepEvent and BreakpointEvent are grouped in the same event set only if they occurs at the same location and in the same thread.
+                    // In order to avoid two duplicated StoppedEvents, the debugger will skip the BreakpointEvent.
+                } else {
+                    ThreadReference bpThread = ((BreakpointEvent) event).thread();
+                    IEvaluationProvider engine = context.getProvider(IEvaluationProvider.class);
+                    if (engine.isInEvaluation(bpThread)) {
+                        return;
+                    }
+
+                    // find the breakpoint related to this breakpoint event
+                    IBreakpoint expressionBP = getAssociatedEvaluatableBreakpoint(context, (BreakpointEvent) event);
+                    String breakpointName = computeBreakpointName(event.request());
+
+                    if (expressionBP != null) {
+                        CompletableFuture.runAsync(() -> {
+                            engine.evaluateForBreakpoint((IEvaluatableBreakpoint) expressionBP, bpThread).whenComplete((value, ex) -> {
+                                boolean resume = handleEvaluationResult(context, bpThread, (IEvaluatableBreakpoint) expressionBP, value, ex);
+                                // Clear the evaluation environment caused by above evaluation.
+                                engine.clearState(bpThread);
+
+                                if (resume) {
+                                    debugEvent.eventSet.resume();
+                                } else {
+                                    context.getThreadCache().addEventThread(bpThread, breakpointName);
+                                    boolean allThreadsStopped = event.request() != null
+                                            && event.request().suspendPolicy() == EventRequest.SUSPEND_ALL;
+                                    context.getProtocolServer().sendEvent(new Events.StoppedEvent(
+                                            breakpointName, bpThread.uniqueID(), allThreadsStopped));
+                                }
+                            });
+                        });
+                    } else {
+                        context.getThreadCache().addEventThread(bpThread, breakpointName);
+                        boolean allThreadsStopped = event.request() != null
+                                && event.request().suspendPolicy() == EventRequest.SUSPEND_ALL;
+                        context.getProtocolServer().sendEvent(new Events.StoppedEvent(
+                                breakpointName, bpThread.uniqueID(), allThreadsStopped));
+                    }
+                    debugEvent.shouldResume = false;
+                }
+            });
         }
-        try {
-            List<Types.Breakpoint> res = new ArrayList<>();
-            IBreakpoint[] toAdds = this.convertClientBreakpointsToDebugger(sourcePath, bpArguments.breakpoints, context);
-            IBreakpoint[] added = manager.setBreakpoints(sourcePath, toAdds, bpArguments.sourceModified);
-            for (int i = 0; i < bpArguments.breakpoints.length; i++) {
-                // For newly added breakpoint, should install it to debuggee first.
-                if (toAdds[i] == added[i] && added[i].className() != null) {
-                    added[i].install().thenAccept(bp -> {
-                        Events.BreakpointEvent bpEvent = new Events.BreakpointEvent("new", this.convertDebuggerBreakpointToClient(bp, context));
-                        context.sendEventAsync(bpEvent);
-                    });
-                } else if (toAdds[i].hitCount() != added[i].hitCount() && added[i].className() != null) {
-                    // Update hitCount condition.
-                    added[i].setHitCount(toAdds[i].hitCount());
+    }
+
+    private String computeBreakpointName(EventRequest request) {
+        switch ((int) request.getProperty(IBreakpoint.REQUEST_TYPE)) {
+            case IBreakpoint.REQUEST_TYPE_LAMBDA:
+                return "lambda breakpoint";
+            case IBreakpoint.REQUEST_TYPE_METHOD:
+                return "function breakpoint";
+            default:
+                return "breakpoint";
+        }
+    }
+
+    /**
+     * Check whether the condition expression is satisfied, and return a boolean value to determine to resume the thread or not.
+     */
+    public static boolean handleEvaluationResult(IDebugAdapterContext context, ThreadReference bpThread, IEvaluatableBreakpoint breakpoint,
+        Value value, Throwable ex) {
+        if (StringUtils.isNotBlank(breakpoint.getLogMessage())) {
+            if (ex != null) {
+                logger.log(Level.SEVERE, String.format("[Logpoint]: %s", ex.getMessage() != null ? ex.getMessage() : ex.toString()), ex);
+                context.getProtocolServer().sendEvent(new Events.UserNotificationEvent(
+                    Events.UserNotificationEvent.NotificationType.ERROR,
+                    String.format("[Logpoint] Log message '%s' error: %s", breakpoint.getLogMessage(), ex.getMessage())));
+            } else if (value != null) {
+                if (value instanceof StringReference) {
+                    String message = ((StringReference) value).value();
+                    context.getProtocolServer().sendEvent(Events.OutputEvent.createConsoleOutput(
+                        message + System.lineSeparator()));
                 }
-                res.add(this.convertDebuggerBreakpointToClient(added[i], context));
             }
-            response.body = new Responses.SetBreakpointsResponseBody(res);
-        } catch (DebugException e) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.SET_BREAKPOINT_FAILURE, String.format("Failed to setBreakpoint. Reason: '%s'", e.toString()));
+            return true;
+        } else {
+            boolean resume = false;
+            boolean resultNotBoolean = false;
+            if (value != null && ex == null) {
+                if (value instanceof BooleanValue) {
+                    resume = !((BooleanValue) value).booleanValue();
+                } else if (value instanceof ObjectReference
+                        && ((ObjectReference) value).type().name().equals("java.lang.Boolean")) {
+                    // get boolean value from java.lang.Boolean object
+                    Field field = ((ReferenceType) ((ObjectReference) value).type()).fieldByName("value");
+                    resume = !((BooleanValue) ((ObjectReference) value).getValue(field)).booleanValue();
+                } else {
+                    resultNotBoolean = true;
+                }
+            }
+            if (resume) {
+                return true;
+            } else {
+                if (context.isVmTerminated()) {
+                    // do nothing
+                } else if (ex != null) {
+                    if (!(ex instanceof VMDisconnectedException || ex.getCause() instanceof VMDisconnectedException)) {
+                        logger.log(Level.SEVERE, String.format("[ConditionalBreakpoint]: %s", ex.getMessage() != null ? ex.getMessage() : ex.toString()), ex);
+                        context.getProtocolServer().sendEvent(new Events.UserNotificationEvent(
+                                Events.UserNotificationEvent.NotificationType.ERROR,
+                                String.format("Breakpoint condition '%s' error: %s", breakpoint.getCondition(), ex.getMessage())));
+                    }
+                } else if (value == null || resultNotBoolean) {
+                    context.getProtocolServer().sendEvent(new Events.UserNotificationEvent(
+                            Events.UserNotificationEvent.NotificationType.WARNING,
+                            String.format("Result of breakpoint condition '%s' is not a boolean, please correct your expression.", breakpoint.getCondition())));
+                }
+                return false;
+            }
         }
     }
 
     private Types.Breakpoint convertDebuggerBreakpointToClient(IBreakpoint breakpoint, IDebugAdapterContext context) {
         int id = (int) breakpoint.getProperty("id");
         boolean verified = breakpoint.getProperty("verified") != null && (boolean) breakpoint.getProperty("verified");
-        int lineNumber = AdapterUtils.convertLineNumber(breakpoint.lineNumber(), context.isDebuggerLinesStartAt1(), context.isClientLinesStartAt1());
+        int lineNumber = AdapterUtils.convertLineNumber(breakpoint.sourceLocation().lineNumberInSourceFile(),
+                                            context.isDebuggerLinesStartAt1(), context.isClientLinesStartAt1());
         return new Types.Breakpoint(id, verified, lineNumber, "");
     }
 
     private IBreakpoint[] convertClientBreakpointsToDebugger(String sourceFile, Types.SourceBreakpoint[] sourceBreakpoints, IDebugAdapterContext context)
             throws DebugException {
-        int[] lines = Arrays.asList(sourceBreakpoints).stream().map(sourceBreakpoint -> {
-            return AdapterUtils.convertLineNumber(sourceBreakpoint.line, context.isClientLinesStartAt1(), context.isDebuggerLinesStartAt1());
-        }).mapToInt(line -> line).toArray();
+        Types.SourceBreakpoint[] debugSourceBreakpoints = Stream.of(sourceBreakpoints).map(sourceBreakpoint -> {
+            int line = AdapterUtils.convertLineNumber(sourceBreakpoint.line, context.isClientLinesStartAt1(), context.isDebuggerLinesStartAt1());
+            int column = AdapterUtils.convertColumnNumber(sourceBreakpoint.column, context.isClientColumnsStartAt1(), context.isDebuggerColumnsStartAt1());
+            return new Types.SourceBreakpoint(line, column);
+        }).toArray(Types.SourceBreakpoint[]::new);
+
         ISourceLookUpProvider sourceProvider = context.getProvider(ISourceLookUpProvider.class);
-        String[] fqns = sourceProvider.getFullyQualifiedName(sourceFile, lines, null);
-        IBreakpoint[] breakpoints = new IBreakpoint[lines.length];
-        for (int i = 0; i < lines.length; i++) {
+        JavaBreakpointLocation[] locations = sourceProvider.getBreakpointLocations(sourceFile, debugSourceBreakpoints);
+        IBreakpoint[] breakpoints = new IBreakpoint[locations.length];
+        for (int i = 0; i < locations.length; i++) {
             int hitCount = 0;
             try {
                 hitCount = Integer.parseInt(sourceBreakpoints[i].hitCondition);
             } catch (NumberFormatException e) {
                 hitCount = 0; // If hitCount is an illegal number, ignore hitCount condition.
             }
-            breakpoints[i] = context.getDebugSession().createBreakpoint(fqns[i], lines[i], hitCount);
-            if (sourceProvider.supportsRealtimeBreakpointVerification() && StringUtils.isNotBlank(fqns[i])) {
+
+            if (DebugSettings.getCurrent().debugSupportOnDecompiledSource == Switch.ON) {
+                // Align the decompiled line with the original line.
+                int[] lineMappings = sourceProvider.getDecompiledLineMappings(sourceFile);
+                if (locations[i] != null && lineMappings != null) {
+                    int lineNumberInSourceFile = locations[i].lineNumber();
+                    int[] originalLines = AdapterUtils.binarySearchMappedLines(lineMappings, lineNumberInSourceFile);
+                    if (originalLines != null && originalLines.length > 0) {
+                        locations[i].setLineNumberInSourceFile(lineNumberInSourceFile);
+                        locations[i].setLineNumber(originalLines[0]);
+                    }
+                }
+            }
+            breakpoints[i] = context.getDebugSession().createBreakpoint(locations[i], hitCount, sourceBreakpoints[i].condition,
+                sourceBreakpoints[i].logMessage);
+            if (sourceProvider.supportsRealtimeBreakpointVerification() && StringUtils.isNotBlank(locations[i].className())) {
                 breakpoints[i].putProperty("verified", true);
             }
         }
         return breakpoints;
     }
 
+    private void reinstallBreakpoints(IDebugAdapterContext context, List<String> typenames) {
+        if (typenames == null || typenames.isEmpty()) {
+            return;
+        }
+        IBreakpoint[] breakpoints = context.getBreakpointManager().getBreakpoints();
+
+        for (IBreakpoint breakpoint : breakpoints) {
+            if (typenames.contains(breakpoint.className())) {
+                try {
+                    breakpoint.close();
+                    breakpoint.install().thenAccept(bp -> {
+                        Events.BreakpointEvent bpEvent = new Events.BreakpointEvent("new", this.convertDebuggerBreakpointToClient(bp, context));
+                        context.getProtocolServer().sendEvent(bpEvent);
+                    });
+                } catch (Exception e) {
+                    logger.log(Level.SEVERE, String.format("Remove breakpoint exception: %s", e.toString()), e);
+                }
+            }
+        }
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetDataBreakpointsRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetDataBreakpointsRequestHandler.java
new file mode 100644
index 000000000..c7c0995fe
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetDataBreakpointsRequestHandler.java
@@ -0,0 +1,172 @@
+/*******************************************************************************
+* Copyright (c) 2019-2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.microsoft.java.debug.core.IDebugSession;
+import com.microsoft.java.debug.core.IEvaluatableBreakpoint;
+import com.microsoft.java.debug.core.IWatchpoint;
+import com.microsoft.java.debug.core.Watchpoint;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.Events.BreakpointEvent;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.SetDataBreakpointsArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types.Breakpoint;
+import com.microsoft.java.debug.core.protocol.Types.DataBreakpoint;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.event.Event;
+import com.sun.jdi.event.WatchpointEvent;
+import com.sun.jdi.request.EventRequest;
+
+public class SetDataBreakpointsRequestHandler implements IDebugRequestHandler {
+    private boolean registered = false;
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.SETDATABREAKPOINTS);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+        if (context.getDebugSession() == null) {
+            return AdapterUtils.createAsyncErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION, "Empty debug session.");
+        }
+
+        if (!registered) {
+            registered = true;
+            registerWatchpointHandler(context);
+        }
+
+        SetDataBreakpointsArguments dataBpArgs = (SetDataBreakpointsArguments) arguments;
+        IWatchpoint[] requestedWatchpoints = (dataBpArgs.breakpoints == null) ? new Watchpoint[0] : new Watchpoint[dataBpArgs.breakpoints.length];
+        for (int i = 0; i < requestedWatchpoints.length; i++) {
+            DataBreakpoint dataBreakpoint = dataBpArgs.breakpoints[i];
+            if (dataBreakpoint.dataId != null) {
+                String[] segments = dataBreakpoint.dataId.split("#");
+                if (segments.length == 2 && StringUtils.isNotBlank(segments[0]) && StringUtils.isNotBlank(segments[1])) {
+                    int hitCount = 0;
+                    try {
+                        hitCount = Integer.parseInt(dataBreakpoint.hitCondition);
+                    } catch (NumberFormatException e) {
+                        hitCount = 0; // If hitCount is an illegal number, ignore hitCount condition.
+                    }
+
+                    String accessType = dataBreakpoint.accessType != null ? dataBreakpoint.accessType.label() : null;
+                    requestedWatchpoints[i] = context.getDebugSession().createWatchPoint(segments[0], segments[1], accessType,
+                                                dataBreakpoint.condition, hitCount);
+                }
+            }
+        }
+
+        IWatchpoint[] currentWatchpoints = context.getBreakpointManager().setWatchpoints(requestedWatchpoints);
+        List<Breakpoint> breakpoints = new ArrayList<>();
+        for (int i = 0; i < currentWatchpoints.length; i++) {
+            if (currentWatchpoints[i] == null) {
+                breakpoints.add(new Breakpoint(false));
+                continue;
+            }
+
+            // If the requested watchpoint exists in the watchpoint manager, it will reuse the cached watchpoint object.
+            // Otherwise add the requested watchpoint to the cache.
+            // So if the returned watchpoint from the manager is same as the requested wantchpoint, this means it's a new watchpoint, need install it.
+            if (currentWatchpoints[i] == requestedWatchpoints[i]) {
+                currentWatchpoints[i].install().thenAccept(wp -> {
+                    BreakpointEvent bpEvent = new BreakpointEvent("new", convertDebuggerWatchpointToClient(wp));
+                    context.getProtocolServer().sendEvent(bpEvent);
+                });
+            } else {
+                if (currentWatchpoints[i].getHitCount() != requestedWatchpoints[i].getHitCount()) {
+                    currentWatchpoints[i].setHitCount(requestedWatchpoints[i].getHitCount());
+                }
+
+                if (!Objects.equals(currentWatchpoints[i].getCondition(), requestedWatchpoints[i].getCondition())) {
+                    currentWatchpoints[i].setCondition(requestedWatchpoints[i].getCondition());
+                }
+            }
+
+            breakpoints.add(convertDebuggerWatchpointToClient(currentWatchpoints[i]));
+        }
+
+        response.body = new Responses.SetDataBreakpointsResponseBody(breakpoints);
+        return CompletableFuture.completedFuture(response);
+    }
+
+    private Breakpoint convertDebuggerWatchpointToClient(IWatchpoint watchpoint) {
+        return new Breakpoint((int) watchpoint.getProperty("id"),
+            watchpoint.getProperty("verified") != null && (boolean) watchpoint.getProperty("verified"));
+    }
+
+    private void registerWatchpointHandler(IDebugAdapterContext context) {
+        IDebugSession debugSession = context.getDebugSession();
+        if (debugSession != null) {
+            debugSession.getEventHub().events().filter(debugEvent -> debugEvent.event instanceof WatchpointEvent).subscribe(debugEvent -> {
+                Event event = debugEvent.event;
+                ThreadReference bpThread = ((WatchpointEvent) event).thread();
+                IEvaluationProvider engine = context.getProvider(IEvaluationProvider.class);
+                if (engine.isInEvaluation(bpThread)) {
+                    return;
+                }
+
+                // Find the watchpoint related to this watchpoint event
+                IWatchpoint watchpoint = Stream.of(context.getBreakpointManager().getWatchpoints())
+                    .filter(wp -> {
+                        return wp instanceof IEvaluatableBreakpoint
+                            && ((IEvaluatableBreakpoint) wp).containsEvaluatableExpression()
+                            && wp.requests().contains(event.request());
+                    })
+                    .findFirst().orElse(null);
+
+                if (watchpoint != null) {
+                    CompletableFuture.runAsync(() -> {
+                        engine.evaluateForBreakpoint((IEvaluatableBreakpoint) watchpoint, bpThread).whenComplete((value, ex) -> {
+                            boolean resume = SetBreakpointsRequestHandler.handleEvaluationResult(
+                                                context, bpThread, (IEvaluatableBreakpoint) watchpoint, value, ex);
+                            // Clear the evaluation environment caused by above evaluation.
+                            engine.clearState(bpThread);
+
+                            if (resume) {
+                                debugEvent.eventSet.resume();
+                            } else {
+                                context.getThreadCache().addEventThread(bpThread, "data breakpoint");
+                                boolean allThreadsStopped = event.request() != null
+                                        && event.request().suspendPolicy() == EventRequest.SUSPEND_ALL;
+                                context.getProtocolServer().sendEvent(new Events.StoppedEvent("data breakpoint", bpThread.uniqueID(), allThreadsStopped));
+                            }
+                        });
+                    });
+                } else {
+                    context.getThreadCache().addEventThread(bpThread, "data breakpoint");
+                    boolean allThreadsStopped = event.request() != null
+                            && event.request().suspendPolicy() == EventRequest.SUSPEND_ALL;
+                    context.getProtocolServer().sendEvent(new Events.StoppedEvent("data breakpoint", bpThread.uniqueID(), allThreadsStopped));
+                }
+                debugEvent.shouldResume = false;
+            });
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetExceptionBreakpointsRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetExceptionBreakpointsRequestHandler.java
index 5ce0f9012..b51c5fe27 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetExceptionBreakpointsRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetExceptionBreakpointsRequestHandler.java
@@ -13,20 +13,32 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 
 import org.apache.commons.lang3.ArrayUtils;
 
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.IDebugSession;
+import com.microsoft.java.debug.core.DebugSettings.IDebugSettingChangeListener;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
 import com.microsoft.java.debug.core.adapter.ErrorCode;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.SetExceptionBreakpointsArguments;
-import com.microsoft.java.debug.core.adapter.Types;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.ExceptionFilters;
+import com.microsoft.java.debug.core.protocol.Requests.SetExceptionBreakpointsArguments;
+import com.microsoft.java.debug.core.protocol.Types;
+import com.sun.jdi.event.VMDeathEvent;
+import com.sun.jdi.event.VMDisconnectEvent;
 
-public class SetExceptionBreakpointsRequestHandler implements IDebugRequestHandler {
+public class SetExceptionBreakpointsRequestHandler implements IDebugRequestHandler, IDebugSettingChangeListener {
+    private IDebugSession debugSession = null;
+    private boolean isInitialized = false;
+    private boolean notifyCaught = false;
+    private boolean notifyUncaught = false;
+    private boolean asyncJDWP = false;
 
     @Override
     public List<Command> getTargetCommands() {
@@ -34,22 +46,54 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public synchronized CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
         if (context.getDebugSession() == null) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION, "Empty debug session.");
-            return;
+            return AdapterUtils.createAsyncErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION, "Empty debug session.");
+        }
+
+        if (!isInitialized) {
+            isInitialized = true;
+            debugSession = context.getDebugSession();
+            asyncJDWP = context.asyncJDWP();
+            DebugSettings.addDebugSettingChangeListener(this);
+            debugSession.getEventHub().events().subscribe(debugEvent -> {
+                if (debugEvent.event instanceof VMDeathEvent
+                    || debugEvent.event instanceof VMDisconnectEvent) {
+                    DebugSettings.removeDebugSettingChangeListener(this);
+                }
+            });
         }
 
         String[] filters = ((SetExceptionBreakpointsArguments) arguments).filters;
         try {
-            boolean notifyCaught = ArrayUtils.contains(filters, Types.ExceptionBreakpointFilter.CAUGHT_EXCEPTION_FILTER_NAME);
-            boolean notifyUncaught = ArrayUtils.contains(filters, Types.ExceptionBreakpointFilter.UNCAUGHT_EXCEPTION_FILTER_NAME);
-
-            context.getDebugSession().setExceptionBreakpoints(notifyCaught, notifyUncaught);
+            this.notifyCaught = ArrayUtils.contains(filters, Types.ExceptionBreakpointFilter.CAUGHT_EXCEPTION_FILTER_NAME);
+            this.notifyUncaught = ArrayUtils.contains(filters, Types.ExceptionBreakpointFilter.UNCAUGHT_EXCEPTION_FILTER_NAME);
+            setExceptionBreakpoints(context.getDebugSession(), this.notifyCaught, this.notifyUncaught);
+            return CompletableFuture.completedFuture(response);
         } catch (Exception ex) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.SET_EXCEPTIONBREAKPOINT_FAILURE,
-                    String.format("Failed to setExceptionBreakpoints. Reason: '%s'", ex.toString()));
+            throw AdapterUtils.createCompletionException(
+                String.format("Failed to setExceptionBreakpoints. Reason: '%s'", ex.toString()),
+                ErrorCode.SET_EXCEPTIONBREAKPOINT_FAILURE,
+                ex);
         }
     }
 
+    private void setExceptionBreakpoints(IDebugSession debugSession, boolean notifyCaught, boolean notifyUncaught) {
+        ExceptionFilters exceptionFilters = DebugSettings.getCurrent().exceptionFilters;
+        String[] exceptionTypes = (exceptionFilters == null ? null : exceptionFilters.exceptionTypes);
+        String[] classFilters = (exceptionFilters == null ? null : exceptionFilters.allowClasses);
+        String[] classExclusionFilters = (exceptionFilters == null ? null : exceptionFilters.skipClasses);
+        debugSession.setExceptionBreakpoints(notifyCaught, notifyUncaught, exceptionTypes, classFilters, classExclusionFilters, this.asyncJDWP);
+    }
+
+    @Override
+    public synchronized void update(DebugSettings oldSettings, DebugSettings newSettings) {
+        try {
+            if (newSettings != null && newSettings.exceptionFiltersUpdated) {
+                setExceptionBreakpoints(debugSession, notifyCaught, notifyUncaught);
+            }
+        } catch (Exception ex) {
+            DebugSettings.removeDebugSettingChangeListener(this);
+        }
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetFunctionBreakpointsRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetFunctionBreakpointsRequestHandler.java
new file mode 100644
index 000000000..01b5e9619
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetFunctionBreakpointsRequestHandler.java
@@ -0,0 +1,197 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Gayan Perera - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.microsoft.java.debug.core.IDebugSession;
+import com.microsoft.java.debug.core.IEvaluatableBreakpoint;
+import com.microsoft.java.debug.core.IMethodBreakpoint;
+import com.microsoft.java.debug.core.MethodBreakpoint;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.Events.BreakpointEvent;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.SetFunctionBreakpointsArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types.Breakpoint;
+import com.microsoft.java.debug.core.protocol.Types.FunctionBreakpoint;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.event.MethodEntryEvent;
+import com.sun.jdi.request.EventRequest;
+
+public class SetFunctionBreakpointsRequestHandler implements IDebugRequestHandler {
+    private boolean registered = false;
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.SETFUNCTIONBREAKPOINTS);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+        if (context.getDebugSession() == null) {
+            return AdapterUtils.createAsyncErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION,
+                    "Empty debug session.");
+        }
+
+        if (!registered) {
+            registered = true;
+            registerMethodBreakpointHandler(context);
+        }
+
+        SetFunctionBreakpointsArguments funcBpArgs = (SetFunctionBreakpointsArguments) arguments;
+        IMethodBreakpoint[] requestedMethodBreakpoints = (funcBpArgs.breakpoints == null) ? new IMethodBreakpoint[0]
+                : new MethodBreakpoint[funcBpArgs.breakpoints.length];
+        for (int i = 0; i < requestedMethodBreakpoints.length; i++) {
+            FunctionBreakpoint funcBreakpoint = funcBpArgs.breakpoints[i];
+            if (funcBreakpoint.name != null) {
+                String[] segments = funcBreakpoint.name.split("#");
+                if (segments.length == 2 && StringUtils.isNotBlank(segments[0])
+                        && StringUtils.isNotBlank(segments[1])) {
+                    int hitCount = 0;
+                    try {
+                        hitCount = Integer.parseInt(funcBreakpoint.hitCondition);
+                    } catch (NumberFormatException e) {
+                        hitCount = 0; // If hitCount is an illegal number, ignore hitCount condition.
+                    }
+                    requestedMethodBreakpoints[i] = context.getDebugSession().createFunctionBreakpoint(segments[0],
+                            segments[1],
+                            funcBreakpoint.condition, hitCount);
+                }
+            }
+        }
+
+        IMethodBreakpoint[] currentMethodBreakpoints = context.getBreakpointManager()
+                .setMethodBreakpoints(requestedMethodBreakpoints);
+        List<Breakpoint> breakpoints = new ArrayList<>();
+        for (int i = 0; i < currentMethodBreakpoints.length; i++) {
+            if (currentMethodBreakpoints[i] == null) {
+                breakpoints.add(new Breakpoint(false));
+                continue;
+            }
+
+            currentMethodBreakpoints[i].setAsync(context.asyncJDWP());
+            // If the requested method breakpoint exists in the manager, it will reuse
+            // the cached breakpoint exists object.
+            // Otherwise add the requested method breakpoint to the cache.
+            // So if the returned method breakpoint from the manager is same as the
+            // requested method breakpoint, this means it's a new method breakpoint, need
+            // install it.
+            if (currentMethodBreakpoints[i] == requestedMethodBreakpoints[i]) {
+                currentMethodBreakpoints[i].install().thenAccept(wp -> {
+                    BreakpointEvent bpEvent = new BreakpointEvent("changed", convertDebuggerMethodToClient(wp));
+                    context.getProtocolServer().sendEvent(bpEvent);
+                });
+            } else {
+                if (currentMethodBreakpoints[i].getHitCount() != requestedMethodBreakpoints[i].getHitCount()) {
+                    currentMethodBreakpoints[i].setHitCount(requestedMethodBreakpoints[i].getHitCount());
+                }
+
+                if (!Objects.equals(currentMethodBreakpoints[i].getCondition(),
+                        requestedMethodBreakpoints[i].getCondition())) {
+                    currentMethodBreakpoints[i].setCondition(requestedMethodBreakpoints[i].getCondition());
+                }
+            }
+
+            breakpoints.add(convertDebuggerMethodToClient(currentMethodBreakpoints[i]));
+        }
+
+        response.body = new Responses.SetDataBreakpointsResponseBody(breakpoints);
+        return CompletableFuture.completedFuture(response);
+    }
+
+    private Breakpoint convertDebuggerMethodToClient(IMethodBreakpoint methodBreakpoint) {
+        return new Breakpoint((int) methodBreakpoint.getProperty("id"),
+                methodBreakpoint.getProperty("verified") != null && (boolean) methodBreakpoint.getProperty("verified"));
+    }
+
+    private void registerMethodBreakpointHandler(IDebugAdapterContext context) {
+        IDebugSession debugSession = context.getDebugSession();
+        if (debugSession != null) {
+            debugSession.getEventHub().events().filter(debugEvent -> debugEvent.event instanceof MethodEntryEvent)
+                    .subscribe(debugEvent -> {
+                        MethodEntryEvent methodEntryEvent = (MethodEntryEvent) debugEvent.event;
+                        ThreadReference bpThread = methodEntryEvent.thread();
+                        IEvaluationProvider engine = context.getProvider(IEvaluationProvider.class);
+
+                        // Find the method breakpoint related to this method entry event
+                        IMethodBreakpoint methodBreakpoint = Stream
+                                .of(context.getBreakpointManager().getMethodBreakpoints())
+                                .filter(mp -> {
+                                    return mp.requests().contains(methodEntryEvent.request())
+                                            && matches(methodEntryEvent, mp);
+                                })
+                                .findFirst().orElse(null);
+
+                        if (methodBreakpoint != null) {
+                            if (methodBreakpoint instanceof IEvaluatableBreakpoint
+                                    && ((IEvaluatableBreakpoint) methodBreakpoint).containsConditionalExpression()) {
+                                if (engine.isInEvaluation(bpThread)) {
+                                    return;
+                                }
+                                CompletableFuture.runAsync(() -> {
+                                    engine.evaluateForBreakpoint((IEvaluatableBreakpoint) methodBreakpoint, bpThread)
+                                            .whenComplete((value, ex) -> {
+                                                boolean resume = SetBreakpointsRequestHandler.handleEvaluationResult(
+                                                        context, bpThread, (IEvaluatableBreakpoint) methodBreakpoint,
+                                                        value,
+                                                        ex);
+                                                // Clear the evaluation environment caused by above evaluation.
+                                                engine.clearState(bpThread);
+
+                                                if (resume) {
+                                                    debugEvent.eventSet.resume();
+                                                } else {
+                                                    context.getThreadCache().addEventThread(bpThread, "function breakpoint");
+                                                    boolean allThreadsStopped = methodEntryEvent.request() != null
+                                                            && methodEntryEvent.request().suspendPolicy() == EventRequest.SUSPEND_ALL;
+                                                    context.getProtocolServer().sendEvent(new Events.StoppedEvent(
+                                                            "function breakpoint", bpThread.uniqueID(), allThreadsStopped));
+                                                }
+                                            });
+                                });
+
+                            } else {
+                                context.getThreadCache().addEventThread(bpThread, "function breakpoint");
+                                boolean allThreadsStopped = methodEntryEvent.request() != null
+                                        && methodEntryEvent.request().suspendPolicy() == EventRequest.SUSPEND_ALL;
+                                context.getProtocolServer()
+                                        .sendEvent(new Events.StoppedEvent("function breakpoint", bpThread.uniqueID(), allThreadsStopped));
+                            }
+
+                            debugEvent.shouldResume = false;
+                        }
+                    });
+        }
+    }
+
+    private boolean matches(MethodEntryEvent methodEntryEvent, IMethodBreakpoint breakpoint) {
+        return breakpoint.className().equals(methodEntryEvent.location().declaringType().name())
+                && breakpoint.methodName().equals(methodEntryEvent.method().name());
+    }
+
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetVariableRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetVariableRequestHandler.java
index 20565c187..c2d3aa1d2 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetVariableRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SetVariableRequestHandler.java
@@ -14,24 +14,25 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 
 import org.apache.commons.lang3.StringUtils;
 
+import com.microsoft.java.debug.core.DebugSettings;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
 import com.microsoft.java.debug.core.adapter.ErrorCode;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.SetVariableArguments;
-import com.microsoft.java.debug.core.adapter.Responses;
-import com.microsoft.java.debug.core.adapter.formatter.NumericFormatEnum;
-import com.microsoft.java.debug.core.adapter.formatter.NumericFormatter;
-import com.microsoft.java.debug.core.adapter.formatter.SimpleTypeFormatter;
+import com.microsoft.java.debug.core.adapter.variables.IVariableFormatter;
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
 import com.microsoft.java.debug.core.adapter.variables.VariableProxy;
 import com.microsoft.java.debug.core.adapter.variables.VariableUtils;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.SetVariableArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
 import com.sun.jdi.AbsentInformationException;
 import com.sun.jdi.ArrayReference;
 import com.sun.jdi.ArrayType;
@@ -57,45 +58,37 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
         SetVariableArguments setVarArguments = (SetVariableArguments) arguments;
         if (setVarArguments.value == null) {
             // Just exit out of editing if we're given an empty expression.
-            return;
+            return CompletableFuture.completedFuture(response);
         } else if (setVarArguments.variablesReference == -1) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.ARGUMENT_MISSING,
-                    "SetVariablesRequest: property 'variablesReference' is missing, null, or empty");
-            return;
+            throw AdapterUtils.createCompletionException(
+                "SetVariablesRequest: property 'variablesReference' is missing, null, or empty",
+                ErrorCode.ARGUMENT_MISSING);
         } else if (StringUtils.isBlank(setVarArguments.name)) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.ARGUMENT_MISSING,
-                    "SetVariablesRequest: property 'name' is missing, null, or empty");
-            return;
+            throw AdapterUtils.createCompletionException(
+                "SetVariablesRequest: property 'name' is missing, null, or empty",
+                ErrorCode.ARGUMENT_MISSING);
         }
 
         this.context = context;
-        Map<String, Object> options = context.getVariableFormatter().getDefaultOptions();
-        // This should be false by default(currently true for test).
-        // User will need to explicitly turn it on by configuring launch.json
-        boolean showStaticVariables = true;
-        // TODO: when vscode protocol support customize settings of value format, showFullyQualifiedNames should be one of the options.
-        boolean showFullyQualifiedNames = true;
-        if (setVarArguments.format != null && setVarArguments.format.hex) {
-            options.put(NumericFormatter.NUMERIC_FORMAT_OPTION, NumericFormatEnum.HEX);
-        }
-        if (showFullyQualifiedNames) {
-            options.put(SimpleTypeFormatter.QUALIFIED_CLASS_NAME_OPTION, showFullyQualifiedNames);
-        }
+        boolean showStaticVariables = DebugSettings.getCurrent().showStaticVariables;
+        IVariableFormatter variableFormatter = context.getVariableFormatter();
+        Map<String, Object> options = variableFormatter.getDefaultOptions();
+        VariableUtils.applyFormatterOptions(options, setVarArguments.format != null && setVarArguments.format.hex);
 
         Object container = context.getRecyclableIdPool().getObjectById(setVarArguments.variablesReference);
         // container is null means the stack frame is continued by user manually.
         if (container == null) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.SET_VARIABLE_FAILURE,
-                    "Failed to set variable. Reason: Cannot set value because the thread is resumed.");
-            return;
+            throw AdapterUtils.createCompletionException(
+                "Failed to set variable. Reason: Cannot set value because the thread is resumed.",
+                ErrorCode.SET_VARIABLE_FAILURE);
         }
 
         String name = setVarArguments.name;
-        Value newValue;
+        Value newValue = null;
         String belongToClass = null;
 
         if (setVarArguments.name.contains("(")) {
@@ -103,30 +96,32 @@ public void handle(Command command, Arguments arguments, Response response, IDeb
             belongToClass = setVarArguments.name.replaceFirst(PATTERN, "$2");
         }
 
-        Object containerObj = ((VariableProxy) container).getProxiedVariable();
         try {
-            if (containerObj instanceof StackFrame) {
+            Object containerObj = ((VariableProxy) container).getProxiedVariable();
+            if (containerObj instanceof StackFrameReference) {
+                StackFrameReference stackFrameReference = (StackFrameReference) containerObj;
+                StackFrame sf = context.getStackFrameManager().getStackFrame(stackFrameReference);
                 newValue = handleSetValueForStackFrame(name, belongToClass, setVarArguments.value,
-                        showStaticVariables, (StackFrame) containerObj, options);
+                        showStaticVariables, sf, options);
             } else if (containerObj instanceof ObjectReference) {
-                newValue = handleSetValueForObject(name, belongToClass, setVarArguments.value,
-                        (ObjectReference) containerObj, options);
+                newValue = handleSetValueForObject(name, belongToClass, setVarArguments.value, (ObjectReference) containerObj, options);
             } else {
-                AdapterUtils.setErrorResponse(response, ErrorCode.SET_VARIABLE_FAILURE,
-                        String.format("SetVariableRequest: Variable %s cannot be found.", setVarArguments.variablesReference));
-                return;
+                throw AdapterUtils.createCompletionException(
+                    String.format("SetVariableRequest: Variable %s cannot be found.", setVarArguments.variablesReference),
+                    ErrorCode.SET_VARIABLE_FAILURE);
             }
         } catch (IllegalArgumentException | AbsentInformationException | InvalidTypeException
                 | UnsupportedOperationException | ClassNotLoadedException e) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.SET_VARIABLE_FAILURE,
-                    String.format("Failed to set variable. Reason: %s", e.toString()));
-            return;
+            throw AdapterUtils.createCompletionException(
+                String.format("Failed to set variable. Reason: %s", e.toString()),
+                ErrorCode.SET_VARIABLE_FAILURE,
+                e);
         }
         int referenceId = 0;
         if (newValue instanceof ObjectReference && VariableUtils.hasChildren(newValue, showStaticVariables)) {
             long threadId = ((VariableProxy) container).getThreadId();
             String scopeName = ((VariableProxy) container).getScope();
-            VariableProxy varProxy = new VariableProxy(threadId, scopeName, (ObjectReference) newValue);
+            VariableProxy varProxy = new VariableProxy(((VariableProxy) container).getThread(), scopeName, newValue, (VariableProxy) container, name);
             referenceId = context.getRecyclableIdPool().addObject(threadId, varProxy);
         }
 
@@ -138,6 +133,7 @@ public void handle(Command command, Arguments arguments, Response response, IDeb
                 context.getVariableFormatter().typeToString(newValue == null ? null : newValue.type(), options), // type
                 context.getVariableFormatter().valueToString(newValue, options), // value,
                 referenceId, indexedVariables);
+        return CompletableFuture.completedFuture(response);
     }
 
     private Value handleSetValueForObject(String name, String belongToClass, String valueString,
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SourceRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SourceRequestHandler.java
index a242f0582..01ae09055 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SourceRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/SourceRequestHandler.java
@@ -13,17 +13,18 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
 import com.microsoft.java.debug.core.adapter.ErrorCode;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
 import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.SourceArguments;
-import com.microsoft.java.debug.core.adapter.Responses;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.SourceArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
 
 public class SourceRequestHandler implements IDebugRequestHandler {
 
@@ -33,15 +34,16 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
         int sourceReference = ((SourceArguments) arguments).sourceReference;
         if (sourceReference <= 0) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.ARGUMENT_MISSING,
+            return AdapterUtils.createAsyncErrorResponse(response, ErrorCode.ARGUMENT_MISSING,
                     "SourceRequest: property 'sourceReference' is missing, null, or empty");
         } else {
             String uri = context.getSourceUri(sourceReference);
             ISourceLookUpProvider sourceProvider = context.getProvider(ISourceLookUpProvider.class);
             response.body = new Responses.SourceResponseBody(sourceProvider.getSourceContents(uri));
+            return CompletableFuture.completedFuture(response);
         }
     }
 
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/StackTraceRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/StackTraceRequestHandler.java
index 79fb983fe..6f54bcedb 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/StackTraceRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/StackTraceRequestHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -11,34 +11,56 @@
 
 package com.microsoft.java.debug.core.adapter.handler;
 
+import java.io.File;
 import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.stream.Collectors;
 
 import org.apache.commons.lang3.StringUtils;
 
+import com.google.gson.JsonObject;
+import com.microsoft.java.debug.core.AsyncJdwpUtils;
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.DebugSettings.Switch;
 import com.microsoft.java.debug.core.DebugUtility;
+import com.microsoft.java.debug.core.IBreakpoint;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
 import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.StackTraceArguments;
-import com.microsoft.java.debug.core.adapter.Responses;
-import com.microsoft.java.debug.core.adapter.Types;
-import com.microsoft.java.debug.core.adapter.variables.JdiObjectProxy;
+import com.microsoft.java.debug.core.adapter.Source;
+import com.microsoft.java.debug.core.adapter.SourceType;
+import com.microsoft.java.debug.core.adapter.formatter.SimpleTypeFormatter;
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
+import com.microsoft.java.debug.core.protocol.Events.TelemetryEvent;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.StackTraceArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types;
 import com.sun.jdi.AbsentInformationException;
 import com.sun.jdi.IncompatibleThreadStateException;
+import com.sun.jdi.LocalVariable;
 import com.sun.jdi.Location;
 import com.sun.jdi.Method;
 import com.sun.jdi.ObjectCollectedException;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ReferenceType;
 import com.sun.jdi.StackFrame;
 import com.sun.jdi.ThreadReference;
+import com.sun.jdi.request.BreakpointRequest;
 
 public class StackTraceRequestHandler implements IDebugRequestHandler {
+    private ThreadLocal<Boolean> isDecompilerInvoked = new ThreadLocal<>();
 
     @Override
     public List<Command> getTargetCommands() {
@@ -46,98 +68,278 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+        final long startAt = System.currentTimeMillis();
+        isDecompilerInvoked.set(false);
         StackTraceArguments stacktraceArgs = (StackTraceArguments) arguments;
         List<Types.StackFrame> result = new ArrayList<>();
         if (stacktraceArgs.startFrame < 0 || stacktraceArgs.levels < 0) {
             response.body = new Responses.StackTraceResponseBody(result, 0);
-            return;
+            return CompletableFuture.completedFuture(response);
+        }
+        long threadId = stacktraceArgs.threadId;
+        ThreadReference thread = context.getThreadCache().getThread(threadId);
+        if (thread == null) {
+            thread = DebugUtility.getThread(context.getDebugSession(), threadId);
         }
-        ThreadReference thread = DebugUtility.getThread(context.getDebugSession(), stacktraceArgs.threadId);
         int totalFrames = 0;
         if (thread != null) {
+            Set<String> decompiledClasses = new LinkedHashSet<>();
             try {
+                // Thread state has changed and then invalidate the stack frame cache.
+                if (stacktraceArgs.startFrame == 0) {
+                    context.getStackFrameManager().clearStackFrames(thread);
+                } else {
+                    Set<String> existing = context.getThreadCache().getDecompiledClassesByThread(threadId);
+                    if (existing != null) {
+                        decompiledClasses.addAll(existing);
+                    }
+                }
+
                 totalFrames = thread.frameCount();
+                int count = stacktraceArgs.levels == 0 ? totalFrames - stacktraceArgs.startFrame
+                        : Math.min(totalFrames - stacktraceArgs.startFrame, stacktraceArgs.levels);
                 if (totalFrames <= stacktraceArgs.startFrame) {
                     response.body = new Responses.StackTraceResponseBody(result, totalFrames);
-                    return;
+                    return CompletableFuture.completedFuture(response);
                 }
-                List<StackFrame> stackFrames = stacktraceArgs.levels == 0
-                        ? thread.frames(stacktraceArgs.startFrame, totalFrames - stacktraceArgs.startFrame)
-                        : thread.frames(stacktraceArgs.startFrame,
-                        Math.min(totalFrames - stacktraceArgs.startFrame, stacktraceArgs.levels));
-                for (int i = 0; i < stackFrames.size(); i++) {
-                    StackFrame stackFrame = stackFrames.get(i);
-                    int frameId = context.getRecyclableIdPool().addObject(stackFrame.thread().uniqueID(),
-                            new JdiObjectProxy<>(stackFrame));
-                    Types.StackFrame clientStackFrame = convertDebuggerStackFrameToClient(stackFrame, frameId, context);
-                    result.add(clientStackFrame);
+
+                StackFrame[] frames = context.getStackFrameManager().reloadStackFrames(thread, stacktraceArgs.startFrame, count);
+                List<StackFrameInfo> jdiFrames = resolveStackFrameInfos(frames, context.asyncJDWP());
+                for (int i = 0; i < count; i++) {
+                    StackFrameReference frameReference = new StackFrameReference(thread, stacktraceArgs.startFrame + i);
+                    int frameId = context.getRecyclableIdPool().addObject(stacktraceArgs.threadId, frameReference);
+                    StackFrameInfo jdiFrame = jdiFrames.get(i);
+                    Types.StackFrame lspFrame = convertDebuggerStackFrameToClient(jdiFrame, frameId, i == 0, context);
+                    result.add(lspFrame);
+                    frameReference.setSource(lspFrame.source);
+                    int jdiLineNumber = AdapterUtils.convertLineNumber(jdiFrame.lineNumber, context.isDebuggerLinesStartAt1(), context.isClientLinesStartAt1());
+                    if (jdiLineNumber != lspFrame.line && lspFrame.source != null && lspFrame.source.path != null) {
+                        decompiledClasses.add(lspFrame.source.path);
+                    }
                 }
             } catch (IncompatibleThreadStateException | IndexOutOfBoundsException | URISyntaxException
-                    | AbsentInformationException | ObjectCollectedException e) {
+                    | AbsentInformationException | ObjectCollectedException
+                    | CancellationException | CompletionException e) {
                 // when error happens, the possible reason is:
                 // 1. the vscode has wrong parameter/wrong uri
                 // 2. the thread actually terminates
-
                 // TODO: should record a error log here.
+            } finally {
+                context.getThreadCache().setDecompiledClassesByThread(threadId, decompiledClasses);
             }
         }
         response.body = new Responses.StackTraceResponseBody(result, totalFrames);
+        long duration = System.currentTimeMillis() - startAt;
+        JsonObject properties = new JsonObject();
+        properties.addProperty("command", "stackTrace");
+        properties.addProperty("duration", duration);
+        properties.addProperty("decompileSupport", DebugSettings.getCurrent().debugSupportOnDecompiledSource.toString());
+        if (isDecompilerInvoked.get() != null) {
+            properties.addProperty("isDecompilerInvoked", Boolean.toString(isDecompilerInvoked.get()));
+        }
+        context.getProtocolServer().sendEvent(new TelemetryEvent("dap", properties));
+        return CompletableFuture.completedFuture(response);
     }
 
-    private Types.StackFrame convertDebuggerStackFrameToClient(StackFrame stackFrame, int frameId, IDebugAdapterContext context)
-            throws URISyntaxException, AbsentInformationException {
-        Location location = stackFrame.location();
-        Method method = location.method();
-        Types.Source clientSource = this.convertDebuggerSourceToClient(location, context);
-        String methodName = method.name();
-        int lineNumber = AdapterUtils.convertLineNumber(location.lineNumber(), context.isDebuggerLinesStartAt1(), context.isClientLinesStartAt1());
-        if (lineNumber < 0 && method.isNative()) {
-            // When the current stack frame stops at a native method, the line number is -1.
-            // Display a tip text "native method" in the Call Stack View.
-            methodName += "[native method]";
+    private static List<StackFrameInfo> resolveStackFrameInfos(StackFrame[] frames, boolean async)
+            throws AbsentInformationException, IncompatibleThreadStateException {
+        List<StackFrameInfo> jdiFrames = new ArrayList<>();
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        for (StackFrame frame : frames) {
+            StackFrameInfo jdiFrame = new StackFrameInfo(frame);
+            jdiFrame.location = jdiFrame.frame.location();
+            jdiFrame.method = jdiFrame.location.method();
+            jdiFrame.methodName = jdiFrame.method.name();
+            jdiFrame.isNative = jdiFrame.method.isNative();
+            jdiFrame.declaringType = jdiFrame.location.declaringType();
+            if (async) {
+                // JDWP Command: M_LINE_TABLE
+                futures.add(AsyncJdwpUtils.runAsync(() -> {
+                    jdiFrame.lineNumber = jdiFrame.location.lineNumber();
+                }));
+
+                // JDWP Commands: RT_SOURCE_DEBUG_EXTENSION, RT_SOURCE_FILE
+                futures.add(AsyncJdwpUtils.runAsync(() -> {
+                    try {
+                        // When the .class file doesn't contain source information in meta data,
+                        // invoking Location#sourceName() would throw AbsentInformationException.
+                        jdiFrame.sourceName = jdiFrame.declaringType.sourceName();
+                    } catch (AbsentInformationException e) {
+                        jdiFrame.sourceName = null;
+                    }
+                }));
+
+                // JDWP Command: RT_SIGNATURE
+                futures.add(AsyncJdwpUtils.runAsync(() -> {
+                    jdiFrame.typeSignature = jdiFrame.declaringType.signature();
+                }));
+            } else {
+                jdiFrame.lineNumber = jdiFrame.location.lineNumber();
+                jdiFrame.typeSignature = jdiFrame.declaringType.signature();
+                try {
+                    // When the .class file doesn't contain source information in meta data,
+                    // invoking Location#sourceName() would throw AbsentInformationException.
+                    jdiFrame.sourceName = jdiFrame.declaringType.sourceName();
+                } catch (AbsentInformationException e) {
+                    jdiFrame.sourceName = null;
+                }
+            }
+
+            jdiFrames.add(jdiFrame);
+        }
+
+        AsyncJdwpUtils.await(futures);
+        for (StackFrameInfo jdiFrame : jdiFrames) {
+            jdiFrame.typeName = jdiFrame.declaringType.name();
+            jdiFrame.argumentTypeNames = jdiFrame.method.argumentTypeNames();
+            if (jdiFrame.sourceName == null) {
+                String enclosingType = AdapterUtils.parseEnclosingType(jdiFrame.typeName);
+                jdiFrame.sourceName = enclosingType.substring(enclosingType.lastIndexOf('.') + 1) + ".java";
+                jdiFrame.sourcePath = enclosingType.replace('.', File.separatorChar) + ".java";
+            } else {
+                jdiFrame.sourcePath = jdiFrame.declaringType.sourcePaths(null).get(0);
+            }
         }
-        return new Types.StackFrame(frameId, methodName, clientSource, lineNumber, 0);
+
+        return jdiFrames;
     }
 
-    private Types.Source convertDebuggerSourceToClient(Location location, IDebugAdapterContext context) throws URISyntaxException {
-        final String fullyQualifiedName = location.declaringType().name();
-        String sourceName = "";
-        String relativeSourcePath = "";
-        try {
-            // When the .class file doesn't contain source information in meta data,
-            // invoking Location#sourceName() would throw AbsentInformationException.
-            sourceName = location.sourceName();
-            relativeSourcePath = location.sourcePath();
-        } catch (AbsentInformationException e) {
-            String enclosingType = AdapterUtils.parseEnclosingType(fullyQualifiedName);
-            sourceName = enclosingType.substring(enclosingType.lastIndexOf('.') + 1) + ".java";
-            relativeSourcePath = enclosingType.replace('.', '/') + ".java";
+    private Types.StackFrame convertDebuggerStackFrameToClient(StackFrameInfo jdiFrame, int frameId, boolean isTopFrame, IDebugAdapterContext context)
+            throws URISyntaxException, AbsentInformationException {
+        Types.Source clientSource = convertDebuggerSourceToClient(jdiFrame.typeName, jdiFrame.sourceName, jdiFrame.sourcePath, context);
+        String methodName = formatMethodName(jdiFrame.methodName, jdiFrame.argumentTypeNames, jdiFrame.typeName, true, true);
+        int clientLineNumber = AdapterUtils.convertLineNumber(jdiFrame.lineNumber, context.isDebuggerLinesStartAt1(), context.isClientLinesStartAt1());
+        // Line number returns -1 if the information is not available; specifically, always returns -1 for native methods.
+        String presentationHint = null;
+        if (clientLineNumber < 0) {
+            presentationHint = "subtle";
+            if (jdiFrame.isNative) {
+                // For native method, display a tip text "native method" in the Call Stack View.
+                methodName += "[native method]";
+            } else {
+                // For other unavailable method, such as lambda expression's built-in methods run/accept/apply,
+                // display "Unknown Source" in the Call Stack View.
+                clientSource = null;
+            }
+            // DAP specifies lineNumber to be set to 0 when unavailable
+            clientLineNumber = 0;
+        } else if (DebugSettings.getCurrent().debugSupportOnDecompiledSource == Switch.ON
+                && clientSource != null && clientSource.path != null) {
+            // Align the original line with the decompiled line.
+            int[] lineMappings = context.getProvider(ISourceLookUpProvider.class).getOriginalLineMappings(clientSource.path);
+            int[] renderLines = AdapterUtils.binarySearchMappedLines(lineMappings, clientLineNumber);
+            if (renderLines != null && renderLines.length > 0) {
+                clientLineNumber = renderLines[0];
+                isDecompilerInvoked.set(true);
+            }
+        }
+
+        int clientColumnNumber = context.isClientColumnsStartAt1() ? 1 : 0;
+        // If the top-level frame is a lambda method, it might be paused on a lambda breakpoint.
+        // We can associate its column number with the target lambda breakpoint.
+        if (isTopFrame && jdiFrame.methodName.startsWith("lambda$")) {
+            for (IBreakpoint breakpoint : context.getBreakpointManager().getBreakpoints()) {
+                if (breakpoint.getColumnNumber() > 0 && breakpoint.getLineNumber() == jdiFrame.lineNumber
+                        && Objects.equals(jdiFrame.typeName, breakpoint.className())) {
+                    boolean match = breakpoint.requests().stream().anyMatch(request -> {
+                        return request instanceof BreakpointRequest
+                                && Objects.equals(((BreakpointRequest) request).location(), jdiFrame.location);
+                    });
+                    if (match) {
+                        clientColumnNumber = AdapterUtils.convertColumnNumber(breakpoint.getColumnNumber(),
+                                context.isDebuggerColumnsStartAt1(), context.isClientColumnsStartAt1());
+                    }
+                }
+            }
         }
 
-        final String finalRelativeSourcePath = relativeSourcePath;
+        return new Types.StackFrame(frameId, methodName, clientSource, clientLineNumber, clientColumnNumber, presentationHint);
+    }
+
+    /**
+     * Find the source mapping for the specified source file name.
+     */
+    public static Types.Source convertDebuggerSourceToClient(String fullyQualifiedName, String sourceName,
+            String relativeSourcePath,
+            IDebugAdapterContext context) throws URISyntaxException {
+
         // use a lru cache for better performance
-        String uri = context.getSourceLookupCache().computeIfAbsent(fullyQualifiedName, key -> {
-            String fromProvider = context.getProvider(ISourceLookUpProvider.class).getSourceFileURI(key, finalRelativeSourcePath);
-            // avoid return null which will cause the compute function executed again
-            return StringUtils.isBlank(fromProvider) ? "" : fromProvider;
+        Source source = context.getSourceLookupCache().computeIfAbsent(fullyQualifiedName, key -> {
+            Source result = context.getProvider(ISourceLookUpProvider.class).getSource(key, relativeSourcePath);
+            if (result == null) {
+                return new Source("", SourceType.LOCAL);
+            }
+            return result;
         });
 
+        Integer sourceReference = 0;
+        String uri = source.getUri();
+
+        if (source.getType().equals(SourceType.REMOTE)) {
+            sourceReference = context.createSourceReference(source.getUri());
+        }
+
         if (!StringUtils.isBlank(uri)) {
-            String clientPath = AdapterUtils.convertPath(uri, context.isDebuggerPathsAreUri(), context.isClientPathsAreUri());
+            // The Source.path could be a file system path or uri string.
             if (uri.startsWith("file:")) {
-                return new Types.Source(sourceName, clientPath, 0);
+                String clientPath = AdapterUtils.convertPath(uri, context.isDebuggerPathsAreUri(), context.isClientPathsAreUri());
+                return new Types.Source(sourceName, clientPath, sourceReference);
             } else {
-                return new Types.Source(sourceName, clientPath, context.createSourceReference(uri));
+                // If the debugger returns uri in the Source.path for the StackTrace response, VSCode client will try to find a TextDocumentContentProvider
+                // to render the contents.
+                // Language Support for Java by Red Hat extension has already registered a jdt TextDocumentContentProvider to parse the jdt-based uri.
+                // The jdt uri looks like 'jdt://contents/rt.jar/java.io/PrintStream.class?=1.helloworld/%5C/usr%5C/lib%5C/jvm%5C/java-8-oracle%5C/jre%5C/
+                // lib%5C/rt.jar%3Cjava.io(PrintStream.class'.
+                return new Types.Source(sourceName, uri, sourceReference);
             }
         } else {
             // If the source lookup engine cannot find the source file, then lookup it in the source directories specified by user.
             String absoluteSourcepath = AdapterUtils.sourceLookup(context.getSourcePaths(), relativeSourcePath);
             if (absoluteSourcepath != null) {
-                return new Types.Source(sourceName, absoluteSourcepath, 0);
+                return new Types.Source(sourceName, absoluteSourcepath, sourceReference);
             } else {
                 return null;
             }
         }
     }
+
+    private String formatMethodName(String methodName, List<String> argumentTypeNames, String fqn, boolean showContextClass, boolean showParameter) {
+        StringBuilder formattedName = new StringBuilder();
+        if (showContextClass) {
+            formattedName.append(SimpleTypeFormatter.trimTypeName(fqn));
+            formattedName.append(".");
+        }
+        formattedName.append(methodName);
+        if (showParameter) {
+            argumentTypeNames = argumentTypeNames.stream().map(SimpleTypeFormatter::trimTypeName).collect(Collectors.toList());
+            formattedName.append("(");
+            formattedName.append(String.join(",", argumentTypeNames));
+            formattedName.append(")");
+        }
+        return formattedName.toString();
+    }
+
+    static class StackFrameInfo {
+        public StackFrame frame;
+        public Location location;
+        public Method method;
+        public String methodName;
+        public List<String> argumentTypeNames = new ArrayList<>();
+        public boolean isNative = false;
+        public int lineNumber;
+        public ReferenceType declaringType = null;
+        public String typeName;
+        public String typeSignature;
+        public String sourceName = "";
+        public String sourcePath = "";
+
+        // variables
+        public List<LocalVariable> visibleVariables = null;
+        public ObjectReference thisObject;
+
+        public StackFrameInfo(StackFrame frame) {
+            this.frame = frame;
+        }
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/StepInTargetsRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/StepInTargetsRequestHandler.java
new file mode 100644
index 000000000..5b3b735fe
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/StepInTargetsRequestHandler.java
@@ -0,0 +1,138 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Gayan Perera - initial API and implementation
+*******************************************************************************/
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.io.File;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
+import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider.MethodInvocation;
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.StepInTargetsArguments;
+import com.microsoft.java.debug.core.protocol.Responses.StepInTargetsResponse;
+import com.microsoft.java.debug.core.protocol.Types.Source;
+import com.microsoft.java.debug.core.protocol.Types.StepInTarget;
+import com.sun.jdi.AbsentInformationException;
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.StackFrame;
+
+public class StepInTargetsRequestHandler implements IDebugRequestHandler {
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.STEPIN_TARGETS);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+        final StepInTargetsArguments stepInTargetsArguments = (StepInTargetsArguments) arguments;
+
+        final int frameId = stepInTargetsArguments.frameId;
+        return CompletableFuture.supplyAsync(() -> {
+            response.body = new StepInTargetsResponse(
+                    findFrame(frameId, context).map(f -> findTargets(f, context))
+                            .orElse(Collections.emptyList()).toArray(StepInTarget[]::new));
+            return response;
+        });
+    }
+
+    private Optional<StackFrameReference> findFrame(int frameId, IDebugAdapterContext context) {
+        Object object = context.getRecyclableIdPool().getObjectById(frameId);
+        if (object instanceof StackFrameReference) {
+            return Optional.of((StackFrameReference) object);
+        }
+        return Optional.empty();
+    }
+
+    private List<StepInTarget> findTargets(StackFrameReference frameReference, IDebugAdapterContext context) {
+        StackFrame stackframe = context.getStackFrameManager().getStackFrame(frameReference);
+        if (stackframe == null) {
+            return Collections.emptyList();
+        }
+
+        Source source = frameReference.getSource() == null ? findSource(stackframe, context) : frameReference.getSource();
+        if (source == null) {
+            return Collections.emptyList();
+        }
+
+        String sourceUri = AdapterUtils.convertPath(source.path, AdapterUtils.isUri(source.path), true);
+        if (sourceUri == null) {
+            return Collections.emptyList();
+        }
+
+        ISourceLookUpProvider sourceLookUpProvider = context.getProvider(ISourceLookUpProvider.class);
+        List<MethodInvocation> invocations = sourceLookUpProvider.findMethodInvocations(sourceUri, stackframe.location().lineNumber());
+        if (invocations.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        long threadId = stackframe.thread().uniqueID();
+        List<StepInTarget> targets = new ArrayList<>(invocations.size());
+        for (MethodInvocation methodInvocation : invocations) {
+            int id = context.getRecyclableIdPool().addObject(threadId, methodInvocation);
+            StepInTarget target = new StepInTarget(id, methodInvocation.expression);
+            target.column = AdapterUtils.convertColumnNumber(methodInvocation.columnStart,
+                context.isDebuggerColumnsStartAt1(), context.isClientColumnsStartAt1());
+            target.endColumn = AdapterUtils.convertColumnNumber(methodInvocation.columnEnd,
+                context.isDebuggerColumnsStartAt1(), context.isClientColumnsStartAt1());
+            target.line = AdapterUtils.convertLineNumber(methodInvocation.lineStart,
+                context.isDebuggerLinesStartAt1(), context.isClientLinesStartAt1());
+            target.endLine = AdapterUtils.convertLineNumber(methodInvocation.lineEnd,
+                context.isDebuggerLinesStartAt1(), context.isClientLinesStartAt1());
+            targets.add(target);
+        }
+
+        // TODO remove the executed method calls.
+        return targets;
+    }
+
+    private Source findSource(StackFrame frame, IDebugAdapterContext context) {
+        ReferenceType declaringType = frame.location().declaringType();
+        String typeName = declaringType.name();
+        String sourceName = null;
+        String sourcePath = null;
+        try {
+            // When the .class file doesn't contain source information in meta data,
+            // invoking ReferenceType#sourceName() would throw AbsentInformationException.
+            sourceName = declaringType.sourceName();
+            sourcePath = declaringType.sourcePaths(null).get(0);
+        } catch (AbsentInformationException e) {
+            String enclosingType = AdapterUtils.parseEnclosingType(typeName);
+            sourceName = enclosingType.substring(enclosingType.lastIndexOf('.') + 1) + ".java";
+            sourcePath = enclosingType.replace('.', File.separatorChar) + ".java";
+        }
+
+        try {
+            return StackTraceRequestHandler.convertDebuggerSourceToClient(typeName, sourceName, sourcePath, context);
+        } catch (URISyntaxException e) {
+            logger.log(Level.SEVERE, "Failed to resolve the source info of the stack frame.", e);
+        }
+
+        return  null;
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/StepRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/StepRequestHandler.java
new file mode 100644
index 000000000..e8f782668
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/StepRequestHandler.java
@@ -0,0 +1,493 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import com.microsoft.java.debug.core.AsyncJdwpUtils;
+import com.microsoft.java.debug.core.DebugEvent;
+import com.microsoft.java.debug.core.DebugUtility;
+import com.microsoft.java.debug.core.IDebugSession;
+import com.microsoft.java.debug.core.JdiExceptionReference;
+import com.microsoft.java.debug.core.JdiMethodResult;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
+import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider.MethodInvocation;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.StepArguments;
+import com.microsoft.java.debug.core.protocol.Requests.StepFilters;
+import com.microsoft.java.debug.core.protocol.Requests.StepInArguments;
+import com.sun.jdi.ClassType;
+import com.sun.jdi.IncompatibleThreadStateException;
+import com.sun.jdi.InterfaceType;
+import com.sun.jdi.Location;
+import com.sun.jdi.Method;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.StackFrame;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.Value;
+import com.sun.jdi.VoidValue;
+import com.sun.jdi.event.BreakpointEvent;
+import com.sun.jdi.event.Event;
+import com.sun.jdi.event.ExceptionEvent;
+import com.sun.jdi.event.LocatableEvent;
+import com.sun.jdi.event.MethodExitEvent;
+import com.sun.jdi.event.StepEvent;
+import com.sun.jdi.request.EventRequest;
+import com.sun.jdi.request.EventRequestManager;
+import com.sun.jdi.request.MethodExitRequest;
+import com.sun.jdi.request.StepRequest;
+
+import io.reactivex.disposables.Disposable;
+
+public class StepRequestHandler implements IDebugRequestHandler {
+
+    @Override
+    public List<Command> getTargetCommands() {
+        return Arrays.asList(Command.STEPIN, Command.STEPOUT, Command.NEXT);
+    }
+
+    @Override
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
+        if (context.getDebugSession() == null) {
+            return AdapterUtils.createAsyncErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION, "Debug Session doesn't exist.");
+        }
+
+        StepArguments stepArguments = (StepArguments) arguments;
+        long threadId = stepArguments.threadId;
+        int targetId = (stepArguments instanceof StepInArguments) ? ((StepInArguments) stepArguments).targetId : 0;
+        ThreadReference thread = context.getThreadCache().getThread(threadId);
+        if (thread == null) {
+            thread = DebugUtility.getThread(context.getDebugSession(), threadId);
+        }
+        if (thread != null) {
+            JdiExceptionReference exception = context.getExceptionManager().removeException(threadId);
+            context.getStepResultManager().removeMethodResult(threadId);
+            try {
+                final ThreadReference targetThread = thread;
+                ThreadState threadState = new ThreadState();
+                threadState.threadId = threadId;
+                threadState.pendingStepType = command;
+                threadState.eventSubscription = context.getDebugSession().getEventHub().events()
+                    .filter(debugEvent -> (debugEvent.event instanceof StepEvent && debugEvent.event.request().equals(threadState.pendingStepRequest))
+                        || (debugEvent.event instanceof MethodExitEvent && debugEvent.event.request().equals(threadState.pendingMethodExitRequest))
+                        || debugEvent.event instanceof BreakpointEvent
+                        || debugEvent.event instanceof ExceptionEvent)
+                    .subscribe(debugEvent -> {
+                        handleDebugEvent(debugEvent, context.getDebugSession(), context, threadState);
+                    });
+
+                if (command == Command.STEPIN) {
+                    threadState.pendingStepRequest = DebugUtility.createStepIntoRequest(thread,
+                        context.getStepFilters().allowClasses,
+                        context.getStepFilters().skipClasses);
+                } else if (command == Command.STEPOUT) {
+                    threadState.pendingStepRequest = DebugUtility.createStepOutRequest(thread,
+                        context.getStepFilters().allowClasses,
+                        context.getStepFilters().skipClasses);
+                } else {
+                    threadState.pendingStepRequest = DebugUtility.createStepOverRequest(thread, null);
+                }
+
+                threadState.pendingMethodExitRequest = thread.virtualMachine().eventRequestManager().createMethodExitRequest();
+                threadState.pendingMethodExitRequest.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
+
+                threadState.targetStepIn = targetId > 0
+                    ? (MethodInvocation) context.getRecyclableIdPool().getObjectById(targetId) : null;
+                if (context.asyncJDWP()) {
+                    List<CompletableFuture<Void>> futures = new ArrayList<>();
+                    futures.add(AsyncJdwpUtils.runAsync(() -> {
+                        // JDWP Command: TR_FRAMES
+                        try {
+                            threadState.topFrame = getTopFrame(targetThread);
+                            threadState.stepLocation = threadState.topFrame.location();
+                            threadState.pendingMethodExitRequest.addClassFilter(threadState.stepLocation.declaringType());
+                            if (targetThread.virtualMachine().canUseInstanceFilters()) {
+                                try {
+                                    // JDWP Command: SF_THIS_OBJECT
+                                    ObjectReference thisObject = threadState.topFrame.thisObject();
+                                    if (thisObject != null) {
+                                        threadState.pendingMethodExitRequest.addInstanceFilter(thisObject);
+                                    }
+                                } catch (Exception e) {
+                                    // ignore
+                                }
+                            }
+                        } catch (IncompatibleThreadStateException e1) {
+                            throw new CompletionException(e1);
+                        }
+                    }));
+                    futures.add(AsyncJdwpUtils.runAsync(
+                        // JDWP Command: OR_IS_COLLECTED
+                        () -> threadState.pendingMethodExitRequest.addThreadFilter(targetThread)
+                    ));
+                    futures.add(AsyncJdwpUtils.runAsync(() -> {
+                        try {
+                            // JDWP Command: TR_FRAME_COUNT
+                            threadState.stackDepth = targetThread.frameCount();
+                        } catch (IncompatibleThreadStateException e) {
+                            throw new CompletionException(e);
+                        }
+                    }));
+                    futures.add(
+                        // JDWP Command: ER_SET
+                        AsyncJdwpUtils.runAsync(() -> threadState.pendingStepRequest.enable())
+                    );
+
+                    try {
+                        AsyncJdwpUtils.await(futures);
+                    } catch (CompletionException ex) {
+                        if (ex.getCause() instanceof IncompatibleThreadStateException) {
+                            throw (IncompatibleThreadStateException) ex.getCause();
+                        }
+                        throw ex;
+                    }
+
+                    // JDWP Command: ER_SET
+                    threadState.pendingMethodExitRequest.enable();
+                } else {
+                    threadState.topFrame = getTopFrame(targetThread);
+                    threadState.stackDepth = targetThread.frameCount();
+                    threadState.stepLocation = threadState.topFrame.location();
+                    threadState.pendingMethodExitRequest.addThreadFilter(thread);
+                    threadState.pendingMethodExitRequest.addClassFilter(threadState.stepLocation.declaringType());
+                    if (targetThread.virtualMachine().canUseInstanceFilters()) {
+                        try {
+                            ObjectReference thisObject = threadState.topFrame.thisObject();
+                            if (thisObject != null) {
+                                threadState.pendingMethodExitRequest.addInstanceFilter(thisObject);
+                            }
+                        } catch (Exception e) {
+                            // ignore
+                        }
+                    }
+                    threadState.pendingStepRequest.enable();
+                    threadState.pendingMethodExitRequest.enable();
+                }
+
+                context.getThreadCache().removeEventThread(thread.uniqueID());
+                DebugUtility.resumeThread(thread);
+                ThreadsRequestHandler.checkThreadRunningAndRecycleIds(thread, context);
+            } catch (IncompatibleThreadStateException ex) {
+                // Roll back the Exception info if stepping fails.
+                context.getExceptionManager().setException(threadId, exception);
+                final String failureMessage = String.format("Failed to step because the thread '%s' is not suspended in the target VM.", thread.name());
+                throw AdapterUtils.createCompletionException(
+                    failureMessage,
+                    ErrorCode.STEP_FAILURE,
+                    ex);
+            } catch (IndexOutOfBoundsException ex) {
+                // Roll back the Exception info if stepping fails.
+                context.getExceptionManager().setException(threadId, exception);
+                final String failureMessage = String.format("Failed to step because the thread '%s' doesn't contain any stack frame", thread.name());
+                throw AdapterUtils.createCompletionException(
+                    failureMessage,
+                    ErrorCode.STEP_FAILURE,
+                    ex);
+            } catch (Exception ex) {
+                // Roll back the Exception info if stepping fails.
+                context.getExceptionManager().setException(threadId, exception);
+                final String failureMessage = String.format("Failed to step because of the error '%s'", ex.getMessage());
+                throw AdapterUtils.createCompletionException(
+                    failureMessage,
+                    ErrorCode.STEP_FAILURE,
+                    ex.getCause() != null ? ex.getCause() : ex);
+            }
+        }
+
+        return CompletableFuture.completedFuture(response);
+    }
+
+    private void handleDebugEvent(DebugEvent debugEvent, IDebugSession debugSession, IDebugAdapterContext context,
+            ThreadState threadState) {
+        Event event = debugEvent.event;
+        EventRequestManager eventRequestManager = debugSession.getVM().eventRequestManager();
+
+        // When a breakpoint occurs, abort any pending step requests from the same thread.
+        if (event instanceof BreakpointEvent || event instanceof ExceptionEvent) {
+            // if we have a pending target step in then ignore and continue.
+            if (threadState.targetStepIn != null) {
+                debugEvent.shouldResume = true;
+                return;
+            }
+
+            long threadId = ((LocatableEvent) event).thread().uniqueID();
+            if (threadId == threadState.threadId && threadState.pendingStepRequest != null) {
+                threadState.deleteStepRequest(eventRequestManager);
+                threadState.deleteMethodExitRequest(eventRequestManager);
+                context.getStepResultManager().removeMethodResult(threadId);
+                if (threadState.eventSubscription != null) {
+                    threadState.eventSubscription.dispose();
+                }
+            }
+        } else if (event instanceof StepEvent) {
+            ThreadReference thread = ((StepEvent) event).thread();
+            long threadId = thread.uniqueID();
+            threadState.deleteStepRequest(eventRequestManager);
+            if (isStepFiltersConfigured(context.getStepFilters()) || threadState.targetStepIn != null) {
+                try {
+                    if (threadState.pendingStepType == Command.STEPIN || threadState.targetStepIn != null) {
+                        int currentStackDepth = thread.frameCount();
+                        StackFrame topFrame = getTopFrame(thread);
+                        Location currentStepLocation = topFrame.location();
+                        if (threadState.targetStepIn != null) {
+                            if (isStoppedAtSelectedMethod(topFrame, threadState.targetStepIn)) {
+                                // hit: send StoppedEvent
+                            } else {
+                                if (currentStackDepth > threadState.stackDepth) {
+                                    context.getStepResultManager().removeMethodResult(threadId);
+                                    threadState.pendingStepRequest = DebugUtility.createStepOutRequest(thread,
+                                        context.getStepFilters().allowClasses,
+                                        context.getStepFilters().skipClasses);
+                                    threadState.pendingStepRequest.enable();
+                                    debugEvent.shouldResume = true;
+                                    return;
+                                } else if (currentStackDepth == threadState.stackDepth) {
+                                    // If the ending step location is same as the original location where the step into operation is originated,
+                                    // do another step of the same kind.
+                                    if (isSameLocation(currentStepLocation, threadState.stepLocation,
+                                            threadState.targetStepIn)) {
+                                        context.getStepResultManager().removeMethodResult(threadId);
+                                        threadState.pendingStepRequest = DebugUtility.createStepIntoRequest(thread,
+                                            context.getStepFilters().allowClasses,
+                                            context.getStepFilters().skipClasses);
+                                        threadState.pendingStepRequest.enable();
+                                        debugEvent.shouldResume = true;
+                                        return;
+                                    }
+                                }
+                            }
+                        } else if (shouldFilterLocation(threadState.stepLocation, currentStepLocation, context)
+                                || shouldDoExtraStepInto(threadState.stackDepth, threadState.stepLocation,
+                                        currentStackDepth, currentStepLocation)) {
+                            // If the ending step location is filtered, or same as the original location where the step into operation is originated,
+                            // do another step of the same kind.
+                            context.getStepResultManager().removeMethodResult(threadId);
+                            String[] allowedClasses = context.getStepFilters().allowClasses;
+                            if (currentStackDepth > threadState.stackDepth) {
+                                threadState.pendingStepRequest = DebugUtility.createStepOutRequest(thread,
+                                    allowedClasses,
+                                    context.getStepFilters().skipClasses);
+                            } else {
+                                threadState.pendingStepRequest = DebugUtility.createStepIntoRequest(thread,
+                                        allowedClasses,
+                                    context.getStepFilters().skipClasses);
+                            }
+                            threadState.pendingStepRequest.enable();
+                            debugEvent.shouldResume = true;
+                            return;
+                        }
+                    }
+                } catch (IncompatibleThreadStateException | IndexOutOfBoundsException ex) {
+                    // ignore.
+                }
+            }
+            threadState.deleteMethodExitRequest(eventRequestManager);
+            if (threadState.eventSubscription != null) {
+                threadState.eventSubscription.dispose();
+            }
+            context.getThreadCache().addEventThread(thread, "step");
+            context.getProtocolServer().sendEvent(new Events.StoppedEvent("step", thread.uniqueID()));
+            debugEvent.shouldResume = false;
+        } else if (event instanceof MethodExitEvent) {
+            MethodExitEvent methodExitEvent = (MethodExitEvent) event;
+            long threadId = methodExitEvent.thread().uniqueID();
+            if (threadId == threadState.threadId && methodExitEvent.method().equals(threadState.stepLocation.method())) {
+                Value returnValue = methodExitEvent.returnValue();
+                if (returnValue instanceof VoidValue) {
+                    context.getStepResultManager().removeMethodResult(threadId);
+                } else {
+                    JdiMethodResult methodResult = new JdiMethodResult(methodExitEvent.method(), returnValue);
+                    context.getStepResultManager().setMethodResult(threadId, methodResult);
+                }
+            }
+            debugEvent.shouldResume = true;
+        }
+    }
+
+    private boolean isStoppedAtSelectedMethod(StackFrame frame, MethodInvocation selectedMethod) {
+        Method method = frame.location().method();
+        if (method != null
+            && Objects.equals(method.name(), selectedMethod.methodName)
+            && (Objects.equals(method.signature(), selectedMethod.methodSignature)
+                || Objects.equals(method.genericSignature(), selectedMethod.methodGenericSignature))) {
+            ObjectReference thisObject = frame.thisObject();
+            ReferenceType currentType = (thisObject == null) ? method.declaringType() : thisObject.referenceType();
+            if ("java.lang.Object".equals(selectedMethod.declaringTypeName)) {
+                return true;
+            }
+
+            return isSubType(currentType, selectedMethod.declaringTypeName);
+        }
+
+        return false;
+    }
+
+    private boolean isSubType(ReferenceType currentType, String baseType) {
+        if (baseType.equals(currentType.name())) {
+            return true;
+        }
+
+        if (currentType instanceof ClassType) {
+            ClassType classType = (ClassType) currentType;
+            ClassType superClassType = classType.superclass();
+            if (superClassType != null && isSubType(superClassType, baseType)) {
+                return true;
+            }
+
+            List<InterfaceType> interfaces = classType.allInterfaces();
+            for (InterfaceType iface : interfaces) {
+                if (isSubType(iface, baseType)) {
+                    return true;
+                }
+            }
+        }
+
+        if (currentType instanceof InterfaceType) {
+            List<InterfaceType> superInterfaces = ((InterfaceType) currentType).superinterfaces();
+            for (InterfaceType superInterface : superInterfaces) {
+                if (isSubType(superInterface, baseType)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private boolean isStepFiltersConfigured(StepFilters filters) {
+        if (filters == null) {
+            return false;
+        }
+        return ArrayUtils.isNotEmpty(filters.allowClasses) || ArrayUtils.isNotEmpty(filters.skipClasses)
+               || ArrayUtils.isNotEmpty(filters.classNameFilters) || filters.skipConstructors
+               || filters.skipStaticInitializers || filters.skipSynthetics;
+    }
+
+    /**
+     * Return true if the StepEvent's location is a Method that the user has indicated to filter.
+     *
+     * @throws IncompatibleThreadStateException
+     *                      if the thread is not suspended in the target VM.
+     */
+    private boolean shouldFilterLocation(Location originalLocation, Location currentLocation, IDebugAdapterContext context)
+            throws IncompatibleThreadStateException {
+        if (originalLocation == null || currentLocation == null) {
+            return false;
+        }
+        return !shouldFilterMethod(originalLocation.method(), context) && shouldFilterMethod(currentLocation.method(), context);
+    }
+
+    private boolean shouldFilterMethod(Method method, IDebugAdapterContext context) {
+        return (context.getStepFilters().skipStaticInitializers && method.isStaticInitializer())
+                || (context.getStepFilters().skipSynthetics && method.isSynthetic())
+                || (context.getStepFilters().skipConstructors && method.isConstructor());
+    }
+
+    /**
+     * Check if the current top stack is same as the original top stack and if we
+     * are not in target step in we should not request an extra step in. But if we
+     * are processing a target step in, we only check if the original and current
+     * location are same. If they are not same we request a extra step in.
+     *
+     * @throws IncompatibleThreadStateException
+     *                                          if the thread is not suspended in
+     *                                          the target VM.
+     */
+    private boolean shouldDoExtraStepInto(int originalStackDepth, Location originalLocation, int currentStackDepth,
+            Location currentLocation)
+            throws IncompatibleThreadStateException {
+        if (originalStackDepth != currentStackDepth) {
+            return false;
+        }
+        if (originalLocation == null) {
+            return false;
+        }
+
+        Method originalMethod = originalLocation.method();
+        Method currentMethod = currentLocation.method();
+        if (!originalMethod.equals(currentMethod)) {
+            return false;
+        }
+        if (originalLocation.lineNumber() != currentLocation.lineNumber()) {
+            return false;
+        }
+
+        return true;
+    }
+
+    private boolean isSameLocation(Location current, Location original, MethodInvocation targetStepIn) {
+        if (original == null || current == null) {
+            return false;
+        }
+
+        Method originalMethod = original.method();
+        Method currentMethod = current.method();
+        // if the lines doesn't match, check if the current line is still behind the
+        // target if a target exist. This handles where the target is part of a
+        // expression which is wrapped.
+        return originalMethod.equals(currentMethod)
+                && (original.lineNumber() == current.lineNumber()
+                        || (targetStepIn != null && targetStepIn.lineEnd >= current.lineNumber()));
+    }
+
+    /**
+     * Return the top stack frame of the target thread.
+     *
+     * @param thread
+     *              the target thread.
+     * @return the top frame.
+     * @throws IncompatibleThreadStateException
+     *                      if the thread is not suspended in the target VM.
+     * @throws IndexOutOfBoundsException
+     *                      if the thread doesn't contain any stack frame.
+     */
+    private StackFrame getTopFrame(ThreadReference thread) throws IncompatibleThreadStateException {
+        return thread.frame(0);
+    }
+
+    class ThreadState {
+        long threadId = -1;
+        Command pendingStepType;
+        StepRequest pendingStepRequest = null;
+        MethodExitRequest pendingMethodExitRequest = null;
+        int stackDepth = -1;
+        StackFrame topFrame = null;
+        Location stepLocation = null;
+        Disposable eventSubscription = null;
+        MethodInvocation targetStepIn = null;
+
+        public void deleteMethodExitRequest(EventRequestManager manager) {
+            DebugUtility.deleteEventRequestSafely(manager, this.pendingMethodExitRequest);
+            this.pendingMethodExitRequest = null;
+        }
+
+        public void deleteStepRequest(EventRequestManager manager) {
+            DebugUtility.deleteEventRequestSafely(manager, this.pendingStepRequest);
+            this.pendingStepRequest = null;
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ThreadsRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ThreadsRequestHandler.java
index f8f964f4e..5c4770391 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ThreadsRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/ThreadsRequestHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -14,25 +14,32 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
+import org.apache.commons.lang3.StringUtils;
+
+import com.microsoft.java.debug.core.AsyncJdwpUtils;
 import com.microsoft.java.debug.core.DebugUtility;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
 import com.microsoft.java.debug.core.adapter.ErrorCode;
-import com.microsoft.java.debug.core.adapter.Events;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.ContinueArguments;
-import com.microsoft.java.debug.core.adapter.Requests.NextArguments;
-import com.microsoft.java.debug.core.adapter.Requests.PauseArguments;
-import com.microsoft.java.debug.core.adapter.Requests.StepInArguments;
-import com.microsoft.java.debug.core.adapter.Requests.StepOutArguments;
-import com.microsoft.java.debug.core.adapter.Requests.ThreadsArguments;
-import com.microsoft.java.debug.core.adapter.Responses;
-import com.microsoft.java.debug.core.adapter.Types;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.protocol.Events;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.ContinueArguments;
+import com.microsoft.java.debug.core.protocol.Requests.PauseArguments;
+import com.microsoft.java.debug.core.protocol.Requests.ThreadOperationArguments;
+import com.microsoft.java.debug.core.protocol.Requests.ThreadsArguments;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types;
 import com.sun.jdi.ObjectCollectedException;
 import com.sun.jdi.ThreadReference;
 import com.sun.jdi.VMDisconnectedException;
@@ -41,123 +48,201 @@ public class ThreadsRequestHandler implements IDebugRequestHandler {
 
     @Override
     public List<Command> getTargetCommands() {
-        return Arrays.asList(Command.THREADS, Command.STEPIN, Command.STEPOUT, Command.NEXT, Command.PAUSE, Command.CONTINUE);
+        return Arrays.asList(Command.THREADS, Command.PAUSE, Command.CONTINUE, Command.CONTINUEALL,
+                Command.CONTINUEOTHERS, Command.PAUSEALL, Command.PAUSEOTHERS);
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response,
+            IDebugAdapterContext context) {
         if (context.getDebugSession() == null) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION, "Debug Session doesn't exist.");
-            return;
+            return AdapterUtils.createAsyncErrorResponse(response, ErrorCode.EMPTY_DEBUG_SESSION,
+                    "Debug Session doesn't exist.");
         }
+
         switch (command) {
             case THREADS:
-                this.threads((ThreadsArguments) arguments, response, context);
-                break;
-            case STEPIN:
-                this.stepIn((StepInArguments) arguments, response, context);
-                break;
-            case STEPOUT:
-                this.stepOut((StepOutArguments) arguments, response, context);
-                break;
-            case NEXT:
-                this.next((NextArguments) arguments, response, context);
-                break;
+                return this.threads((ThreadsArguments) arguments, response, context);
             case PAUSE:
-                this.pause((PauseArguments) arguments, response, context);
-                break;
+                return this.pause((PauseArguments) arguments, response, context);
             case CONTINUE:
-                this.resume((ContinueArguments) arguments, response, context);
-                break;
+                return this.resume((ContinueArguments) arguments, response, context);
+            case CONTINUEALL:
+                return this.resumeAll((ThreadOperationArguments) arguments, response, context);
+            case CONTINUEOTHERS:
+                return this.resumeOthers((ThreadOperationArguments) arguments, response, context);
+            case PAUSEALL:
+                return this.pauseAll((ThreadOperationArguments) arguments, response, context);
+            case PAUSEOTHERS:
+                return this.pauseOthers((ThreadOperationArguments) arguments, response, context);
             default:
-                return;
+                return AdapterUtils.createAsyncErrorResponse(response, ErrorCode.UNRECOGNIZED_REQUEST_FAILURE,
+                        String.format("Unrecognized request: { _request: %s }", command.toString()));
         }
     }
 
-    private void threads(Requests.ThreadsArguments arguments, Response response, IDebugAdapterContext context) {
+    private CompletableFuture<Response> threads(Requests.ThreadsArguments arguments, Response response, IDebugAdapterContext context) {
         ArrayList<Types.Thread> threads = new ArrayList<>();
         try {
-            for (ThreadReference thread : context.getDebugSession().allThreads()) {
-                if (thread.isCollected()) {
-                    continue;
-                }
-                Types.Thread clientThread = new Types.Thread(thread.uniqueID(), "Thread [" + thread.name() + "]");
-                threads.add(clientThread);
+            List<ThreadReference> allThreads = context.getThreadCache().visibleThreads(context);
+            context.getThreadCache().resetThreads(allThreads);
+            allThreads = allThreads.stream().filter((thread) -> !context.getThreadCache().isDeathThread(thread.uniqueID())).collect(Collectors.toList());
+            List<ThreadInfo> jdiThreads = resolveThreadInfos(allThreads, context);
+            for (ThreadInfo jdiThread : jdiThreads) {
+                String name = StringUtils.isBlank(jdiThread.name) ? String.valueOf(jdiThread.thread.uniqueID()) : jdiThread.name;
+                threads.add(new Types.Thread(jdiThread.thread.uniqueID(), "Thread [" + name + "]"));
             }
-        } catch (VMDisconnectedException | ObjectCollectedException ex) {
+        } catch (ObjectCollectedException | CancellationException | CompletionException ex) {
             // allThreads may throw VMDisconnectedException when VM terminates and thread.name() may throw ObjectCollectedException
             // when the thread is exiting.
         }
         response.body = new Responses.ThreadsResponseBody(threads);
+        return CompletableFuture.completedFuture(response);
     }
 
-    private void stepIn(Requests.StepInArguments arguments, Response response, IDebugAdapterContext context) {
-        ThreadReference thread = DebugUtility.getThread(context.getDebugSession(), arguments.threadId);
-        if (thread != null) {
-            DebugUtility.stepInto(thread, context.getDebugSession().eventHub());
-            checkThreadRunningAndRecycleIds(thread, context);
-        }
-    }
+    private static List<ThreadInfo> resolveThreadInfos(List<ThreadReference> allThreads, IDebugAdapterContext context) {
+        List<ThreadInfo> threadInfos = new ArrayList<>(allThreads.size());
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        for (ThreadReference thread : allThreads) {
+            ThreadInfo threadInfo = new ThreadInfo(thread);
+            long threadId = thread.uniqueID();
+            if (context.getThreadCache().getThreadName(threadId) != null) {
+                threadInfo.name = context.getThreadCache().getThreadName(threadId);
+            } else {
+                if (context.asyncJDWP()) {
+                    futures.add(AsyncJdwpUtils.runAsync(() -> {
+                        threadInfo.name = threadInfo.thread.name();
+                        context.getThreadCache().setThreadName(threadId, threadInfo.name);
+                    }));
+                } else {
+                    threadInfo.name = threadInfo.thread.name();
+                    context.getThreadCache().setThreadName(threadId, threadInfo.name);
+                }
+            }
 
-    private void stepOut(Requests.StepOutArguments arguments, Response response, IDebugAdapterContext context) {
-        ThreadReference thread = DebugUtility.getThread(context.getDebugSession(), arguments.threadId);
-        if (thread != null) {
-            DebugUtility.stepOut(thread, context.getDebugSession().eventHub());
-            checkThreadRunningAndRecycleIds(thread, context);
+            threadInfos.add(threadInfo);
         }
-    }
 
-    private void next(Requests.NextArguments arguments, Response response, IDebugAdapterContext context) {
-        ThreadReference thread = DebugUtility.getThread(context.getDebugSession(), arguments.threadId);
-        if (thread != null) {
-            DebugUtility.stepOver(thread, context.getDebugSession().eventHub());
-            checkThreadRunningAndRecycleIds(thread, context);
-        }
+        AsyncJdwpUtils.await(futures);
+        return threadInfos;
     }
 
-    private void pause(Requests.PauseArguments arguments, Response response, IDebugAdapterContext context) {
-        ThreadReference thread = DebugUtility.getThread(context.getDebugSession(), arguments.threadId);
+    private CompletableFuture<Response> pause(Requests.PauseArguments arguments, Response response, IDebugAdapterContext context) {
+        ThreadReference thread = context.getThreadCache().getThread(arguments.threadId);
+        if (thread == null) {
+            thread = DebugUtility.getThread(context.getDebugSession(), arguments.threadId);
+        }
         if (thread != null) {
-            try {
-                thread.suspend();
-                context.sendEventAsync(new Events.StoppedEvent("pause", arguments.threadId));
-            } catch (VMDisconnectedException ex) {
-                AdapterUtils.setErrorResponse(response, ErrorCode.VM_TERMINATED, "Target VM is already terminated.");
-            }
+            pauseThread(thread, context);
         } else {
+            context.getStepResultManager().removeAllMethodResults();
             context.getDebugSession().suspend();
-            context.sendEventAsync(new Events.StoppedEvent("pause", arguments.threadId, true));
+            context.getProtocolServer().sendEvent(new Events.StoppedEvent("pause", arguments.threadId, true));
+            context.getThreadCache().setThreadStoppedReason(arguments.threadId, "pause");
         }
+        return CompletableFuture.completedFuture(response);
     }
 
-    private void resume(Requests.ContinueArguments arguments, Response response, IDebugAdapterContext context) {
+    private CompletableFuture<Response> resume(Requests.ContinueArguments arguments, Response response, IDebugAdapterContext context) {
         boolean allThreadsContinued = true;
-        ThreadReference thread = DebugUtility.getThread(context.getDebugSession(), arguments.threadId);
+        ThreadReference thread = context.getThreadCache().getThread(arguments.threadId);
+        if (thread == null) {
+            thread = DebugUtility.getThread(context.getDebugSession(), arguments.threadId);
+        }
+
+        if (context.getDebugSession().shouldSuspendAllThreads()) {
+            thread = null;
+        }
+
         /**
          * See the jdi doc https://docs.oracle.com/javase/7/docs/jdk/api/jpda/jdi/com/sun/jdi/ThreadReference.html#resume(),
          * suspends of both the virtual machine and individual threads are counted. Before a thread will run again, it must
          * be resumed (through ThreadReference#resume() or VirtualMachine#resume()) the same number of times it has been suspended.
          */
         if (thread != null) {
+            context.getThreadCache().removeEventThread(arguments.threadId);
+            context.getStepResultManager().removeMethodResult(arguments.threadId);
+            context.getExceptionManager().removeException(arguments.threadId);
             allThreadsContinued = false;
+            context.getThreadCache().clearThreadStoppedState(arguments.threadId);
             DebugUtility.resumeThread(thread);
+            context.getStackFrameManager().clearStackFrames(thread);
             checkThreadRunningAndRecycleIds(thread, context);
         } else {
-            context.getDebugSession().resume();
+            context.getStepResultManager().removeAllMethodResults();
+            context.getExceptionManager().removeAllExceptions();
+            context.getThreadCache().clearAllThreadStoppedState();
+            resumeVM(context);
+            context.getStackFrameManager().clearStackFrames();
             context.getRecyclableIdPool().removeAllObjects();
         }
         response.body = new Responses.ContinueResponseBody(allThreadsContinued);
+        return CompletableFuture.completedFuture(response);
     }
 
-    private void checkThreadRunningAndRecycleIds(ThreadReference thread, IDebugAdapterContext context) {
-        try {
-            boolean allThreadsRunning = !DebugUtility.getAllThreadsSafely(context.getDebugSession()).stream()
-                    .anyMatch(ThreadReference::isSuspended);
-            if (allThreadsRunning) {
-                context.getRecyclableIdPool().removeAllObjects();
+    private CompletableFuture<Response> resumeAll(Requests.ThreadOperationArguments arguments, Response response, IDebugAdapterContext context) {
+        context.getStepResultManager().removeAllMethodResults();
+        context.getExceptionManager().removeAllExceptions();
+        context.getThreadCache().clearAllThreadStoppedState();
+        resumeVM(context);
+        context.getProtocolServer().sendEvent(new Events.ContinuedEvent(arguments.threadId, true));
+        context.getStackFrameManager().clearStackFrames();
+        context.getRecyclableIdPool().removeAllObjects();
+        return CompletableFuture.completedFuture(response);
+    }
+
+    private CompletableFuture<Response> resumeOthers(Requests.ThreadOperationArguments arguments, Response response, IDebugAdapterContext context) {
+        List<ThreadReference> threads = context.getThreadCache().visibleThreads(context);
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        for (ThreadReference thread : threads) {
+            if (thread.uniqueID() == arguments.threadId) {
+                continue;
+            }
+
+            context.getThreadCache().clearThreadStoppedState(thread.uniqueID());
+            if (context.asyncJDWP()) {
+                futures.add(AsyncJdwpUtils.runAsync(() -> resumeThread(thread, context)));
             } else {
-                context.getRecyclableIdPool().removeObjectsByOwner(thread.uniqueID());
+                resumeThread(thread, context);
+            }
+        }
+        AsyncJdwpUtils.await(futures);
+        return CompletableFuture.completedFuture(response);
+    }
+
+    private CompletableFuture<Response> pauseAll(Requests.ThreadOperationArguments arguments, Response response, IDebugAdapterContext context) {
+        context.getDebugSession().suspend();
+        context.getProtocolServer().sendEvent(new Events.StoppedEvent("pause", arguments.threadId, true));
+        context.getThreadCache().setThreadStoppedReason(arguments.threadId, "pause");
+        return CompletableFuture.completedFuture(response);
+    }
+
+    private CompletableFuture<Response> pauseOthers(Requests.ThreadOperationArguments arguments, Response response, IDebugAdapterContext context) {
+        List<ThreadReference> threads = context.getThreadCache().visibleThreads(context);
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        for (ThreadReference thread : threads) {
+            if (thread.uniqueID() == arguments.threadId) {
+                continue;
             }
+
+            if (context.asyncJDWP()) {
+                futures.add(AsyncJdwpUtils.runAsync(() -> pauseThread(thread, context)));
+            } else {
+                pauseThread(thread, context);
+            }
+        }
+        AsyncJdwpUtils.await(futures);
+        return CompletableFuture.completedFuture(response);
+    }
+
+    /**
+     * Recycle the related ids owned by the specified thread.
+     */
+    public static void checkThreadRunningAndRecycleIds(ThreadReference thread, IDebugAdapterContext context) {
+        try {
+            IEvaluationProvider engine = context.getProvider(IEvaluationProvider.class);
+            engine.clearState(thread);
+            context.getRecyclableIdPool().removeObjectsByOwner(thread.uniqueID());
         } catch (VMDisconnectedException ex) {
             // isSuspended may throw VMDisconnectedException when the VM terminates
             context.getRecyclableIdPool().removeAllObjects();
@@ -167,4 +252,79 @@ private void checkThreadRunningAndRecycleIds(ThreadReference thread, IDebugAdapt
         }
     }
 
+    private void resumeVM(IDebugAdapterContext context) {
+        List<ThreadReference> visibleThreads = context.getThreadCache().visibleThreads(context);
+        context.getThreadCache().clearEventThread();
+
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        /**
+         * To ensure that all threads are fully resumed when the VM is resumed, make sure the suspend count
+         * of each thread is no larger than 1.
+         * Notes: Decrementing the thread' suspend count to 1 is on purpose, because it doesn't break the
+         * the thread's suspend state, and also make sure the next instruction vm.resume() is able to resume
+         * all threads fully.
+         */
+        Consumer<ThreadReference> resumeThread = (ThreadReference tr) -> {
+            try {
+                while (tr.suspendCount() > 1) {
+                    tr.resume();
+                }
+            } catch (ObjectCollectedException ex) {
+                // Ignore it if the thread is garbage collected.
+            }
+        };
+        for (ThreadReference tr : visibleThreads) {
+            if (context.asyncJDWP()) {
+                futures.add(AsyncJdwpUtils.runAsync(() -> resumeThread.accept(tr)));
+            } else {
+                resumeThread.accept(tr);
+            }
+        }
+
+        AsyncJdwpUtils.await(futures);
+        context.getDebugSession().getVM().resume();
+    }
+
+    private void resumeThread(ThreadReference thread, IDebugAdapterContext context) {
+        try {
+            context.getThreadCache().removeEventThread(thread.uniqueID());
+            int suspends = thread.suspendCount();
+            if (suspends > 0) {
+                long threadId = thread.uniqueID();
+                context.getExceptionManager().removeException(threadId);
+                DebugUtility.resumeThread(thread, suspends);
+                context.getProtocolServer().sendEvent(new Events.ContinuedEvent(threadId));
+                context.getStackFrameManager().clearStackFrames(thread);
+                checkThreadRunningAndRecycleIds(thread, context);
+            }
+        } catch (ObjectCollectedException ex) {
+            // the thread is garbage collected.
+            context.getThreadCache().addDeathThread(thread.uniqueID());
+        }
+    }
+
+    private void pauseThread(ThreadReference thread, IDebugAdapterContext context) {
+        try {
+            // Ignore it if the thread status is unknown or zombie
+            if (!thread.isSuspended() && thread.status() > 0) {
+                long threadId = thread.uniqueID();
+                context.getStepResultManager().removeMethodResult(threadId);
+                thread.suspend();
+                context.getProtocolServer().sendEvent(new Events.StoppedEvent("pause", threadId));
+                context.getThreadCache().setThreadStoppedReason(threadId, "pause");
+            }
+        } catch (ObjectCollectedException ex) {
+            // the thread is garbage collected.
+            context.getThreadCache().addDeathThread(thread.uniqueID());
+        }
+    }
+
+    static class ThreadInfo {
+        public ThreadReference thread;
+        public String name;
+
+        public ThreadInfo(ThreadReference thread) {
+            this.thread = thread;
+        }
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/VMHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/VMHandler.java
new file mode 100644
index 000000000..07c57d00b
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/VMHandler.java
@@ -0,0 +1,54 @@
+/*******************************************************************************
+* Copyright (c) 2020 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.handler;
+
+import com.microsoft.java.debug.core.adapter.IVirtualMachineManager;
+import com.microsoft.java.debug.core.adapter.IVirtualMachineManagerProvider;
+import com.sun.jdi.VirtualMachine;
+import com.sun.jdi.VirtualMachineManager;
+
+public class VMHandler {
+    private IVirtualMachineManagerProvider vmProvider = null;
+
+    public VMHandler() {
+    }
+
+    public VMHandler(IVirtualMachineManagerProvider vmProvider) {
+        this.vmProvider = vmProvider;
+    }
+
+    public IVirtualMachineManagerProvider getVmProvider() {
+        return vmProvider;
+    }
+
+    public void setVmProvider(IVirtualMachineManagerProvider vmProvider) {
+        this.vmProvider = vmProvider;
+    }
+
+    public void connectVirtualMachine(VirtualMachine vm) {
+        if (vm != null && vmProvider != null) {
+            VirtualMachineManager vmManager = vmProvider.getVirtualMachineManager();
+            if (vmManager instanceof IVirtualMachineManager) {
+                ((IVirtualMachineManager) vmManager).connectVirtualMachine(vm);
+            }
+        }
+    }
+
+    public void disconnectVirtualMachine(VirtualMachine vm) {
+        if (vm != null && vmProvider != null) {
+            VirtualMachineManager vmManager = vmProvider.getVirtualMachineManager();
+            if (vmManager instanceof IVirtualMachineManager) {
+                ((IVirtualMachineManager) vmManager).disconnectVirtualMachine(vm);
+            }
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/VariablesRequestHandler.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/VariablesRequestHandler.java
index af1fb585b..47854528f 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/VariablesRequestHandler.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/handler/VariablesRequestHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -19,33 +19,72 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
+import com.microsoft.java.debug.core.AsyncJdwpUtils;
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.JdiMethodResult;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
 import com.microsoft.java.debug.core.adapter.ErrorCode;
 import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.IDebugRequestHandler;
-import com.microsoft.java.debug.core.adapter.Messages.Response;
-import com.microsoft.java.debug.core.adapter.Requests.Arguments;
-import com.microsoft.java.debug.core.adapter.Requests.Command;
-import com.microsoft.java.debug.core.adapter.Requests.VariablesArguments;
-import com.microsoft.java.debug.core.adapter.Responses;
-import com.microsoft.java.debug.core.adapter.Types;
-import com.microsoft.java.debug.core.adapter.formatter.NumericFormatEnum;
-import com.microsoft.java.debug.core.adapter.formatter.NumericFormatter;
-import com.microsoft.java.debug.core.adapter.formatter.SimpleTypeFormatter;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.adapter.IStackFrameManager;
 import com.microsoft.java.debug.core.adapter.variables.IVariableFormatter;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructure;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructure.LogicalStructureExpression;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructure.LogicalVariable;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructureManager;
+import com.microsoft.java.debug.core.adapter.variables.StackFrameReference;
+import com.microsoft.java.debug.core.adapter.variables.StringReferenceProxy;
 import com.microsoft.java.debug.core.adapter.variables.Variable;
+import com.microsoft.java.debug.core.adapter.variables.VariableDetailUtils;
 import com.microsoft.java.debug.core.adapter.variables.VariableProxy;
 import com.microsoft.java.debug.core.adapter.variables.VariableUtils;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+import com.microsoft.java.debug.core.protocol.Requests.Arguments;
+import com.microsoft.java.debug.core.protocol.Requests.Command;
+import com.microsoft.java.debug.core.protocol.Requests.VariablesArguments;
+import com.microsoft.java.debug.core.protocol.Types.VariablePresentationHint;
+import com.microsoft.java.debug.core.protocol.Responses;
+import com.microsoft.java.debug.core.protocol.Types;
 import com.sun.jdi.AbsentInformationException;
 import com.sun.jdi.ArrayReference;
+import com.sun.jdi.IntegerValue;
+import com.sun.jdi.InternalException;
+import com.sun.jdi.InvalidStackFrameException;
 import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ReferenceType;
 import com.sun.jdi.StackFrame;
+import com.sun.jdi.StringReference;
 import com.sun.jdi.Type;
 import com.sun.jdi.Value;
+import com.sun.jdi.PrimitiveType;
+import com.sun.jdi.ClassNotLoadedException;
 
 public class VariablesRequestHandler implements IDebugRequestHandler {
+    protected static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    /**
+     * When the debugger enables logical structures and
+     * toString settings, for each Object variable in the
+     * variable list, the debugger needs to check its
+     * superclass and interface to find out if it inherits
+     * from Collection or overrides the toString method.
+     * This will cause the debugger to send a lot of JDWP
+     * requests for them. For a test case with 4 object
+     * variables, the debug adapter may need to send more
+     * than 100 JDWP requests to handle these variable
+     * requests. To achieve a DAP latency of 1s with a
+     * single-threaded JDWP request processing strategy,
+     * a single JDWP latency is about 10ms.
+     */
+    static final long USABLE_JDWP_LATENCY = 10/*ms*/;
 
     @Override
     public List<Command> getTargetCommands() {
@@ -53,22 +92,15 @@ public List<Command> getTargetCommands() {
     }
 
     @Override
-    public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
+    public CompletableFuture<Response> handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
         IVariableFormatter variableFormatter = context.getVariableFormatter();
         VariablesArguments varArgs = (VariablesArguments) arguments;
 
+        boolean showStaticVariables = DebugSettings.getCurrent().showStaticVariables;
+
         Map<String, Object> options = variableFormatter.getDefaultOptions();
-        // This should be false by default(currently true for test).
-        // User will need to explicitly turn it on by configuring launch.json
-        boolean showStaticVariables = true;
-        // TODO: When vscode protocol support customize settings of value format, showFullyQualifiedNames should be one of the options.
-        boolean showFullyQualifiedNames = true;
-        if (varArgs.format != null && varArgs.format.hex) {
-            options.put(NumericFormatter.NUMERIC_FORMAT_OPTION, NumericFormatEnum.HEX);
-        }
-        if (showFullyQualifiedNames) {
-            options.put(SimpleTypeFormatter.QUALIFIED_CLASS_NAME_OPTION, showFullyQualifiedNames);
-        }
+        VariableUtils.applyFormatterOptions(options, varArgs.format != null && varArgs.format.hex);
+        IEvaluationProvider evaluationEngine = context.getProvider(IEvaluationProvider.class);
 
         List<Types.Variable> list = new ArrayList<>();
         Object container = context.getRecyclableIdPool().getObjectById(varArgs.variablesReference);
@@ -76,60 +108,144 @@ public void handle(Command command, Arguments arguments, Response response, IDeb
         // variable request will contain the right variablesReference.
         if (container == null) {
             response.body = new Responses.VariablesResponseBody(list);
-            return;
+            return CompletableFuture.completedFuture(response);
         }
 
         if (!(container instanceof VariableProxy)) {
-            AdapterUtils.setErrorResponse(response, ErrorCode.GET_VARIABLE_FAILURE,
-                    String.format("VariablesRequest: Invalid variablesReference %d.", varArgs.variablesReference));
-            return;
+            throw AdapterUtils.createCompletionException(
+                String.format("VariablesRequest: Invalid variablesReference %d.", varArgs.variablesReference),
+                ErrorCode.GET_VARIABLE_FAILURE);
         }
 
         VariableProxy containerNode = (VariableProxy) container;
-        List<Variable> childrenList;
-        if (containerNode.getProxiedVariable() instanceof StackFrame) {
+
+        if (supportsToStringView(context) && containerNode.isLazyVariable()) {
+            Types.Variable typedVariable = this.resolveLazyVariable(context, containerNode, variableFormatter, options, evaluationEngine);
+            if (typedVariable != null) {
+                list.add(typedVariable);
+                response.body = new Responses.VariablesResponseBody(list);
+                return CompletableFuture.completedFuture(response);
+            }
+        }
+        List<Variable> childrenList = new ArrayList<>();
+        IStackFrameManager stackFrameManager = context.getStackFrameManager();
+        String containerEvaluateName = containerNode.getEvaluateName();
+        boolean isUnboundedTypeContainer = containerNode.isUnboundedType();
+        if (containerNode.getProxiedVariable() instanceof StackFrameReference) {
+            StackFrameReference stackFrameReference = (StackFrameReference) containerNode.getProxiedVariable();
+            StackFrame frame = stackFrameManager.getStackFrame(stackFrameReference);
+            if (frame == null) {
+                throw AdapterUtils.createCompletionException(
+                    String.format("Invalid stackframe id %d to get variables.", varArgs.variablesReference),
+                    ErrorCode.GET_VARIABLE_FAILURE);
+            }
             try {
-                StackFrame frame = (StackFrame) containerNode.getProxiedVariable();
-                childrenList = VariableUtils.listLocalVariables(frame);
-                Variable thisVariable = VariableUtils.getThisVariable(frame);
-                if (thisVariable != null) {
-                    childrenList.add(thisVariable);
+                long threadId = stackFrameReference.getThread().uniqueID();
+                JdiMethodResult result = context.getStepResultManager().getMethodResult(threadId);
+                if (result != null) {
+                    String returnIcon = (AdapterUtils.isWin || AdapterUtils.isMac) ? "⎯►" : "->";
+                    childrenList.add(new Variable(returnIcon + result.method.name() + "()", result.value, null));
                 }
-                if (showStaticVariables && frame.location().method().isStatic()) {
-                    childrenList.addAll(VariableUtils.listStaticVariables(frame));
+
+                if (useAsyncJDWP(context)) {
+                    childrenList.addAll(getVariablesOfFrameAsync(frame, showStaticVariables));
+                } else {
+                    childrenList.addAll(VariableUtils.listLocalVariables(frame));
+                    Variable thisVariable = VariableUtils.getThisVariable(frame);
+                    if (thisVariable != null) {
+                        childrenList.add(thisVariable);
+                    }
+                    if (showStaticVariables && frame.location().method().isStatic()) {
+                        childrenList.addAll(VariableUtils.listStaticVariables(frame));
+                    }
                 }
-            } catch (AbsentInformationException e) {
-                AdapterUtils.setErrorResponse(response, ErrorCode.GET_VARIABLE_FAILURE,
-                        String.format("Failed to get variables. Reason: %s", e.toString()));
-                return;
+            } catch (CompletionException | InternalException | InvalidStackFrameException | CancellationException | AbsentInformationException e) {
+                throw AdapterUtils.createCompletionException(
+                    String.format("Failed to get variables. Reason: %s", e.toString()),
+                    ErrorCode.GET_VARIABLE_FAILURE,
+                    e.getCause() != null ? e.getCause() : e);
             }
         } else {
             try {
                 ObjectReference containerObj = (ObjectReference) containerNode.getProxiedVariable();
+                if (supportsLogicStructureView(context) && evaluationEngine != null) {
+                    JavaLogicalStructure logicalStructure = null;
+                    try {
+                        logicalStructure = JavaLogicalStructureManager.getLogicalStructure(containerObj);
+                    } catch (Exception e) {
+                        logger.log(Level.WARNING, "Failed to get the logical structure for the variable, fall back to the Object view.", e);
+                    }
+                    if (isUnboundedTypeContainer && logicalStructure != null && containerEvaluateName != null) {
+                        containerEvaluateName = "((" + logicalStructure.getFullyQualifiedName() + ")" + containerEvaluateName + ")";
+                        isUnboundedTypeContainer = false;
+                    }
+                    while (logicalStructure != null) {
+                        LogicalStructureExpression valueExpression = logicalStructure.getValueExpression();
+                        LogicalVariable[] logicalVariables = logicalStructure.getVariables();
+                        try {
+                            if (valueExpression != null) {
+                                containerEvaluateName = containerEvaluateName == null ? null : containerEvaluateName + "." + valueExpression.evaluateName;
+                                isUnboundedTypeContainer = valueExpression.returnUnboundedType;
+                                Value value = logicalStructure.getValue(containerObj, containerNode.getThread(), evaluationEngine);
+                                if (value instanceof ObjectReference) {
+                                    containerObj = (ObjectReference) value;
+                                    logicalStructure = JavaLogicalStructureManager.getLogicalStructure(containerObj);
+                                    continue;
+                                } else {
+                                    childrenList = Arrays.asList(new Variable("logical structure", value));
+                                }
+                            } else if (logicalVariables != null && logicalVariables.length > 0) {
+                                for (LogicalVariable logicalVariable : logicalVariables) {
+                                    String name = logicalVariable.getName();
+                                    Value value = logicalVariable.getValue(containerObj, containerNode.getThread(), evaluationEngine);
+                                    Variable variable = new Variable(name, value, logicalVariable.getEvaluateName());
+                                    variable.setUnboundedType(logicalVariable.returnUnboundedType());
+                                    childrenList.add(variable);
+                                }
+                            }
+                        } catch (Exception e) {
+                            logger.log(Level.WARNING, "Failed to get the logical structure for the variable, fall back to the Object view.", e);
+                        }
 
-                if (varArgs.count > 0) {
-                    childrenList = VariableUtils.listFieldVariables(containerObj, varArgs.start, varArgs.count);
-                } else {
-                    childrenList = VariableUtils.listFieldVariables(containerObj, showStaticVariables);
+                        logicalStructure = null;
+                    }
+                }
+
+                if (childrenList.isEmpty() && VariableUtils.hasChildren(containerObj, showStaticVariables)) {
+                    if (varArgs.count > 0) {
+                        childrenList = VariableUtils.listFieldVariables(containerObj, varArgs.start, varArgs.count);
+                    } else {
+                        childrenList = VariableUtils.listFieldVariables(containerObj, showStaticVariables, useAsyncJDWP(context));
+                    }
                 }
             } catch (AbsentInformationException e) {
-                AdapterUtils.setErrorResponse(response, ErrorCode.GET_VARIABLE_FAILURE,
-                        String.format("Failed to get variables. Reason: %s", e.toString()));
-                return;
+                throw AdapterUtils.createCompletionException(
+                    String.format("Failed to get variables. Reason: %s", e.toString()),
+                    ErrorCode.GET_VARIABLE_FAILURE,
+                    e);
             }
         }
 
         // Find variable name duplicates
-        Set<String> duplicateNames = getDuplicateNames(childrenList.stream().map(var -> var.name)
-                .collect(Collectors.toList()));
-        Map<Variable, String> variableNameMap = new HashMap<>();
-        if (!duplicateNames.isEmpty()) {
-            Map<String, List<Variable>> duplicateVars =
-                    childrenList.stream()
-                            .filter(var -> duplicateNames.contains(var.name))
-                            .collect(Collectors.groupingBy(var -> var.name, Collectors.toList()));
+        Set<String> duplicateNames = getDuplicateNames(childrenList.stream().map(var -> var.name).collect(Collectors.toList()));
+        List<Variable> duplicateVars = childrenList.stream()
+                .filter(var -> duplicateNames.contains(var.name))
+                .collect(Collectors.toList());
+        // Since JDI caches the fetched properties locally, in async mode we can warm up the JDI cache in advance.
+        if (useAsyncJDWP(context)) {
+            try {
+                AsyncJdwpUtils.await(warmUpJDICache(childrenList, duplicateVars));
+            } catch (CompletionException | CancellationException e) {
+                response.body = new Responses.VariablesResponseBody(list);
+                return CompletableFuture.completedFuture(response);
+            }
+        }
 
-            duplicateVars.forEach((k, duplicateVariables) -> {
+        Map<Variable, String> variableNameMap = new HashMap<>();
+        if (!duplicateVars.isEmpty()) {
+            Map<String, List<Variable>> duplicateVarGroups = duplicateVars.stream()
+                    .collect(Collectors.groupingBy(var -> var.name, Collectors.toList()));
+            duplicateVarGroups.forEach((k, duplicateVariables) -> {
                 Set<String> declarationTypeNames = new HashSet<>();
                 boolean declarationTypeNameConflict = false;
                 // try use type formatter to resolve name conflict
@@ -156,25 +272,190 @@ public void handle(Command command, Arguments arguments, Response response, IDeb
                 }
             });
         }
+
         for (Variable javaVariable : childrenList) {
             Value value = javaVariable.value;
             String name = javaVariable.name;
             if (variableNameMap.containsKey(javaVariable)) {
                 name = variableNameMap.get(javaVariable);
             }
+            int indexedVariables = -1;
+            Value sizeValue = null;
+            if (value instanceof ArrayReference) {
+                indexedVariables = ((ArrayReference) value).length();
+            } else if (supportsLogicStructureView(context) && value instanceof ObjectReference && evaluationEngine != null) {
+                try {
+                    JavaLogicalStructure structure = JavaLogicalStructureManager.getLogicalStructure((ObjectReference) value);
+                    if (structure != null && structure.getSizeExpression() != null) {
+                        sizeValue = structure.getSize((ObjectReference) value, containerNode.getThread(), evaluationEngine);
+                        if (sizeValue != null && sizeValue instanceof IntegerValue) {
+                            indexedVariables = ((IntegerValue) sizeValue).value();
+                        }
+                    }
+                } catch (Exception e) {
+                    logger.log(Level.INFO, "Failed to get the logical size of the variable", e);
+                }
+            }
+
+            String evaluateName = null;
+            if (javaVariable.evaluateName == null || (containerEvaluateName == null && containerNode.getProxiedVariable() instanceof ObjectReference)) {
+                // Disable evaluate on the method return value.
+                evaluateName = null;
+            } else if (isUnboundedTypeContainer && !containerNode.isIndexedVariable()) {
+                // The type name returned by JDI is the binary name, which uses '$' as the separator of
+                // inner class e.g. Foo$Bar. But the evaluation expression only accepts using '.' as the class
+                // name separator.
+                String typeName = ((ObjectReference) containerNode.getProxiedVariable()).referenceType().name();
+                // TODO: This replacement will possibly change the $ in the class name itself.
+                typeName = typeName.replaceAll("\\$", ".");
+                evaluateName = VariableUtils.getEvaluateName(javaVariable.evaluateName, "((" + typeName + ")" + containerEvaluateName + ")", false);
+            } else {
+                if (containerEvaluateName != null && containerEvaluateName.contains("%s")) {
+                    evaluateName = String.format(containerEvaluateName, javaVariable.evaluateName);
+                } else {
+                    evaluateName = VariableUtils.getEvaluateName(javaVariable.evaluateName, containerEvaluateName, containerNode.isIndexedVariable());
+                }
+            }
+
+            VariableProxy varProxy = null;
+            if (indexedVariables > 0 || (indexedVariables < 0 && value instanceof ObjectReference)) {
+                varProxy = new VariableProxy(containerNode.getThread(), containerNode.getScope(), value, containerNode, evaluateName);
+                varProxy.setIndexedVariable(indexedVariables >= 0);
+                varProxy.setUnboundedType(javaVariable.isUnboundedType());
+            }
+
+            boolean hasErrors = false;
+            String valueString = null;
+            try {
+                valueString = variableFormatter.valueToString(value, options);
+            } catch (OutOfMemoryError e) {
+                hasErrors = true;
+                logger.log(Level.SEVERE, "Failed to convert the value of a large object to a string", e);
+                valueString = "<Unable to display the value of a large object>";
+            } catch (Exception e) {
+                hasErrors = true;
+                logger.log(Level.SEVERE, "Failed to resolve the variable value", e);
+                valueString = "<Failed to resolve the variable value due to \"" + e.getMessage() + "\">";
+            }
+
+            String typeString = "";
+            try {
+                typeString = variableFormatter.typeToString(value == null ? null : value.type(), options);
+            } catch (Exception e) {
+                logger.log(Level.SEVERE, "Failed to resolve the variable type", e);
+                typeString = "";
+            }
+
+            String detailsValue = null;
+            if (hasErrors) {
+                // If failed to resolve the variable value, skip the details info as well.
+            } else if (sizeValue != null) {
+                detailsValue = "size=" + variableFormatter.valueToString(sizeValue, options);
+            } else if (supportsToStringView(context)) {
+                if (VariableDetailUtils.isLazyLoadingSupported(value) && varProxy != null) {
+                    varProxy.setLazyVariable(true);
+                } else {
+                    try {
+                        detailsValue = VariableDetailUtils.formatDetailsValue(value, containerNode.getThread(), variableFormatter, options, evaluationEngine);
+                    } catch (OutOfMemoryError e) {
+                        logger.log(Level.SEVERE, "Failed to compute the toString() value of a large object", e);
+                        detailsValue = "<Unable to display the details of a large object>";
+                    } catch (Exception e) {
+                        logger.log(Level.SEVERE, "Failed to compute the toString() value", e);
+                        detailsValue = "<Failed to resolve the variable details due to \"" + e.getMessage() + "\">";
+                    }
+                }
+            }
+
             int referenceId = 0;
-            if (value instanceof ObjectReference && VariableUtils.hasChildren(value, showStaticVariables)) {
-                VariableProxy varProxy = new VariableProxy(containerNode.getThreadId(), containerNode.getScope(), value);
+            if (varProxy != null) {
                 referenceId = context.getRecyclableIdPool().addObject(containerNode.getThreadId(), varProxy);
             }
-            Types.Variable typedVariables = new Types.Variable(name, variableFormatter.valueToString(value, options),
-                    variableFormatter.typeToString(value == null ? null : value.type(), options), referenceId, null);
-            if (javaVariable.value instanceof ArrayReference) {
-                typedVariables.indexedVariables = ((ArrayReference) javaVariable.value).length();
+
+            String[] rawAttributes = extractAttributes(javaVariable);
+
+            Types.Variable typedVariables = new Types.Variable(name, valueString, typeString, referenceId, evaluateName);
+            typedVariables.indexedVariables = Math.max(indexedVariables, 0);
+            if ((varProxy != null && varProxy.isLazyVariable()) || (rawAttributes.length > 0)) {
+                typedVariables.presentationHint = new VariablePresentationHint(varProxy != null && varProxy.isLazyVariable(), rawAttributes);
+            }
+
+            if (detailsValue != null) {
+                typedVariables.value = typedVariables.value + " " + detailsValue;
             }
             list.add(typedVariables);
         }
+
+        if (list.isEmpty() && containerNode.getProxiedVariable() instanceof ObjectReference) {
+            list.add(new Types.Variable("Class has no fields", "", null, 0, null));
+        }
+
         response.body = new Responses.VariablesResponseBody(list);
+
+        return CompletableFuture.completedFuture(response);
+    }
+
+    private String[] extractAttributes(Variable variable) {
+        final List<String> attributes = new ArrayList<>();
+        if (variable.field != null) {
+            if (variable.field.isStatic()) {
+                attributes.add("static");
+            }
+            if (variable.field.isFinal()) {
+                // static final Primitive or StringRef fields are compile-time constants in Java
+                boolean isPrimitive;
+                try {
+                    isPrimitive = variable.field.type() instanceof PrimitiveType;
+                } catch (ClassNotLoadedException e) { /* type() not yet loaded indicates some ReferenceType */
+                    isPrimitive = false;
+                }
+                boolean canBeTrueConstant = (isPrimitive || variable.field instanceof StringReference);
+                if (variable.field.isStatic() && canBeTrueConstant) {
+                    attributes.add("constant");
+                }
+                attributes.add("readOnly");
+            }
+        }
+        // local 'final' variables get inlined by the compiler and do not appear
+
+        if (variable.value instanceof StringReference) {
+            attributes.add("rawString");
+        }
+
+        return attributes.toArray(new String[0]);
+    }
+
+    private boolean supportsLogicStructureView(IDebugAdapterContext context) {
+        return (!useAsyncJDWP(context) || context.getJDWPLatency() <= USABLE_JDWP_LATENCY)
+            && DebugSettings.getCurrent().showLogicalStructure;
+    }
+
+    private boolean supportsToStringView(IDebugAdapterContext context) {
+        return (!useAsyncJDWP(context) || context.getJDWPLatency() <= USABLE_JDWP_LATENCY)
+            && DebugSettings.getCurrent().showToString;
+    }
+
+    private boolean useAsyncJDWP(IDebugAdapterContext context) {
+        return context.asyncJDWP(USABLE_JDWP_LATENCY);
+    }
+
+    private Types.Variable resolveLazyVariable(IDebugAdapterContext context, VariableProxy containerNode, IVariableFormatter variableFormatter,
+            Map<String, Object> options, IEvaluationProvider evaluationEngine) {
+        VariableProxy valueReferenceProxy = new VariableProxy(containerNode.getThread(), containerNode.getScope(),
+            containerNode.getProxiedVariable(), null /** container */, containerNode.getEvaluateName());
+        valueReferenceProxy.setIndexedVariable(containerNode.isIndexedVariable());
+        valueReferenceProxy.setUnboundedType(containerNode.isUnboundedType());
+        int referenceId = context.getRecyclableIdPool().addObject(containerNode.getThreadId(), valueReferenceProxy);
+        // this proxiedVariable is intermediate object, see https://github.com/microsoft/vscode/issues/135147#issuecomment-1076240074
+        Object proxiedVariable = containerNode.getProxiedVariable();
+        if (proxiedVariable instanceof ObjectReference) {
+            ObjectReference variable = (ObjectReference) proxiedVariable;
+            String valueString = variableFormatter.valueToString(variable, options);
+            String detailString = VariableDetailUtils.formatDetailsValue(variable, containerNode.getThread(), variableFormatter, options,
+                evaluationEngine);
+            return new Types.Variable("", valueString + " " + detailString, "", referenceId, containerNode.getEvaluateName());
+        }
+        return null;
     }
 
     private Set<String> getDuplicateNames(Collection<String> list) {
@@ -190,4 +471,74 @@ private Set<String> getDuplicateNames(Collection<String> list) {
         }
         return result;
     }
+
+    private List<Variable> getVariablesOfFrameAsync(StackFrame frame, boolean showStaticVariables) {
+        CompletableFuture<List<Variable>> localVariables = VariableUtils.listLocalVariablesAsync(frame);
+        CompletableFuture<Variable> thisVariable = VariableUtils.getThisVariableAsync(frame);
+        CompletableFuture<List<Variable>>[] staticVariables = new CompletableFuture[1];
+        if (showStaticVariables && frame.location().method().isStatic()) {
+            staticVariables[0] = VariableUtils.listStaticVariablesAsync(frame);
+        }
+
+        CompletableFuture<Void> futures = staticVariables[0] == null ? CompletableFuture.allOf(localVariables, thisVariable)
+            : CompletableFuture.allOf(localVariables, thisVariable, staticVariables[0]);
+
+        AsyncJdwpUtils.await(futures);
+
+        List<Variable> result = new ArrayList<>();
+        result.addAll(localVariables.join());
+        Variable thisVar = thisVariable.join();
+        if (thisVar != null) {
+            result.add(thisVar);
+        }
+
+        if (staticVariables[0] != null) {
+            result.addAll(staticVariables[0].join());
+        }
+
+        return result;
+    }
+
+    private CompletableFuture<Void> warmUpJDICache(List<Variable> variables, List<Variable> duplicatedVars) {
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        if (duplicatedVars != null && !duplicatedVars.isEmpty()) {
+            Set<Type> declaringTypes = new HashSet<>();
+            duplicatedVars.forEach((var) -> {
+                Type declarationType = var.getDeclaringType();
+                if (declarationType != null) {
+                    declaringTypes.add(declarationType);
+                }
+            });
+
+            for (Type type : declaringTypes) {
+                if (type instanceof ReferenceType) {
+                    // JDWP Command: RT_SIGNATURE
+                    futures.add(AsyncJdwpUtils.runAsync(() -> type.signature()));
+                }
+            }
+        }
+
+        for (Variable javaVariable : variables) {
+            Value value = javaVariable.value;
+            if (value instanceof ArrayReference) {
+                // JDWP Command: AR_LENGTH
+                futures.add(AsyncJdwpUtils.runAsync(() -> ((ArrayReference) value).length()));
+            } else if (value instanceof StringReference) {
+                // JDWP Command: SR_VALUE
+                futures.add(AsyncJdwpUtils.runAsync(() -> {
+                    String strValue = ((StringReference) value).value();
+                    javaVariable.value = new StringReferenceProxy((StringReference) value, strValue);
+                }));
+            }
+
+            if (value instanceof ObjectReference) {
+                // JDWP Command: OR_REFERENCE_TYPE, RT_SIGNATURE
+                futures.add(AsyncJdwpUtils.runAsync(() -> {
+                    value.type().signature();
+                }));
+            }
+        }
+
+        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/JavaLogicalStructure.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/JavaLogicalStructure.java
new file mode 100644
index 000000000..0d065cf51
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/JavaLogicalStructure.java
@@ -0,0 +1,235 @@
+/*******************************************************************************
+ * Copyright (c) 2019-2020 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.variables;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.sun.jdi.ClassType;
+import com.sun.jdi.Field;
+import com.sun.jdi.InterfaceType;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.Type;
+import com.sun.jdi.Value;
+
+public class JavaLogicalStructure {
+    // The binary type name. For inner type, the binary name uses '$' as the separator, e.g. java.util.Map$Entry.
+    private final String type;
+    // The fully qualified name, which uses '.' as the separator, e.g. java.util.Map.Entry.
+    private final String fullyQualifiedName;
+    private final LogicalStructureExpression valueExpression;
+    private final LogicalStructureExpression sizeExpression;
+    private final LogicalVariable[] variables;
+    // Indicates whether the specified type is an interface.
+    private final boolean isInterface;
+
+    /**
+     * Constructor.
+     */
+    public JavaLogicalStructure(String type, LogicalStructureExpression valueExpression, LogicalStructureExpression sizeExpression,
+            LogicalVariable[] variables) {
+        this(type, type, valueExpression, sizeExpression, variables);
+    }
+
+    /**
+     * Constructor.
+     */
+    public JavaLogicalStructure(String type, String fullyQualifiedName, LogicalStructureExpression valueExpression, LogicalStructureExpression sizeExpression,
+            LogicalVariable[] variables) {
+        this(type, type, true, valueExpression, sizeExpression, variables);
+    }
+
+    public JavaLogicalStructure(String type, String fullyQualifiedName, boolean isInterface, LogicalStructureExpression valueExpression,
+        LogicalStructureExpression sizeExpression, LogicalVariable[] variables) {
+        this.valueExpression = valueExpression;
+        this.type = type;
+        this.fullyQualifiedName = fullyQualifiedName;
+        this.isInterface = isInterface;
+        this.sizeExpression = sizeExpression;
+        this.variables = variables;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public String getFullyQualifiedName() {
+        return fullyQualifiedName;
+    }
+
+    public LogicalStructureExpression getValueExpression() {
+        return valueExpression;
+    }
+
+    public LogicalStructureExpression getSizeExpression() {
+        return sizeExpression;
+    }
+
+    public LogicalVariable[] getVariables() {
+        return variables;
+    }
+
+    /**
+     * Returns whether to support the logical structure view for the given object instance.
+     */
+    public boolean providesLogicalStructure(ObjectReference obj) {
+        Type variableType = obj.type();
+        if (!(variableType instanceof ClassType)) {
+            return false;
+        }
+
+        ClassType classType = (ClassType) variableType;
+        if (Objects.equals(type, classType.name())) {
+            return true;
+        }
+
+        if (isInterface) {
+            List<InterfaceType> interfaceTypes = ((ClassType) variableType).allInterfaces();
+            for (InterfaceType interfaceType : interfaceTypes) {
+                if (Objects.equals(type, interfaceType.name())) {
+                    return true;
+                }
+            }
+        } else {
+            while (classType != null) {
+                if (Objects.equals(type, classType.name())) {
+                    return true;
+                }
+
+                classType = classType.superclass();
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Return the logical size of the specified thisObject.
+     */
+    public Value getSize(ObjectReference thisObject, ThreadReference thread, IEvaluationProvider evaluationEngine)
+            throws CancellationException, InterruptedException, IllegalArgumentException, ExecutionException, UnsupportedOperationException {
+        if (sizeExpression  == null) {
+            throw new UnsupportedOperationException("The object hasn't defined the logical size operation.");
+        }
+
+        return getValue(thisObject, sizeExpression, thread, evaluationEngine);
+    }
+
+    /**
+     * Return the logical value of the specified thisObject.
+     */
+    public Value getValue(ObjectReference thisObject, ThreadReference thread, IEvaluationProvider evaluationEngine)
+            throws CancellationException, IllegalArgumentException, InterruptedException, ExecutionException {
+        return getValue(thisObject, valueExpression, thread, evaluationEngine);
+    }
+
+    private static Value getValue(ObjectReference thisObject, LogicalStructureExpression expression, ThreadReference thread,
+            IEvaluationProvider evaluationEngine) throws CancellationException, IllegalArgumentException, InterruptedException, ExecutionException {
+        if (expression.type == LogicalStructureExpressionType.METHOD) {
+            if (expression.value == null || expression.value.length < 2) {
+                throw new IllegalArgumentException("The method expression should contain at least methodName and methodSignature!");
+            }
+            return evaluationEngine.invokeMethod(thisObject, expression.value[0], expression.value[1], null, thread, false).get();
+        } else if (expression.type == LogicalStructureExpressionType.FIELD) {
+            if (expression.value == null || expression.value.length < 1) {
+                throw new IllegalArgumentException("The field expression should contain the field name!");
+            }
+            return getValueByField(thisObject, expression.value[0], thread);
+        } else {
+            if (expression.value == null || expression.value.length < 1) {
+                throw new IllegalArgumentException("The evaluation expression should contain a valid expression statement!");
+            }
+            return evaluationEngine.evaluate(expression.value[0], thisObject, thread).get();
+        }
+    }
+
+    private static Value getValueByField(ObjectReference thisObject, String fieldName, ThreadReference thread) {
+        Field targetField = thisObject.referenceType().fieldByName(fieldName);
+        if (targetField == null) {
+            return null;
+        }
+
+        return thisObject.getValue(targetField);
+    }
+
+    public static class LogicalVariable {
+        private final String name;
+        private final LogicalStructureExpression valueExpression;
+
+        public LogicalVariable(String name, LogicalStructureExpression valueExpression) {
+            this.name = name;
+            this.valueExpression = valueExpression;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public Value getValue(ObjectReference thisObject, ThreadReference thread, IEvaluationProvider evaluationEngine)
+                throws CancellationException, IllegalArgumentException, InterruptedException, ExecutionException {
+            return JavaLogicalStructure.getValue(thisObject, valueExpression, thread, evaluationEngine);
+        }
+
+        public String getEvaluateName() {
+            if (valueExpression == null || valueExpression.evaluateName == null) {
+                return name;
+            }
+
+            return valueExpression.evaluateName;
+        }
+
+        public boolean returnUnboundedType() {
+            return valueExpression != null && valueExpression.returnUnboundedType;
+        }
+    }
+
+    public static class LogicalStructureExpression {
+        public LogicalStructureExpressionType type;
+        public String[] value;
+        public String evaluateName;
+        public boolean returnUnboundedType = false;
+
+        /**
+         *  Constructor.
+         */
+        public LogicalStructureExpression(LogicalStructureExpressionType type, String[] value) {
+            this(type, value, null);
+        }
+
+        /**
+         *  Constructor.
+         */
+        public LogicalStructureExpression(LogicalStructureExpressionType type, String[] value, String evaluateName) {
+            this.type = type;
+            this.value = value;
+            this.evaluateName = evaluateName;
+        }
+
+        /**
+         *  Constructor.
+         */
+        public LogicalStructureExpression(LogicalStructureExpressionType type, String[] value, String evaluateName, boolean returnUnboundedType) {
+            this.type = type;
+            this.value = value;
+            this.evaluateName = evaluateName;
+            this.returnUnboundedType = returnUnboundedType;
+        }
+    }
+
+    public static enum LogicalStructureExpressionType {
+        FIELD, METHOD, EVALUATION_SNIPPET
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/JavaLogicalStructureManager.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/JavaLogicalStructureManager.java
new file mode 100644
index 000000000..2762173cd
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/JavaLogicalStructureManager.java
@@ -0,0 +1,92 @@
+/*******************************************************************************
+ * Copyright (c) 2019-2020 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.variables;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructure.LogicalStructureExpression;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructure.LogicalStructureExpressionType;
+import com.microsoft.java.debug.core.adapter.variables.JavaLogicalStructure.LogicalVariable;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.Value;
+
+public class JavaLogicalStructureManager {
+    private static final List<JavaLogicalStructure> supportedLogicalStructures = Collections.synchronizedList(new ArrayList<>());
+
+    static {
+        supportedLogicalStructures.add(new JavaLogicalStructure("java.util.Map",
+            new LogicalStructureExpression(LogicalStructureExpressionType.METHOD, new String[] {"entrySet", "()Ljava/util/Set;"}, "entrySet()"),
+            new LogicalStructureExpression(LogicalStructureExpressionType.METHOD, new String[] {"size", "()I"}),
+            new LogicalVariable[0]
+        ));
+        supportedLogicalStructures.add(new JavaLogicalStructure("java.util.Map$Entry", "java.util.Map.Entry", null, null,
+            new LogicalVariable[] {
+                new LogicalVariable("key",
+                    new LogicalStructureExpression(LogicalStructureExpressionType.METHOD, new String[] {"getKey", "()Ljava/lang/Object;"}, "getKey()", true)
+                ),
+                new LogicalVariable("value",
+                    new LogicalStructureExpression(LogicalStructureExpressionType.METHOD,
+                        new String[] {"getValue", "()Ljava/lang/Object;"}, "getValue()", true)
+                )}
+        ));
+        supportedLogicalStructures.add(new JavaLogicalStructure("java.util.List",
+            new LogicalStructureExpression(LogicalStructureExpressionType.METHOD, new String[] {"toArray", "()[Ljava/lang/Object;"}, "get(%s)", true),
+            new LogicalStructureExpression(LogicalStructureExpressionType.METHOD, new String[] {"size", "()I"}),
+            new LogicalVariable[0]
+        ));
+        supportedLogicalStructures.add(new JavaLogicalStructure("java.util.Collection",
+            new LogicalStructureExpression(LogicalStructureExpressionType.METHOD, new String[] {"toArray", "()[Ljava/lang/Object;"}, "toArray()", true),
+            new LogicalStructureExpression(LogicalStructureExpressionType.METHOD, new String[] {"size", "()I"}),
+            new LogicalVariable[0]
+        ));
+    }
+
+    /**
+     * Return the provided logical structure handler for the given variable.
+     */
+    public static JavaLogicalStructure getLogicalStructure(ObjectReference obj) {
+        for (JavaLogicalStructure structure : supportedLogicalStructures) {
+            if (structure.providesLogicalStructure(obj)) {
+                return structure;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Return true if the specified Object has defined the logical size.
+     */
+    public static boolean isIndexedVariable(ObjectReference obj) {
+        JavaLogicalStructure structure = getLogicalStructure(obj);
+        return structure != null && structure.getSizeExpression() != null;
+    }
+
+    /**
+     * Return the logical size if the specified Object has defined the logical size.
+     */
+    public static Value getLogicalSize(ObjectReference thisObject, ThreadReference thread, IEvaluationProvider evaluationEngine)
+            throws CancellationException, InterruptedException, IllegalArgumentException, ExecutionException, UnsupportedOperationException {
+        JavaLogicalStructure structure = getLogicalStructure(thisObject);
+        if (structure == null) {
+            return null;
+        }
+
+        return structure.getSize(thisObject, thread, evaluationEngine);
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/JdiObjectProxy.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/JdiObjectProxy.java
deleted file mode 100644
index 85074879d..000000000
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/JdiObjectProxy.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2017 Microsoft Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Microsoft Corporation - initial API and implementation
- *******************************************************************************/
-
-package com.microsoft.java.debug.core.adapter.variables;
-
-import java.util.Objects;
-
-public class JdiObjectProxy<T> {
-    private final T object;
-    private final int hashCode;
-
-
-    /**
-     * Create a jdi object proxy.
-     *
-     * @param object the underling jdi object
-     */
-    public JdiObjectProxy(T object) {
-        if (object == null) {
-            throw new IllegalArgumentException("Null object is illegal for JdiObjectProxy.");
-        }
-        this.object = object;
-        this.hashCode = object.hashCode();
-
-    }
-
-    @Override
-    public String toString() {
-        return String.valueOf(getProxiedObject());
-    }
-
-    @Override
-    public int hashCode() {
-        return hashCode;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (!(o instanceof JdiObjectProxy)) {
-            return false;
-        }
-        final JdiObjectProxy<?> other = (JdiObjectProxy<?>) o;
-        return Objects.equals(this.getProxiedObject(), other.getProxiedObject());
-    }
-
-    public T getProxiedObject() {
-        return object;
-    }
-
-}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/StackFrameReference.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/StackFrameReference.java
new file mode 100644
index 000000000..46726cde8
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/StackFrameReference.java
@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.variables;
+
+import com.microsoft.java.debug.core.protocol.Types.Source;
+import com.sun.jdi.ThreadReference;
+
+public class StackFrameReference {
+    private final int depth;
+    private final int hash;
+    private final ThreadReference thread;
+    private Source source;
+
+    /**
+     * Create a wrapper of JDI stackframe to keep the immutable properties of a stackframe, IStackFrameManager will use
+     * these properties to construct a jdi stackframe.
+     *
+     * @param thread the jdi thread.
+     * @param depth
+     *            the index of this stackframe inside all frames inside one stopped
+     *            thread
+     */
+    public StackFrameReference(ThreadReference thread, int depth) {
+        if (thread == null) {
+            throw new NullPointerException("'thread' should not be null for StackFrameReference");
+        }
+
+        if (depth < 0) {
+            throw new IllegalArgumentException("'depth' should not be zero or an positive integer.");
+        }
+        this.thread = thread;
+        this.depth = depth;
+        hash = Long.hashCode(thread.hashCode()) + depth;
+    }
+
+    public int getDepth() {
+        return depth;
+    }
+
+    public ThreadReference getThread() {
+        return thread;
+    }
+
+    public Source getSource() {
+        return source;
+    }
+
+    public void setSource(Source source) {
+        this.source = source;
+    }
+
+    @Override
+    public int hashCode() {
+        return hash;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (obj.getClass() != this.getClass()) {
+            return false;
+        }
+        if (this == obj) {
+            return true;
+        }
+        StackFrameReference sf = (StackFrameReference) obj;
+        return thread.equals(sf.thread) && depth == sf.depth;
+    }
+
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/StringReferenceProxy.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/StringReferenceProxy.java
new file mode 100644
index 000000000..82c4da56e
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/StringReferenceProxy.java
@@ -0,0 +1,121 @@
+/*******************************************************************************
+ * Copyright (c) 2022 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.variables;
+
+import java.util.List;
+import java.util.Map;
+
+import com.sun.jdi.ClassNotLoadedException;
+import com.sun.jdi.Field;
+import com.sun.jdi.IncompatibleThreadStateException;
+import com.sun.jdi.InvalidTypeException;
+import com.sun.jdi.InvocationException;
+import com.sun.jdi.Method;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.StringReference;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.Type;
+import com.sun.jdi.Value;
+import com.sun.jdi.VirtualMachine;
+
+public class StringReferenceProxy implements StringReference {
+    private StringReference delegateStringRef;
+    private String value = null;
+
+    public StringReferenceProxy(StringReference sr, String value) {
+        this.delegateStringRef = sr;
+        this.value = value;
+    }
+
+    public String value() {
+        if (value != null) {
+            return value;
+        }
+
+        return delegateStringRef.value();
+    }
+
+    public ReferenceType referenceType() {
+        return delegateStringRef.referenceType();
+    }
+
+    public VirtualMachine virtualMachine() {
+        return delegateStringRef.virtualMachine();
+    }
+
+    public String toString() {
+        return delegateStringRef.toString();
+    }
+
+    public Value getValue(Field sig) {
+        return delegateStringRef.getValue(sig);
+    }
+
+    public Map<Field, Value> getValues(List<? extends Field> fields) {
+        return delegateStringRef.getValues(fields);
+    }
+
+    public void setValue(Field field, Value value) throws InvalidTypeException, ClassNotLoadedException {
+        delegateStringRef.setValue(field, value);
+    }
+
+    public Value invokeMethod(ThreadReference thread, Method method, List<? extends Value> arguments, int options)
+            throws InvalidTypeException, ClassNotLoadedException, IncompatibleThreadStateException,
+            InvocationException {
+        return delegateStringRef.invokeMethod(thread, method, arguments, options);
+    }
+
+    public Type type() {
+        return delegateStringRef.type();
+    }
+
+    public void disableCollection() {
+        delegateStringRef.disableCollection();
+    }
+
+    public void enableCollection() {
+        delegateStringRef.enableCollection();
+    }
+
+    public boolean isCollected() {
+        return delegateStringRef.isCollected();
+    }
+
+    public long uniqueID() {
+        return delegateStringRef.uniqueID();
+    }
+
+    public List<ThreadReference> waitingThreads() throws IncompatibleThreadStateException {
+        return delegateStringRef.waitingThreads();
+    }
+
+    public ThreadReference owningThread() throws IncompatibleThreadStateException {
+        return delegateStringRef.owningThread();
+    }
+
+    public int entryCount() throws IncompatibleThreadStateException {
+        return delegateStringRef.entryCount();
+    }
+
+    public List<ObjectReference> referringObjects(long maxReferrers) {
+        return delegateStringRef.referringObjects(maxReferrers);
+    }
+
+    public boolean equals(Object obj) {
+        return delegateStringRef.equals(obj);
+    }
+
+    public int hashCode() {
+        return delegateStringRef.hashCode();
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/Variable.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/Variable.java
index e2a6efc2a..559e62b29 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/Variable.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/Variable.java
@@ -13,6 +13,8 @@
 
 import org.apache.commons.lang3.StringUtils;
 
+import java.util.Objects;
+
 import com.sun.jdi.Field;
 import com.sun.jdi.LocalVariable;
 import com.sun.jdi.Type;
@@ -61,18 +63,39 @@ public class Variable {
      */
     public int argumentIndex;
 
+    /**
+     * The variable evaluate name for the container context. Defaults to the variable name.
+     */
+    public String evaluateName;
+
+    /**
+     * Indicates whether this variable's type is determined at runtime.
+     */
+    private boolean isUnboundedType = false;
+
     /**
      * The constructor of <code>JavaVariable</code>.
      * @param name the name of this variable.
      * @param value the JDI value
      */
     public Variable(String name, Value value) {
+        this(name, value, name);
+    }
+
+    /**
+     * The constructor of <code>JavaVariable</code>.
+     * @param name the name of this variable.
+     * @param value the JDI value
+     * @param evaluateName the variable evaluate name for the container context if any
+     */
+    public Variable(String name, Value value, String evaluateName) {
         if (StringUtils.isBlank(name)) {
             throw new IllegalArgumentException("Name is required for a java variable.");
         }
         this.name = name;
         this.value = value;
         this.argumentIndex = -1;
+        this.evaluateName = evaluateName;
     }
 
     /**
@@ -86,4 +109,16 @@ public Type getDeclaringType() {
         }
         return null;
     }
+
+    public void setUnboundedType(boolean isUnboundedType) {
+        this.isUnboundedType = isUnboundedType;
+    }
+
+    public boolean isUnboundedType() {
+        if (isUnboundedType) {
+            return true;
+        }
+
+        return field != null && Objects.equals(field.signature(), "Ljava/lang/Object;");
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableDetailUtils.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableDetailUtils.java
new file mode 100644
index 000000000..3fd060625
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableDetailUtils.java
@@ -0,0 +1,178 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.adapter.variables;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.sun.jdi.ClassType;
+import com.sun.jdi.InterfaceType;
+import com.sun.jdi.Method;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.Type;
+import com.sun.jdi.Value;
+
+public class VariableDetailUtils {
+    private static final String STRING_TYPE = "java.lang.String";
+    private static final String TO_STRING_METHOD = "toString";
+    private static final String TO_STRING_METHOD_SIGNATURE = "()Ljava/lang/String;";
+    private static final String ENTRY_TYPE = "java.util.Map$Entry";
+    private static final String GET_KEY_METHOD = "getKey";
+    private static final String GET_KEY_METHOD_SIGNATURE = "()Ljava/lang/Object;";
+    private static final String GET_VALUE_METHOD = "getValue";
+    private static final String GET_VALUE_METHOD_SIGNATURE = "()Ljava/lang/Object;";
+    private static final Set<String> COLLECTION_TYPES = new HashSet(
+            Arrays.asList("java.util.Map", "java.util.Collection", "java.util.Map$Entry"));
+
+    /**
+     * Returns the details information for the specified variable.
+     */
+    public static String formatDetailsValue(Value value, ThreadReference thread, IVariableFormatter variableFormatter, Map<String, Object> options,
+            IEvaluationProvider evaluationEngine) {
+        if (isClassType(value, STRING_TYPE)) {
+            // No need to show additional details information.
+            return null;
+        } else {
+            return computeToStringValue(value, thread, variableFormatter, options, evaluationEngine, true);
+        }
+    }
+
+    private static String computeToStringValue(Value value, ThreadReference thread, IVariableFormatter variableFormatter,
+            Map<String, Object> options, IEvaluationProvider evaluationEngine, boolean isFirstLevel) {
+        if (!(value instanceof ObjectReference) || evaluationEngine == null) {
+            return null;
+        }
+
+        String inheritedType = findInheritedType(value, COLLECTION_TYPES);
+        if (inheritedType != null) {
+            if (Objects.equals(inheritedType, ENTRY_TYPE)) {
+                try {
+                    Value keyObject = evaluationEngine.invokeMethod((ObjectReference) value, GET_KEY_METHOD, GET_KEY_METHOD_SIGNATURE,
+                            null, thread, false).get();
+                    Value valueObject = evaluationEngine.invokeMethod((ObjectReference) value, GET_VALUE_METHOD, GET_VALUE_METHOD_SIGNATURE,
+                            null, thread, false).get();
+                    String toStringValue = computeToStringValue(keyObject, thread, variableFormatter, options, evaluationEngine, false)
+                            + ":"
+                            + computeToStringValue(valueObject, thread, variableFormatter, options, evaluationEngine, false);
+                    if (!isFirstLevel) {
+                        toStringValue = "\"" + toStringValue + "\"";
+                    }
+
+                    return toStringValue;
+                } catch (InterruptedException | ExecutionException e) {
+                    // do nothing.
+                }
+            } else if (!isFirstLevel) {
+                return variableFormatter.valueToString(value, options);
+            }
+        } else if (containsToStringMethod((ObjectReference) value)) {
+            try {
+                Value toStringValue = evaluationEngine.invokeMethod((ObjectReference) value, TO_STRING_METHOD, TO_STRING_METHOD_SIGNATURE,
+                        null, thread, false).get();
+                return variableFormatter.valueToString(toStringValue, options);
+            } catch (InterruptedException | ExecutionException e) {
+                // do nothing.
+            }
+        }
+
+        return null;
+    }
+
+    private static boolean containsToStringMethod(ObjectReference obj) {
+        ReferenceType refType = obj.referenceType();
+        if (refType instanceof ClassType) {
+            Method m = ((ClassType) refType).concreteMethodByName(TO_STRING_METHOD, TO_STRING_METHOD_SIGNATURE);
+            if (m != null) {
+                if (!Objects.equals("Ljava/lang/Object;", m.declaringType().signature())) {
+                    return true;
+                }
+            }
+
+            for (InterfaceType iface : ((ClassType) refType).allInterfaces()) {
+                List<Method> matches = iface.methodsByName(TO_STRING_METHOD, TO_STRING_METHOD_SIGNATURE);
+                for (Method ifaceMethod : matches) {
+                    if (!ifaceMethod.isAbstract()) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private static String findInheritedType(Value value, Set<String> typeNames) {
+        if (!(value instanceof ObjectReference)) {
+            return null;
+        }
+
+        Type variableType = ((ObjectReference) value).type();
+        if (!(variableType instanceof ClassType)) {
+            return null;
+        }
+
+        ClassType classType = (ClassType) variableType;
+        while (classType != null) {
+            if (typeNames.contains(classType.name())) {
+                return classType.name();
+            }
+
+            classType = classType.superclass();
+        }
+
+        List<InterfaceType> interfaceTypes = ((ClassType) variableType).allInterfaces();
+        for (InterfaceType interfaceType : interfaceTypes) {
+            if (typeNames.contains(interfaceType.name())) {
+                return interfaceType.name();
+            }
+        }
+
+        return null;
+    }
+
+    private static boolean isClassType(Value value, String typeName) {
+        if (!(value instanceof ObjectReference)) {
+            return false;
+        }
+
+        return Objects.equals(((ObjectReference) value).type().name(), typeName);
+    }
+
+    public static boolean isLazyLoadingSupported(Value value) {
+        if (isClassType(value, STRING_TYPE)) {
+            return false;
+        }
+        if (!(value instanceof ObjectReference)) {
+            return false;
+        }
+        String inheritedType = findInheritedType(value, COLLECTION_TYPES);
+        // Map.Entry should not use lazy loading because its details computation
+        // (getKey + getValue) is lightweight and showing "key:value" inline
+        // significantly improves UX for large Maps. See
+        // https://github.com/microsoft/vscode-java-debug/issues/1605
+        if (Objects.equals(inheritedType, ENTRY_TYPE)) {
+            return false;
+        }
+        if (inheritedType == null && !containsToStringMethod((ObjectReference) value)) {
+            return false;
+        }
+        return true;
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableProxy.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableProxy.java
index af78fb74e..5ebf93735 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableProxy.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableProxy.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2020 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -13,31 +13,49 @@
 
 import java.util.Objects;
 
+import com.sun.jdi.ThreadReference;
+
 public class VariableProxy {
-    private final long threadId;
+    private final ThreadReference thread;
     private final String scopeName;
     private Object variable;
     private int hashCode;
+    // The variable evaluate expression which can be passed to 'EvaluateRequest' to fetch this variable.
+    private final String evaluateName;
+    private boolean isIndexedVariable;
+    private boolean isUnboundedType = false;
+    private boolean isLazyVariable = false;
 
     /**
-     * Create a variable proxy.
-     * @param threadId
-     *              the context thread id
+     * Create a variable reference.
+     *
+     * @param thread the jdi thread
      * @param scopeName
      *              the scope name
      * @param variable
      *              the variable object
+     * @param container
+     *              the variable container, if any
+     * @param evaluateName
+     *              the variable evaluate expression which can be passed to 'EvaluateRequest' to
+     *              fetch this variable, if any
      */
-    public VariableProxy(long threadId, String scopeName, Object variable) {
-        this.threadId = threadId;
+    public VariableProxy(ThreadReference thread, String scopeName, Object variable, VariableProxy container, String evaluateName) {
+        this.thread = thread;
         this.scopeName = scopeName;
         this.variable = variable;
-        this.hashCode = (int) (threadId & scopeName.hashCode() & variable.hashCode());
+        this.evaluateName = evaluateName;
+
+        hashCode = Objects.hash(scopeName, thread, variable, evaluateName);
     }
 
     @Override
     public String toString() {
-        return String.format("%s %s", String.valueOf(this.variable), this.scopeName);
+        return String.format("%s %s", String.valueOf(variable), scopeName);
+    }
+
+    public ThreadReference getThread() {
+        return thread;
     }
 
     @Override
@@ -46,25 +64,60 @@ public int hashCode() {
     }
 
     @Override
-    public boolean equals(Object o) {
-        if (!(o instanceof VariableProxy)) {
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
             return false;
         }
-        final VariableProxy other = (VariableProxy) o;
-        return this.getThreadId() == other.getThreadId()
-                && Objects.equals(this.getScope(), other.getScope())
-                && Objects.equals(this.getProxiedVariable(), other.getProxiedVariable());
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        VariableProxy other = (VariableProxy) obj;
+        return Objects.equals(scopeName, other.scopeName) && Objects.equals(getThreadId(), other.getThreadId())
+                && Objects.equals(variable, other.variable) && Objects.equals(evaluateName, other.evaluateName)
+                && Objects.equals(isLazyVariable, other.isLazyVariable);
     }
 
     public long getThreadId() {
-        return this.threadId;
+        return thread.uniqueID();
     }
 
     public String getScope() {
-        return this.scopeName;
+        return scopeName;
     }
 
     public Object getProxiedVariable() {
-        return this.variable;
+        return variable;
+    }
+
+    public String getEvaluateName() {
+        return evaluateName;
+    }
+
+    public boolean isIndexedVariable() {
+        return isIndexedVariable;
     }
+
+    public void setIndexedVariable(boolean isIndexedVariable) {
+        this.isIndexedVariable = isIndexedVariable;
+    }
+
+    public boolean isUnboundedType() {
+        return isUnboundedType;
+    }
+
+    public void setUnboundedType(boolean isUnboundedType) {
+        this.isUnboundedType = isUnboundedType;
+    }
+
+    public boolean isLazyVariable() {
+        return isLazyVariable;
+    }
+
+    public void setLazyVariable(boolean isLazyVariable) {
+        this.isLazyVariable = isLazyVariable;
+    }
+
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableUtils.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableUtils.java
index 1291d83d0..1a8139fa9 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableUtils.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/variables/VariableUtils.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2017 Microsoft Corporation and others.
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -12,15 +12,32 @@
 package com.microsoft.java.debug.core.adapter.variables;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
+import com.microsoft.java.debug.core.AsyncJdwpUtils;
 import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.adapter.formatter.NumericFormatEnum;
+import com.microsoft.java.debug.core.adapter.formatter.NumericFormatter;
+import com.microsoft.java.debug.core.adapter.formatter.SimpleTypeFormatter;
+import com.microsoft.java.debug.core.adapter.formatter.StringObjectFormatter;
 import com.sun.jdi.AbsentInformationException;
 import com.sun.jdi.ArrayReference;
 import com.sun.jdi.ArrayType;
+import com.sun.jdi.ClassType;
+import com.sun.jdi.InterfaceType;
 import com.sun.jdi.ClassNotLoadedException;
 import com.sun.jdi.Field;
 import com.sun.jdi.InternalException;
@@ -45,15 +62,14 @@ public abstract class VariableUtils {
      * @return true if this value is reference objects.
      */
     public static boolean hasChildren(Value value, boolean includeStatic) {
-        if (value == null) {
+        if (value == null || !(value instanceof ObjectReference)) {
             return false;
         }
-        Type type = value.type();
+        ReferenceType type = ((ObjectReference) value).referenceType();
         if (type instanceof ArrayType) {
             return ((ArrayReference) value).length() > 0;
         }
-        return value.type() instanceof ReferenceType && ((ReferenceType) type).allFields().stream()
-                .filter(t -> includeStatic || !t.isStatic()).toArray().length > 0;
+        return type.allFields().stream().anyMatch(t -> includeStatic || !t.isStatic());
     }
 
     /**
@@ -66,17 +82,23 @@ public static boolean hasChildren(Value value, boolean includeStatic) {
      *             when there is any error in retrieving information
      */
     public static List<Variable> listFieldVariables(ObjectReference obj, boolean includeStatic) throws AbsentInformationException {
+        return listFieldVariables(obj, includeStatic, false);
+    }
+
+    public static List<Variable> listFieldVariables(ObjectReference obj, boolean includeStatic, boolean async) throws AbsentInformationException {
         List<Variable> res = new ArrayList<>();
-        Type type = obj.type();
+        ReferenceType type = obj.referenceType();
         if (type instanceof ArrayType) {
             int arrayIndex = 0;
+            boolean isUnboundedArrayType = Objects.equals(type.signature(), "[Ljava/lang/Object;");
             for (Value elementValue : ((ArrayReference) obj).getValues()) {
                 Variable ele = new Variable(String.valueOf(arrayIndex++), elementValue);
+                ele.setUnboundedType(isUnboundedArrayType);
                 res.add(ele);
             }
             return res;
         }
-        List<Field> fields = obj.referenceType().allFields().stream().filter(t -> includeStatic || !t.isStatic())
+        List<Field> fields = resolveAllFields(type, async).stream().filter(t -> includeStatic || !t.isStatic())
                 .sorted((a, b) -> {
                     try {
                         boolean v1isStatic = a.isStatic();
@@ -93,11 +115,16 @@ public static List<Variable> listFieldVariables(ObjectReference obj, boolean inc
                         return -1;
                     }
                 }).collect(Collectors.toList());
-        fields.forEach(f -> {
-            Variable var = new Variable(f.name(), obj.getValue(f));
-            var.field = f;
-            res.add(var);
-        });
+
+        bulkFetchValues(fields, DebugSettings.getCurrent().limitOfVariablesPerJdwpRequest, (currentPage -> {
+            Map<Field, Value> fieldValues = obj.getValues(currentPage);
+            for (Field currentField : currentPage) {
+                Variable var = new Variable(currentField.name(), fieldValues.get(currentField));
+                var.field = currentField;
+                res.add(var);
+            }
+        }));
+
         return res;
     }
 
@@ -120,8 +147,11 @@ public static List<Variable> listFieldVariables(ObjectReference obj, int start,
         Type type = obj.type();
         if (type instanceof ArrayType) {
             int arrayIndex = start;
+            boolean isUnboundedArrayType = Objects.equals(type.signature(), "[Ljava/lang/Object;");
             for (Value elementValue : ((ArrayReference) obj).getValues(start, count)) {
-                res.add(new Variable(String.valueOf(arrayIndex++), elementValue));
+                Variable variable = new Variable(String.valueOf(arrayIndex++), elementValue);
+                variable.setUnboundedType(isUnboundedArrayType);
+                res.add(variable);
             }
             return res;
         }
@@ -143,11 +173,18 @@ public static List<Variable> listLocalVariables(StackFrame stackFrame) throws Ab
             return res;
         }
         try {
-            for (LocalVariable localVariable : stackFrame.visibleVariables()) {
-                Variable var = new Variable(localVariable.name(), stackFrame.getValue(localVariable));
-                var.local = localVariable;
-                res.add(var);
-            }
+            List<LocalVariable> visibleVariables = stackFrame.visibleVariables();
+            // When using the API StackFrame.getValues() to batch fetch the variable values, the JDI
+            // probably throws timeout exception if the variables to be passed at one time are large.
+            // So use paging to fetch the values in chunks.
+            bulkFetchValues(visibleVariables, DebugSettings.getCurrent().limitOfVariablesPerJdwpRequest, (currentPage -> {
+                Map<LocalVariable, Value> values = stackFrame.getValues(currentPage);
+                for (LocalVariable localVariable : currentPage) {
+                    Variable var = new Variable(localVariable.name(), values.get(localVariable));
+                    var.local = localVariable;
+                    res.add(var);
+                }
+            }));
         } catch (AbsentInformationException ex) {
             // avoid listing variable on native methods
 
@@ -189,6 +226,91 @@ public static List<Variable> listLocalVariables(StackFrame stackFrame) throws Ab
         return res;
     }
 
+    public static CompletableFuture<List<Variable>> listLocalVariablesAsync(StackFrame stackFrame) {
+        CompletableFuture<List<Variable>> future = new CompletableFuture<>();
+        if (stackFrame.location().method().isNative()) {
+            return CompletableFuture.completedFuture(new ArrayList<>());
+        }
+
+        AsyncJdwpUtils.supplyAsync(() -> {
+            try {
+                return stackFrame.visibleVariables();
+            } catch (AbsentInformationException ex) {
+                throw new CompletionException(ex);
+            }
+        }).thenCompose((visibleVariables) -> {
+            // When using the API StackFrame.getValues() to batch fetch the variable values, the JDI
+            // probably throws timeout exception if the variables to be passed at one time are large.
+            // So use paging to fetch the values in chunks.
+            return bulkFetchValuesAsync(visibleVariables, DebugSettings.getCurrent().limitOfVariablesPerJdwpRequest, (currentPage) -> {
+                Map<LocalVariable, Value> values = stackFrame.getValues(currentPage);
+                List<Variable> result = new ArrayList<>();
+                for (LocalVariable localVariable : currentPage) {
+                    Variable var = new Variable(localVariable.name(), values.get(localVariable));
+                    var.local = localVariable;
+                    result.add(var);
+                }
+
+                return result;
+            });
+        }).whenComplete((res, ex) -> {
+            if (ex instanceof CompletionException && ex.getCause() != null) {
+                ex = ex.getCause();
+            }
+
+            if (ex instanceof AbsentInformationException) {
+                // avoid listing variable on native methods
+                try {
+                    if (stackFrame.location().method().argumentTypes().size() == 0) {
+                        future.complete(new ArrayList<>());
+                        return;
+                    }
+                } catch (ClassNotLoadedException ex2) {
+                    // ignore since the method is hit.
+                }
+                // 1. in oracle implementations, when there is no debug information, the AbsentInformationException will be
+                // thrown, then we need to retrieve arguments from stackFrame#getArgumentValues.
+                // 2. in eclipse jdt implementations, when there is no debug information, stackFrame#visibleVariables will
+                // return some generated variables like arg0, arg1, and the stackFrame#getArgumentValues will return null
+
+                // for both scenarios, we need to handle the possible null returned by stackFrame#getArgumentValues and
+                // we need to call stackFrame.getArgumentValues get the arguments if AbsentInformationException is thrown
+                int argId = 0;
+                try {
+                    List<Value> arguments = stackFrame.getArgumentValues();
+                    if (arguments == null) {
+                        future.complete(new ArrayList<>());
+                        return;
+                    }
+
+                    List<Variable> variables = new ArrayList<>();
+                    for (Value argValue : arguments) {
+                        Variable var = new Variable("arg" + argId, argValue);
+                        var.argumentIndex = argId++;
+                        variables.add(var);
+                    }
+                    future.complete(variables);
+                } catch (InternalException ex2) {
+                    // From Oracle's forums:
+                    // This could be a JPDA bug. Unexpected JDWP Error: 32 means that an 'opaque' frame was
+                    // detected at the lower JPDA levels,
+                    // typically a native frame.
+                    if (ex2.errorCode() != 32) {
+                        throw ex2;
+                    }
+                }
+            } else if (ex != null) {
+                future.complete(new ArrayList<>());
+            } else {
+                future.complete(res.stream()
+                    .flatMap(List::stream)
+                    .collect(Collectors.toList()));
+            }
+        });
+
+        return future;
+    }
+
     /**
      * Get the this variable of an stack frame.
      *
@@ -204,6 +326,16 @@ public static Variable getThisVariable(StackFrame stackFrame) {
         return new Variable("this", thisObject);
     }
 
+    public static CompletableFuture<Variable> getThisVariableAsync(StackFrame stackFrame) {
+        return AsyncJdwpUtils.supplyAsync(() -> {
+            ObjectReference thisObject = stackFrame.thisObject();
+            if (thisObject == null) {
+                return null;
+            }
+            return new Variable("this", thisObject);
+        });
+    }
+
     /**
      * Get the static variable of an stack frame.
      *
@@ -214,14 +346,196 @@ public static Variable getThisVariable(StackFrame stackFrame) {
     public static List<Variable> listStaticVariables(StackFrame stackFrame) {
         List<Variable> res = new ArrayList<>();
         ReferenceType type = stackFrame.location().declaringType();
-        type.allFields().stream().filter(TypeComponent::isStatic).forEach(field -> {
-            Variable staticVar = new Variable(field.name(), type.getValue(field));
-            staticVar.field = field;
-            res.add(staticVar);
-        });
+        List<Field> fields = type.allFields().stream().filter(TypeComponent::isStatic).collect(Collectors.toList());
+        bulkFetchValues(fields, DebugSettings.getCurrent().limitOfVariablesPerJdwpRequest, (currentPage -> {
+            Map<Field, Value> fieldValues = type.getValues(currentPage);
+            for (Field currentField : currentPage) {
+                Variable var = new Variable(currentField.name(), fieldValues.get(currentField));
+                var.field = currentField;
+                res.add(var);
+            }
+        }));
+
         return res;
     }
 
+    public static CompletableFuture<List<Variable>> listStaticVariablesAsync(StackFrame stackFrame) {
+        CompletableFuture<List<Variable>> future = new CompletableFuture<>();
+        ReferenceType type = stackFrame.location().declaringType();
+        AsyncJdwpUtils.supplyAsync(() -> {
+            return type.allFields().stream().filter(TypeComponent::isStatic).collect(Collectors.toList());
+        }).thenCompose((fields) -> {
+            return bulkFetchValuesAsync(fields, DebugSettings.getCurrent().limitOfVariablesPerJdwpRequest, (currentPage) -> {
+                List<Variable> variables = new ArrayList<>();
+                Map<Field, Value> fieldValues = type.getValues(currentPage);
+                for (Field currentField : currentPage) {
+                    Variable var = new Variable(currentField.name(), fieldValues.get(currentField));
+                    var.field = currentField;
+                    variables.add(var);
+                }
+
+                return variables;
+            });
+        }).whenComplete((res, ex) -> {
+            if (ex instanceof CompletionException && ex.getCause() != null) {
+                ex = ex.getCause();
+            }
+
+            if (ex != null) {
+                future.complete(new ArrayList<>());
+            } else {
+                future.complete(res.stream()
+                    .flatMap(List::stream)
+                    .collect(Collectors.toList()));
+            }
+        });
+
+        return future;
+    }
+
+    /**
+     * Apply the display options for variable formatter, it is used in variable and evaluate requests, controls the display content in
+     * variable view/debug console.
+     *
+     * @param defaultOptions the initial options for adding options from user settings
+     * @param hexInArgument when request sent by vscode declare hex format explicitly, settings this parameter true to override value in DebugSettings class.
+     */
+    public static void applyFormatterOptions(Map<String, Object> defaultOptions, boolean hexInArgument) {
+        Map<String, Object> options = defaultOptions;
+        boolean showFullyQualifiedNames = DebugSettings.getCurrent().showQualifiedNames;
+        if (hexInArgument || DebugSettings.getCurrent().showHex) {
+            options.put(NumericFormatter.NUMERIC_FORMAT_OPTION, NumericFormatEnum.HEX);
+        }
+        if (showFullyQualifiedNames) {
+            options.put(SimpleTypeFormatter.QUALIFIED_CLASS_NAME_OPTION, true);
+        }
+
+        if (DebugSettings.getCurrent().maxStringLength > 0) {
+            options.put(StringObjectFormatter.MAX_STRING_LENGTH_OPTION, DebugSettings.getCurrent().maxStringLength);
+        }
+
+        if (DebugSettings.getCurrent().numericPrecision > 0) {
+            options.put(NumericFormatter.NUMERIC_PRECISION_OPTION, DebugSettings.getCurrent().numericPrecision);
+        }
+    }
+
+    /**
+     * Get the name for evaluation of variable.
+     *
+     * @param name the variable name, if any
+     * @param containerName the container name, if any
+     * @param isArrayElement is the variable an array element?
+     */
+    public static String getEvaluateName(String name, String containerName, boolean isArrayElement) {
+        if (name == null) {
+            return null;
+        }
+
+        if (isArrayElement) {
+            if (containerName == null) {
+                return null;
+            }
+
+            return String.format("%s[%s]", containerName, name);
+        }
+
+        if (containerName == null) {
+            return name;
+        }
+
+        return String.format("%s.%s", containerName, name);
+    }
+
+    private static <T> void bulkFetchValues(List<T> elements, int numberPerPage, Consumer<List<T>> consumer) {
+        int size = elements.size();
+        numberPerPage = numberPerPage < 1 ? 1 : numberPerPage;
+        int page = size / numberPerPage + Math.min(size % numberPerPage, 1);
+        for (int i = 0; i < page; i++) {
+            int pageStart = i * numberPerPage;
+            int pageEnd = Math.min(pageStart + numberPerPage, size);
+            List<T> currentPage = elements.subList(pageStart, pageEnd);
+            consumer.accept(currentPage);
+        }
+    }
+
+    private static <T, R> CompletableFuture<List<R>> bulkFetchValuesAsync(List<T> elements, int numberPerPage, Function<List<T>, R> function) {
+        int size = elements.size();
+        numberPerPage = numberPerPage < 1 ? 1 : numberPerPage;
+        int page = size / numberPerPage + Math.min(size % numberPerPage, 1);
+        List<CompletableFuture<R>> futures = new ArrayList<>();
+        for (int i = 0; i < page; i++) {
+            int pageStart = i * numberPerPage;
+            int pageEnd = Math.min(pageStart + numberPerPage, size);
+            final List<T> currentPage = elements.subList(pageStart, pageEnd);
+            futures.add(AsyncJdwpUtils.supplyAsync(() -> {
+                return function.apply(currentPage);
+            }));
+        }
+
+        return AsyncJdwpUtils.all(futures);
+    }
+
+    private static List<Field> resolveAllFields(ReferenceType type, boolean async) {
+        if (async) {
+            return resolveAllFieldsAsync(type);
+        }
+
+        return type.allFields();
+    }
+
+    private static List<Field> resolveAllFieldsAsync(ReferenceType type) {
+        Set<Field> result = Collections.synchronizedSet(new HashSet<>());
+        AsyncJdwpUtils.await(resolveAllFieldsAsync(type, result));
+        List<Field> fields = new ArrayList<>();
+        fields.addAll(result);
+        return fields;
+    }
+
+    private static CompletableFuture<Void> resolveAllFieldsAsync(ReferenceType type, Set<Field> result) {
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        // JDWP Command: RT_FIELDS_WITH_GENERIC
+        futures.add(
+            AsyncJdwpUtils.runAsync(() -> result.addAll(type.fields()))
+        );
+
+        if (type instanceof ClassType) {
+            ClassType classType = (ClassType) type;
+            // JDWP Command: RT_INTERFACES
+            futures.add(AsyncJdwpUtils.supplyAsync(() -> classType.interfaces())
+                .thenCompose((its) -> {
+                    List<CompletableFuture<Void>> itFutures = new ArrayList<>();
+                    for (InterfaceType it : its) {
+                        itFutures.add(resolveAllFieldsAsync(it, result));
+                    }
+
+                    return CompletableFuture.allOf(itFutures.toArray(new CompletableFuture[0]));
+                }));
+
+            // JDWP Command: CT_SUPERCLASS
+            AsyncJdwpUtils.supplyAsync(() -> classType.superclass())
+                .thenCompose((superclass) -> {
+                    if (superclass != null) {
+                        return resolveAllFieldsAsync(superclass, result);
+                    }
+                    return CompletableFuture.completedFuture(null);
+                });
+        } else if (type instanceof InterfaceType) {
+            InterfaceType interfaceType = (InterfaceType) type;
+            // JDWP Command: RT_INTERFACES
+            futures.add(AsyncJdwpUtils.supplyAsync(() -> interfaceType.superinterfaces())
+                .thenCompose((its) -> {
+                    List<CompletableFuture<Void>> itFutures = new ArrayList<>();
+                    for (InterfaceType it : its) {
+                        itFutures.add(resolveAllFieldsAsync(it, result));
+                    }
+
+                    return CompletableFuture.allOf(itFutures.toArray(new CompletableFuture[0]));
+                }));
+        }
+
+        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
+    }
+
     private VariableUtils() {
 
     }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/AbstractProtocolServer.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/AbstractProtocolServer.java
new file mode 100644
index 000000000..61d57bd85
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/AbstractProtocolServer.java
@@ -0,0 +1,307 @@
+/*******************************************************************************
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.protocol;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.protocol.Events.DebugEvent;
+
+import io.reactivex.disposables.Disposable;
+import io.reactivex.schedulers.Schedulers;
+import io.reactivex.subjects.PublishSubject;
+
+public abstract class AbstractProtocolServer implements IProtocolServer {
+    private static final Logger logger = Logger.getLogger("java-debug");
+    private static final int BUFFER_SIZE = 4096;
+    private static final String TWO_CRLF = "\r\n\r\n";
+    private static final Pattern CONTENT_LENGTH_MATCHER = Pattern.compile("Content-Length: (\\d+)");
+    private static final Charset PROTOCOL_ENCODING = StandardCharsets.UTF_8; // vscode protocol uses UTF-8 as encoding format.
+
+    protected boolean terminateSession = false;
+
+    private Reader reader;
+    private Writer writer;
+
+    private ByteBuffer rawData;
+    private int contentLength = -1;
+    private AtomicInteger sequenceNumber = new AtomicInteger(1);
+    private boolean isValidDAPRequest = true;
+
+    private PublishSubject<Messages.Response> responseSubject = PublishSubject.<Messages.Response>create();
+    private PublishSubject<Messages.Request> requestSubject = PublishSubject.<Messages.Request>create();
+
+    /**
+     * Constructs a protocol server instance based on the given input stream and
+     * output stream.
+     *
+     * @param input
+     *            the input stream
+     * @param output
+     *            the output stream
+     */
+    public AbstractProtocolServer(InputStream input, OutputStream output) {
+        this.reader = new BufferedReader(new InputStreamReader(input, PROTOCOL_ENCODING));
+        this.writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(output, PROTOCOL_ENCODING)));
+        this.contentLength = -1;
+        this.rawData = new ByteBuffer();
+
+        requestSubject.observeOn(Schedulers.newThread()).subscribe(request -> {
+            try {
+                this.dispatchRequest(request);
+            } catch (Exception e) {
+                logger.log(Level.SEVERE, String.format("Dispatch debug protocol error: %s", e.toString()), e);
+            }
+        });
+    }
+
+    /**
+     * A while-loop to parse input data and send output data constantly.
+     */
+    public void run() {
+        char[] buffer = new char[BUFFER_SIZE];
+        try {
+            while (!this.terminateSession) {
+                int read = this.reader.read(buffer, 0, BUFFER_SIZE);
+                if (read == -1) {
+                    break;
+                }
+
+                this.rawData.append(new String(buffer, 0, read).getBytes(PROTOCOL_ENCODING));
+                this.processData();
+            }
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, String.format("Read data from io exception: %s", e.toString()), e);
+        }
+
+        requestSubject.onComplete();
+    }
+
+    /**
+     * Sets terminateSession flag to true. And the dispatcher loop will be
+     * terminated after current dispatching operation finishes.
+     */
+    public void stop() {
+        this.terminateSession = true;
+    }
+
+    /**
+     * Send a request/response/event to the DA.
+     *
+     * @param message
+     *            the message.
+     */
+    private void sendMessage(Messages.ProtocolMessage message) {
+        message.seq = this.sequenceNumber.getAndIncrement();
+
+        String jsonMessage = JsonUtils.toJson(message);
+        byte[] jsonBytes = jsonMessage.getBytes(PROTOCOL_ENCODING);
+
+        String header = String.format("Content-Length: %d%s", jsonBytes.length, TWO_CRLF);
+        byte[] headerBytes = header.getBytes(PROTOCOL_ENCODING);
+
+        ByteBuffer data = new ByteBuffer();
+        data.append(headerBytes);
+        data.append(jsonBytes);
+
+        String utf8Data = data.getString(PROTOCOL_ENCODING);
+
+        try {
+            if (message instanceof Messages.Request) {
+                logger.fine("\n[[REQUEST]]\n" + utf8Data);
+            } else if (message instanceof Messages.Event) {
+                logger.fine("\n[[EVENT]]\n" + utf8Data);
+            } else {
+                logger.fine("\n[[RESPONSE]]\n" + utf8Data);
+            }
+            this.writer.write(utf8Data);
+            this.writer.flush();
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, String.format("Write data to io exception: %s", e.toString()), e);
+        }
+    }
+
+    @Override
+    public void sendEvent(DebugEvent event) {
+        sendMessage(new Messages.Event(event.type, event));
+    }
+
+    @Override
+    public void sendResponse(Messages.Response response) {
+        sendMessage(response);
+    }
+
+    @Override
+    public CompletableFuture<Messages.Response> sendRequest(Messages.Request request) {
+        return sendRequest(request, 0);
+    }
+
+    @Override
+    public CompletableFuture<Messages.Response> sendRequest(Messages.Request request, long timeout) {
+        CompletableFuture<Messages.Response> future = new CompletableFuture<>();
+        Timer timer = new Timer();
+        Disposable[] disposable = new Disposable[1];
+        disposable[0] = responseSubject.filter(response -> response.request_seq == request.seq).take(1)
+                .observeOn(Schedulers.newThread()).subscribe((response) -> {
+                    try {
+                        timer.cancel();
+                        future.complete(response);
+                        if (disposable[0] != null) {
+                            disposable[0].dispose();
+                        }
+                    } catch (Exception e) {
+                        logger.log(Level.SEVERE, String.format("Handle response error: %s", e.toString()), e);
+                    }
+                });
+        sendMessage(request);
+        if (timeout > 0) {
+            try {
+                timer.schedule(new TimerTask() {
+                    @Override
+                    public void run() {
+                        if (disposable[0] != null) {
+                            disposable[0].dispose();
+                        }
+                        future.completeExceptionally(new TimeoutException("timeout"));
+                    }
+                }, timeout);
+            } catch (IllegalStateException ex) {
+                // if timer or task has been cancelled, do nothing.
+            }
+        }
+        return future;
+    }
+
+    private void processData() {
+        while (true) {
+            /**
+             * In vscode debug protocol, the content length represents the
+             * message's byte length with utf8 format.
+             */
+            if (this.contentLength >= 0) {
+                if (this.rawData.length() >= this.contentLength) {
+                    byte[] buf = this.rawData.removeFirst(this.contentLength);
+                    this.contentLength = -1;
+                    String messageData = new String(buf, PROTOCOL_ENCODING);
+                    try {
+                        Messages.ProtocolMessage message = JsonUtils.fromJson(messageData, Messages.ProtocolMessage.class);
+
+                        logger.fine(String.format("\n[%s]\n%s", message.type, messageData));
+
+                        if (message.type.equals("request")) {
+                            Messages.Request request = JsonUtils.fromJson(messageData, Messages.Request.class);
+                            if (this.isValidDAPRequest) {
+                                requestSubject.onNext(request);
+                            } else {
+                                Messages.Response response = new Messages.Response(request.seq, request.command);
+                                sendResponse(AdapterUtils.setErrorResponse(response,
+                                    ErrorCode.INVALID_DAP_HEADER,
+                                    String.format("'%s' request is rejected due to not being a valid DAP message.", request.command)));
+                            }
+                        } else if (message.type.equals("response")) {
+                            Messages.Response response = JsonUtils.fromJson(messageData, Messages.Response.class);
+                            responseSubject.onNext(response);
+                        }
+                    } catch (Exception ex) {
+                        logger.log(Level.SEVERE, String.format("Error parsing message: %s", ex.toString()), ex);
+                    }
+
+                    continue;
+                }
+            }
+
+            String rawMessage = this.rawData.getString(PROTOCOL_ENCODING);
+            int idx = rawMessage.indexOf(TWO_CRLF);
+            if (idx != -1) {
+                Matcher matcher = CONTENT_LENGTH_MATCHER.matcher(rawMessage);
+                if (matcher.find()) {
+                    final String contentLengthText = matcher.group(1);
+                    this.contentLength = Integer.parseInt(contentLengthText);
+                    final String headerMessage = rawMessage.substring(0, idx + TWO_CRLF.length());
+                    final int headerByteLength = headerMessage.getBytes(PROTOCOL_ENCODING).length;
+                    this.rawData.removeFirst(headerByteLength); // Remove the header from the raw message.
+
+                    int expectedHeaderLength = 16 /*"Content-Length: ".length()*/ + contentLengthText.length();
+                    int actualHeaderLength = idx;
+                    if (expectedHeaderLength != actualHeaderLength) {
+                        this.isValidDAPRequest = false;
+                        logger.log(Level.SEVERE, String.format("Illegal DAP request is detected: %s", headerMessage));
+                    } else {
+                        this.isValidDAPRequest = true;
+                    }
+                    continue;
+                }
+            }
+
+            break;
+        }
+    }
+
+    protected abstract void dispatchRequest(Messages.Request request);
+
+    class ByteBuffer {
+        private byte[] buffer;
+
+        public ByteBuffer() {
+            this.buffer = new byte[0];
+        }
+
+        public int length() {
+            return this.buffer.length;
+        }
+
+        public String getString(Charset cs) {
+            return new String(this.buffer, cs);
+        }
+
+        public void append(byte[] b) {
+            append(b, b.length);
+        }
+
+        public void append(byte[] b, int length) {
+            byte[] newBuffer = new byte[this.buffer.length + length];
+            System.arraycopy(buffer, 0, newBuffer, 0, this.buffer.length);
+            System.arraycopy(b, 0, newBuffer, this.buffer.length, length);
+            this.buffer = newBuffer;
+        }
+
+        public byte[] removeFirst(int n) {
+            byte[] b = new byte[n];
+            System.arraycopy(this.buffer, 0, b, 0, n);
+            byte[] newBuffer = new byte[this.buffer.length - n];
+            System.arraycopy(this.buffer, n, newBuffer, 0, this.buffer.length - n);
+            this.buffer = newBuffer;
+            return b;
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Events.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Events.java
similarity index 51%
rename from com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Events.java
rename to com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Events.java
index c5859e4e6..e692e9b8d 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Events.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Events.java
@@ -9,7 +9,10 @@
 *     Microsoft Corporation - initial API and implementation
 *******************************************************************************/
 
-package com.microsoft.java.debug.core.adapter;
+package com.microsoft.java.debug.core.protocol;
+
+import com.google.gson.annotations.SerializedName;
+import com.microsoft.java.debug.core.protocol.Types.Source;
 
 /**
  * The event types defined by VSCode Debug Protocol.
@@ -35,6 +38,11 @@ public static class StoppedEvent extends DebugEvent {
         public String description;
         public String text;
         public boolean allThreadsStopped;
+        /**
+         * A value of true hints to the client that this event should not change the
+         * focus.
+         */
+        public Boolean preserveFocusHint;
 
         /**
          * Constructor.
@@ -43,7 +51,7 @@ public StoppedEvent(String reason, long threadId) {
             super("stopped");
             this.reason = reason;
             this.threadId = threadId;
-            this.allThreadsStopped = false;
+            allThreadsStopped = false;
         }
 
         /**
@@ -136,6 +144,11 @@ public enum Category {
 
         public Category category;
         public String output;
+        public int variablesReference;
+        public Source source;
+        public int line;
+        public int column;
+        public Object data;
 
         /**
          * Constructor.
@@ -146,6 +159,17 @@ public OutputEvent(Category category, String output) {
             this.output = output;
         }
 
+        /**
+         * Constructor.
+         */
+        public OutputEvent(Category category, String output, Source source, int line) {
+            super("output");
+            this.category = category;
+            this.output = output;
+            this.source = source;
+            this.line = line;
+        }
+
         public static OutputEvent createConsoleOutput(String output) {
             return new OutputEvent(Category.console, output);
         }
@@ -154,10 +178,24 @@ public static OutputEvent createStdoutOutput(String output) {
             return new OutputEvent(Category.stdout, output);
         }
 
+        /**
+         * Construct an stdout output event with source info.
+         */
+        public static OutputEvent createStdoutOutputWithSource(String output, Source source, int line) {
+            return new OutputEvent(Category.stdout, output, source, line);
+        }
+
         public static OutputEvent createStderrOutput(String output) {
             return new OutputEvent(Category.stderr, output);
         }
 
+        /**
+         * Construct an stderr output event with source info.
+         */
+        public static OutputEvent createStderrOutputWithSource(String output, Source source, int line) {
+            return new OutputEvent(Category.stderr, output, source, line);
+        }
+
         public static OutputEvent createTelemetryOutput(String output) {
             return new OutputEvent(Category.telemetry, output);
         }
@@ -176,4 +214,124 @@ public BreakpointEvent(String reason, Types.Breakpoint breakpoint) {
             this.breakpoint = breakpoint;
         }
     }
+
+    public static class HotCodeReplaceEvent extends DebugEvent {
+        public enum ChangeType {
+            ERROR, WARNING, STARTING, END, BUILD_COMPLETE
+        }
+
+        public ChangeType changeType;
+        public String message;
+
+        /**
+         * Constructor.
+         */
+        public HotCodeReplaceEvent(ChangeType changeType, String message) {
+            super("hotcodereplace");
+            this.changeType = changeType;
+            this.message = message;
+        }
+    }
+
+    public static class UserNotificationEvent extends DebugEvent {
+        public enum NotificationType {
+            ERROR, WARNING, INFORMATION
+        }
+
+        public NotificationType notificationType;
+        public String message;
+
+        /**
+         * Constructor.
+         */
+        public UserNotificationEvent(NotificationType notifyType, String message) {
+            super("usernotification");
+            this.notificationType = notifyType;
+            this.message = message;
+        }
+    }
+
+    public static class TelemetryEvent extends DebugEvent {
+        /**
+         * The telemetry event name.
+         */
+        public String name;
+
+        /**
+         * The properties is an object as below.
+         * {
+         *   [key: string]: string | number;
+         * }
+         */
+        public Object properties;
+
+        /**
+         * Constructor.
+         */
+        public TelemetryEvent(String name, Object data) {
+            super("telemetry");
+            this.name = name;
+            this.properties = data;
+        }
+    }
+
+    public static enum InvalidatedAreas {
+        @SerializedName("all")
+        ALL,
+        @SerializedName("stacks")
+        STACKS,
+        @SerializedName("threads")
+        THREADS,
+        @SerializedName("variables")
+        VARIABLES;
+    }
+
+    public static class InvalidatedEvent extends DebugEvent {
+        public InvalidatedAreas[] areas;
+        public long threadId;
+        public int frameId;
+
+        public InvalidatedEvent() {
+            super("invalidated");
+        }
+
+        public InvalidatedEvent(InvalidatedAreas area) {
+            super("invalidated");
+            this.areas = new InvalidatedAreas[]{area};
+        }
+
+        public InvalidatedEvent(InvalidatedAreas area, long threadId) {
+            super("invalidated");
+            this.areas = new InvalidatedAreas[]{area};
+            this.threadId = threadId;
+        }
+
+        public InvalidatedEvent(InvalidatedAreas area, int frameId) {
+            super("invalidated");
+            this.areas = new InvalidatedAreas[]{area};
+            this.frameId = frameId;
+        }
+    }
+
+    public static class ProcessIdNotification extends DebugEvent {
+        /**
+         * The process ID.
+         */
+        public long processId = -1;
+        /**
+         * The process ID of the terminal shell if the process is running in a terminal shell.
+         */
+        public long shellProcessId = -1;
+
+        public ProcessIdNotification(long processId) {
+            super("processid");
+            this.processId = processId;
+        }
+
+        public ProcessIdNotification(long processId, long shellProcessId) {
+            super("processid");
+            this.processId = processId;
+            this.shellProcessId = shellProcessId;
+        }
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/IProtocolServer.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/IProtocolServer.java
new file mode 100644
index 000000000..4041824e1
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/IProtocolServer.java
@@ -0,0 +1,54 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.core.protocol;
+
+import java.util.concurrent.CompletableFuture;
+
+import com.microsoft.java.debug.core.protocol.Events.DebugEvent;
+import com.microsoft.java.debug.core.protocol.Messages.Request;
+import com.microsoft.java.debug.core.protocol.Messages.Response;
+
+public interface IProtocolServer {
+    /**
+     * Send a request to the DA.
+     *
+     * @param request
+     *            the request message.
+     * @return a CompletableFuture.
+     */
+    CompletableFuture<Response> sendRequest(Request request);
+
+    /**
+     * Send a request to the DA. The future will complete exceptionally if no response is received at the give time.
+     *
+     * @param request
+     *            the request message.
+     * @param timeout
+     *            the maximum time (in millis) to wait.
+     * @return a CompletableFuture.
+     */
+    CompletableFuture<Response> sendRequest(Request request, long timeout);
+
+    /**
+     * Send an event to the DA.
+     * @param event
+     *              the event message.
+     */
+    void sendEvent(DebugEvent event);
+
+    /**
+     * Send a response to the DA.
+     * @param response
+     *                  the response message.
+     */
+    void sendResponse(Response response);
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/JsonUtils.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/JsonUtils.java
similarity index 96%
rename from com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/JsonUtils.java
rename to com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/JsonUtils.java
index ed421e771..a2e925f57 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/JsonUtils.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/JsonUtils.java
@@ -9,7 +9,7 @@
 *     Microsoft Corporation - initial API and implementation
 *******************************************************************************/
 
-package com.microsoft.java.debug.core.adapter;
+package com.microsoft.java.debug.core.protocol;
 
 import java.lang.reflect.Type;
 
@@ -46,6 +46,10 @@ public static String toJson(Object src, Type typeOfSrc) {
         return GSON.toJson(src, typeOfSrc);
     }
 
+    public static JsonElement toJsonTree(Object src, Type typeOfSrc) {
+        return GSON.toJsonTree(src, typeOfSrc);
+    }
+
     /**
      * Get the integer value for the specified property from the json Object.
      * @param args
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Messages.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Messages.java
similarity index 67%
rename from com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Messages.java
rename to com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Messages.java
index dce0a11c4..467a4bf38 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Messages.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Messages.java
@@ -9,7 +9,7 @@
 *     Microsoft Corporation - initial API and implementation
 *******************************************************************************/
 
-package com.microsoft.java.debug.core.adapter;
+package com.microsoft.java.debug.core.protocol;
 
 import com.google.gson.JsonObject;
 
@@ -40,6 +40,15 @@ public Request(int id, String cmd, JsonObject arg) {
             this.command = cmd;
             this.arguments = arg;
         }
+
+        /**
+        * Constructor.
+        */
+        public Request(String cmd, JsonObject arg) {
+            super("request");
+            this.command = cmd;
+            this.arguments = arg;
+        }
     }
 
     public static class Response extends ProtocolMessage {
@@ -56,46 +65,55 @@ public Response() {
         /**
          * Constructor.
          */
-        public Response(String msg) {
+        public Response(String message) {
             super("response");
             this.success = false;
-            this.message = msg;
+            this.message = message;
         }
 
         /**
          * Constructor.
          */
-        public Response(boolean succ, String message) {
+        public Response(boolean success, String message) {
             super("response");
-            this.success = succ;
+            this.success = success;
             this.message = message;
         }
 
         /**
          * Constructor.
          */
-        public Response(Response m) {
+        public Response(Response response) {
             super("response");
-            this.seq = m.seq;
-            this.success = m.success;
-            this.message = m.message;
-            this.request_seq = m.request_seq;
-            this.command = m.command;
-            this.body = m.body;
+            this.seq = response.seq;
+            this.success = response.success;
+            this.message = response.message;
+            this.request_seq = response.request_seq;
+            this.command = response.command;
+            this.body = response.body;
         }
 
         /**
          * Constructor.
          */
-        public Response(int rseq, String cmd) {
+        public Response(int requestSeq, String command) {
             super("response");
-            this.request_seq = rseq;
-            this.command = cmd;
+            this.request_seq = requestSeq;
+            this.command = command;
+        }
+
+        public Response(int requestSeq, String command, boolean success) {
+            this(requestSeq, command);
+            this.success = success;
         }
 
-        public Response(int rseq, String cmd, boolean succ) {
-            this(rseq, cmd);
-            this.success = succ;
+        /**
+         * Constructor.
+         */
+        public Response(int requestSeq, String command, boolean success, String message) {
+            this(requestSeq, command);
+            this.success = success;
+            this.message = message;
         }
     }
 
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Requests.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Requests.java
new file mode 100644
index 000000000..1129d230e
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Requests.java
@@ -0,0 +1,518 @@
+/*******************************************************************************
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.protocol;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Objects;
+
+import com.google.gson.annotations.SerializedName;
+import com.microsoft.java.debug.core.protocol.Types.DataBreakpoint;
+import com.microsoft.java.debug.core.protocol.Types.Source;
+
+/**
+ * The request arguments types defined by VSCode Debug Protocol.
+ */
+public class Requests {
+
+    public static class ValueFormat {
+        public boolean hex;
+    }
+
+    public static class Arguments {
+
+    }
+
+    public static class InitializeArguments extends Arguments {
+        public String clientID;
+        public String adapterID;
+        public String pathFormat;
+        public boolean linesStartAt1;
+        public boolean columnsStartAt1;
+        public boolean supportsVariableType;
+        public boolean supportsVariablePaging;
+        public boolean supportsRunInTerminalRequest;
+    }
+
+    public static class ClassFilters {
+        /**
+         * Restricts the events generated by the request to those whose location is
+         * in a class whose name matches this restricted regular expression. Regular
+         * expressions are limited to exact matches and patterns that begin with '*'
+         * or end with '*'; for example, "*.Foo" or "java.*".
+         *
+         * This property corresponds to the ClassFilter (include filter). Multiple
+         * filters are applied with CUT-OFF AND. Only events that satisfied all
+         * filters are placed in the event queue, that means several include filters
+         * are handled as "A and B and C", not "A or B or C".
+         */
+        public String[] allowClasses = new String[0];
+
+        /**
+         * Restricts the events generated by the request to those whose location is
+         * in a class whose name does not match this restricted regular expression, e.g.
+         * "java.*" or "*.Foo".
+         *
+         * This property corrsponds to the ClassExclusionFilter (exclude filter).
+         */
+        public String[] skipClasses = new String[0];
+    }
+
+    public static class ExceptionFilters extends ClassFilters {
+        /**
+         * Specifies that exceptions which are instances of refType will be reported.
+         * Note: this will include instances of sub-types. If null, all instances
+         * will be reported.
+         */
+        public String[] exceptionTypes = new String[0];
+    }
+
+    public static class StepFilters extends ClassFilters {
+        /**
+         * Deprecated - please use {@link ClassFilters#skipClasses } instead.
+         */
+        @Deprecated
+        public String[] classNameFilters;
+        public boolean skipSynthetics;
+        public boolean skipStaticInitializers;
+        public boolean skipConstructors;
+    }
+
+    public static class LaunchBaseArguments extends Arguments {
+        public String type;
+        public String name;
+        public String request;
+        public String projectName;
+        public String[] sourcePaths = new String[0];
+        public StepFilters stepFilters;
+    }
+
+    public static enum CONSOLE {
+        internalConsole,
+        integratedTerminal,
+        externalTerminal;
+    }
+
+    public static enum ShortenApproach {
+        @SerializedName("none")
+        NONE,
+        @SerializedName("jarmanifest")
+        JARMANIFEST,
+        @SerializedName("argfile")
+        ARGFILE;
+    }
+
+    public static class LaunchArguments extends LaunchBaseArguments {
+        public String mainClass;
+        public String args = "";
+        public String vmArgs = "";
+        public String encoding = "";
+        public String[] classPaths = new String[0];
+        public String[] modulePaths = new String[0];
+        public String cwd;
+        public Map<String, String> env;
+        public boolean stopOnEntry;
+        public boolean noDebug = false;
+        public CONSOLE console = CONSOLE.integratedTerminal;
+        public ShortenApproach shortenCommandLine = ShortenApproach.NONE;
+        public String launcherScript;
+        public String javaExec;
+    }
+
+    public static class AttachArguments extends LaunchBaseArguments {
+        public String hostName;
+        public int port;
+        public int timeout = 30000; // Default to 30s.
+    }
+
+    public static class RunInTerminalRequestArguments extends Arguments {
+        public String kind; // Supported kind should be "integrated" or "external".
+        public String title;
+        public String cwd; // required.
+        public String[] args; // required.
+        public Map<String, String> env;
+
+        private RunInTerminalRequestArguments() {
+            // do nothing.
+        }
+
+        /**
+         * Create a RunInTerminalRequestArguments instance.
+         * @param cmds
+         *            List of command arguments. The first arguments is the command to run.
+         * @param cwd
+         *            Working directory of the command.
+         * @return the request arguments instance.
+         */
+        public static RunInTerminalRequestArguments createIntegratedTerminal(String[] cmds, String cwd) {
+            RunInTerminalRequestArguments requestArgs = new RunInTerminalRequestArguments();
+            requestArgs.args = cmds;
+            requestArgs.cwd = cwd;
+            requestArgs.kind = "integrated";
+            return requestArgs;
+        }
+
+        /**
+         * Create a RunInTerminalRequestArguments instance.
+         * @param cmds
+         *            List of command arguments. The first arguments is the command to run.
+         * @param cwd
+         *            Working directory of the command.
+         * @param env
+         *            Environment key-value pairs that are added to the default environment.
+         * @param title
+         *            Optional title of the terminal.
+         * @return the request arguments instance.
+         */
+        public static RunInTerminalRequestArguments createIntegratedTerminal(String[] cmds, String cwd, Map<String, String> env, String title) {
+            RunInTerminalRequestArguments requestArgs = createIntegratedTerminal(cmds, cwd);
+            requestArgs.env = env;
+            requestArgs.title = title;
+            return requestArgs;
+        }
+
+        /**
+         * Create a RunInTerminalRequestArguments instance.
+         * @param cmds
+         *            List of command arguments. The first arguments is the command to run.
+         * @param cwd
+         *            Working directory of the command.
+         * @return the request arguments instance.
+         */
+        public static RunInTerminalRequestArguments createExternalTerminal(String[] cmds, String cwd) {
+            RunInTerminalRequestArguments requestArgs = new RunInTerminalRequestArguments();
+            requestArgs.args = cmds;
+            requestArgs.cwd = cwd;
+            requestArgs.kind = "external";
+            return requestArgs;
+        }
+
+        /**
+         * Create a RunInTerminalRequestArguments instance.
+         * @param cmds
+         *            List of command arguments. The first arguments is the command to run.
+         * @param cwd
+         *            Working directory of the command.
+         * @param env
+         *            Environment key-value pairs that are added to the default environment.
+         * @param title
+         *            Optional title of the terminal.
+         * @return the request arguments instance.
+         */
+        public static RunInTerminalRequestArguments createExternalTerminal(String[] cmds, String cwd, Map<String, String> env, String title) {
+            RunInTerminalRequestArguments requestArgs = createExternalTerminal(cmds, cwd);
+            requestArgs.env = env;
+            requestArgs.title = title;
+            return requestArgs;
+        }
+    }
+
+    public static class RestartArguments extends Arguments {
+
+    }
+
+    public static class DisconnectArguments extends Arguments {
+        // If client doesn't set terminateDebuggee attribute at the DisconnectRequest,
+        // the debugger would choose to terminate debuggee by default.
+        public boolean terminateDebuggee = true;
+        public boolean restart;
+    }
+
+    public static class ConfigurationDoneArguments extends Arguments {
+
+    }
+
+    public static class SetBreakpointArguments extends Arguments {
+        public Types.Source source;
+        public int[] lines = new int[0];
+        public Types.SourceBreakpoint[] breakpoints = new Types.SourceBreakpoint[0];
+        public boolean sourceModified = false;
+    }
+
+    public static class StackTraceArguments extends Arguments {
+        public long threadId;
+        public int startFrame;
+        public int levels;
+    }
+
+    public static class SetFunctionBreakpointsArguments extends Arguments {
+        public Types.FunctionBreakpoint[] breakpoints;
+    }
+
+    public static class SetExceptionBreakpointsArguments extends Arguments {
+        public String[] filters = new String[0];
+    }
+
+    public static class ExceptionInfoArguments extends Arguments {
+        public long threadId;
+    }
+
+    public static class ThreadsArguments extends Arguments {
+
+    }
+
+    public static class ContinueArguments extends Arguments {
+        public long threadId;
+    }
+
+    public static class StepArguments extends Arguments {
+        public long threadId;
+    }
+
+    public static class NextArguments extends StepArguments {
+
+    }
+
+    public static class StepInArguments extends StepArguments {
+        public int targetId;
+    }
+
+    public static class StepOutArguments extends StepArguments {
+
+    }
+
+    public static class StepInTargetsArguments extends Arguments {
+        public int frameId;
+    }
+
+    public static class PauseArguments extends Arguments {
+        public long threadId;
+    }
+
+    public static class ThreadOperationArguments extends Arguments {
+        public long threadId;
+    }
+
+    public static class ScopesArguments extends Arguments {
+        public int frameId;
+    }
+
+    public static class VariablesArguments extends Arguments {
+        public int variablesReference = -1;
+        public String filter;
+        public int start;
+        public int count;
+        public ValueFormat format;
+    }
+
+    public static class SetVariableArguments extends Arguments {
+        public int variablesReference;
+        public String name;
+        public String value;
+        public ValueFormat format;
+    }
+
+    public static class RefreshVariablesArguments extends Arguments {
+        public boolean showStaticVariables = false;
+        public boolean showQualifiedNames = false;
+        public boolean showHex = false;
+        public boolean showLogicalStructure = true;
+        public boolean showToString = true;
+    }
+
+    public static class SourceArguments extends Arguments {
+        public int sourceReference;
+    }
+
+    public static class EvaluateArguments extends Arguments {
+        public String expression;
+        public int frameId;
+        public String context;
+        public ValueFormat format;
+    }
+
+    public static class RedefineClassesArguments extends Arguments {
+
+    }
+
+    public static class RestartFrameArguments extends Arguments {
+        public int frameId;
+    }
+
+    public static class CompletionsArguments extends Arguments {
+        public int frameId;
+        public String text;
+        public int line;
+        public int column;
+    }
+
+    public static class DataBreakpointInfoArguments extends Arguments {
+        /**
+         * Reference to the Variable container if the data breakpoint is requested for a child of the container.
+         */
+        public int variablesReference;
+        /**
+         * The name of the Variable's child to obtain data breakpoint information for. If variableReference isn’t provided, this can be an expression.
+         */
+        public String name;
+    }
+
+    public static class SetDataBreakpointsArguments extends Arguments {
+        /**
+         * The contents of this array replaces all existing data breakpoints. An empty array clears all data breakpoints.
+         */
+        public DataBreakpoint[] breakpoints;
+    }
+
+    public static class InlineValuesArguments extends Arguments {
+        public int frameId;
+        public InlineVariable[] variables;
+    }
+
+    public static class InlineVariable {
+        public String expression;
+        public String declaringClass;
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(declaringClass, expression);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof InlineVariable)) {
+                return false;
+            }
+            InlineVariable other = (InlineVariable) obj;
+            return Objects.equals(declaringClass, other.declaringClass) && Objects.equals(expression, other.expression);
+        }
+    }
+
+    /**
+     * Arguments for breakpointLocations request.
+     */
+    public static class BreakpointLocationsArguments extends Arguments {
+        /**
+         * The source location of the breakpoints; either `source.path` or
+         * `source.reference` must be specified.
+         */
+        public Source source;
+
+        /**
+         * Start line of range to search possible breakpoint locations in. If only the
+         * line is specified, the request returns all possible locations in that line.
+         */
+        public int line;
+
+        /**
+         * Start column of range to search possible breakpoint locations in. If no
+         * start column is given, the first column in the start line is assumed.
+         */
+        public int column;
+
+        /**
+         * End line of range to search possible breakpoint locations in. If no end
+         * line is given, then the end line is assumed to be the start line.
+         */
+        public int endLine;
+
+        /**
+         * End column of range to search possible breakpoint locations in. If no end
+         * column is given, then it is assumed to be in the last column of the end
+         * line.
+         */
+        public int endColumn;
+    }
+
+    public static class RefreshFramesArguments extends Arguments {
+        /**
+         * If provided, refresh the stack frames of the paused threads that previously
+         * requested decompiled sources for classes in the affected root paths.
+         * Otherwise, refresh all paused threads.
+         */
+        public String[] affectedRootPaths;
+    }
+
+    public static enum Command {
+        INITIALIZE("initialize", InitializeArguments.class),
+        LAUNCH("launch", LaunchArguments.class),
+        ATTACH("attach", AttachArguments.class),
+        DISCONNECT("disconnect", DisconnectArguments.class),
+        CONFIGURATIONDONE("configurationDone", ConfigurationDoneArguments.class),
+        NEXT("next", NextArguments.class),
+        CONTINUE("continue", ContinueArguments.class),
+        STEPIN("stepIn", StepInArguments.class),
+        STEPOUT("stepOut", StepOutArguments.class),
+        STEPIN_TARGETS("stepInTargets",
+                StepInTargetsArguments.class),
+        PAUSE("pause", PauseArguments.class),
+        STACKTRACE("stackTrace", StackTraceArguments.class),
+        RESTARTFRAME("restartFrame", RestartFrameArguments.class),
+        SCOPES("scopes", ScopesArguments.class),
+        VARIABLES("variables", VariablesArguments.class),
+        SETVARIABLE("setVariable", SetVariableArguments.class),
+        SOURCE("source", SourceArguments.class),
+        THREADS("threads", ThreadsArguments.class),
+        SETBREAKPOINTS("setBreakpoints", SetBreakpointArguments.class),
+        SETEXCEPTIONBREAKPOINTS("setExceptionBreakpoints", SetExceptionBreakpointsArguments.class),
+        SETFUNCTIONBREAKPOINTS("setFunctionBreakpoints", SetFunctionBreakpointsArguments.class),
+        EVALUATE("evaluate", EvaluateArguments.class),
+        COMPLETIONS("completions", CompletionsArguments.class),
+        RUNINTERMINAL("runInTerminal", RunInTerminalRequestArguments.class),
+        REDEFINECLASSES("redefineClasses", RedefineClassesArguments.class),
+        EXCEPTIONINFO("exceptionInfo", ExceptionInfoArguments.class),
+        DATABREAKPOINTINFO("dataBreakpointInfo", DataBreakpointInfoArguments.class),
+        SETDATABREAKPOINTS("setDataBreakpoints", SetDataBreakpointsArguments.class),
+        CONTINUEALL("continueAll", ThreadOperationArguments.class),
+        CONTINUEOTHERS("continueOthers", ThreadOperationArguments.class),
+        PAUSEALL("pauseAll", ThreadOperationArguments.class),
+        PAUSEOTHERS("pauseOthers", ThreadOperationArguments.class),
+        INLINEVALUES("inlineValues", InlineValuesArguments.class),
+        REFRESHVARIABLES("refreshVariables", RefreshVariablesArguments.class),
+        PROCESSID("processId", Arguments.class),
+        BREAKPOINTLOCATIONS("breakpointLocations", BreakpointLocationsArguments.class),
+        REFRESHFRAMES("refreshFrames", RefreshFramesArguments.class),
+        UNSUPPORTED("", Arguments.class);
+
+        private String command;
+        private Class<? extends Arguments> argumentType;
+
+        Command(String command, Class<? extends Arguments> argumentType) {
+            this.command = command;
+            this.argumentType = argumentType;
+        }
+
+        public String getName() {
+            return this.command;
+        }
+
+        @Override
+        public String toString() {
+            return this.command;
+        }
+
+        public Class<? extends Arguments> getArgumentType() {
+            return this.argumentType;
+        }
+
+        /**
+         * Get the corresponding Command type by the command name.
+         * If the command is not defined in the enum type, return UNSUPPORTED.
+         * @param command
+         *             the command name
+         * @return the Command type
+         */
+        public static Command parse(String command) {
+            Command[] found = Arrays.stream(Command.values()).filter(cmd -> {
+                return cmd.toString().equals(command);
+            }).toArray(Command[]::new);
+
+            if (found.length > 0) {
+                return found[0];
+            }
+            return UNSUPPORTED;
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Responses.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Responses.java
similarity index 50%
rename from com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Responses.java
rename to com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Responses.java
index d7d65cc2f..af701552e 100644
--- a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/adapter/Responses.java
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Responses.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -9,10 +9,17 @@
 *     Microsoft Corporation - initial API and implementation
 *******************************************************************************/
 
-package com.microsoft.java.debug.core.adapter;
+package com.microsoft.java.debug.core.protocol;
 
 import java.util.List;
 
+import com.microsoft.java.debug.core.protocol.Types.BreakpointLocation;
+import com.microsoft.java.debug.core.protocol.Types.DataBreakpointAccessType;
+import com.microsoft.java.debug.core.protocol.Types.ExceptionBreakMode;
+import com.microsoft.java.debug.core.protocol.Types.ExceptionDetails;
+import com.microsoft.java.debug.core.protocol.Types.StepInTarget;
+import com.microsoft.java.debug.core.protocol.Types.Variable;
+
 /**
  * The response content types defined by VSCode Debug Protocol.
  */
@@ -34,6 +41,37 @@ public InitializeResponseBody(Types.Capabilities capabilities) {
         }
     }
 
+    public static class ProcessIdResponseBody extends ResponseBody {
+        /**
+         * The process ID.
+         */
+        public long processId = -1;
+        /**
+         * The process ID of the terminal shell if the process is running in a terminal shell.
+         */
+        public long shellProcessId = -1;
+
+        public ProcessIdResponseBody(long processId) {
+            this.processId = processId;
+        }
+
+        public ProcessIdResponseBody(long processId, long shellProcessId) {
+            this.processId = processId;
+            this.shellProcessId = shellProcessId;
+        }
+    }
+
+    public static class RunInTerminalResponseBody extends ProcessIdResponseBody {
+
+        public RunInTerminalResponseBody(long processId) {
+            super(processId);
+        }
+
+        public RunInTerminalResponseBody(long processId, long shellProcessId) {
+            super(processId, shellProcessId);
+        }
+    }
+
     public static class ErrorResponseBody extends ResponseBody {
         public Types.Message error;
 
@@ -164,6 +202,21 @@ public EvaluateResponseBody(String value, int ref, String type, int indexedVaria
         }
     }
 
+    public static class CompletionsResponseBody extends ResponseBody {
+        public Types.CompletionItem[] targets;
+
+        /**
+         * Constructor.
+         */
+        public CompletionsResponseBody(List<Types.CompletionItem> items) {
+            if (items == null) {
+                targets = new Types.CompletionItem[0];
+            } else {
+                targets = items.toArray(new Types.CompletionItem[0]);
+            }
+        }
+    }
+
     public static class SetBreakpointsResponseBody extends ResponseBody {
         public Types.Breakpoint[] breakpoints;
 
@@ -181,6 +234,71 @@ public SetBreakpointsResponseBody(List<Types.Breakpoint> bpts) {
         }
     }
 
+    public static class SetDataBreakpointsResponseBody extends SetBreakpointsResponseBody {
+        public SetDataBreakpointsResponseBody(List<Types.Breakpoint> bpts) {
+            super(bpts);
+        }
+    }
+
+    public static class DataBreakpointInfoResponseBody extends ResponseBody {
+        /**
+         * An identifier for the data on which a data breakpoint can be registered with the setDataBreakpoints request
+         * or null if no data breakpoint is available.
+         */
+        public String dataId;
+        /**
+         * UI string that describes on what data the breakpoint is set on or why a data breakpoint is not available.
+         */
+        public String description;
+        /**
+         * Optional attribute listing the available access types for a potential data breakpoint. A UI frontend could surface this information.
+         */
+        public DataBreakpointAccessType[] accessTypes;
+        /**
+         * Optional attribute indicating that a potential data breakpoint could be persisted across sessions.
+         */
+        public boolean canPersist;
+
+        public DataBreakpointInfoResponseBody(String dataId) {
+            this(dataId, null);
+        }
+
+        public DataBreakpointInfoResponseBody(String dataId, String description) {
+            this(dataId, description, null);
+        }
+
+        public DataBreakpointInfoResponseBody(String dataId, String description,
+                DataBreakpointAccessType[] accessTypes) {
+            this(dataId, description, accessTypes, false);
+        }
+
+        /**
+         * Constructor.
+         */
+        public DataBreakpointInfoResponseBody(String dataId, String description, DataBreakpointAccessType[] accessTypes,
+                boolean canPersist) {
+            this.dataId = dataId;
+            this.description = description;
+            this.accessTypes = accessTypes;
+            this.canPersist = canPersist;
+        }
+    }
+
+    /**
+     * Response to breakpointLocations request.
+     * Contains possible locations for source breakpoints.
+     */
+    public static class BreakpointLocationsResponseBody extends ResponseBody {
+        /**
+         * Sorted set of possible breakpoint locations.
+         */
+        public BreakpointLocation[] breakpoints;
+
+        public BreakpointLocationsResponseBody(BreakpointLocation[] breakpoints) {
+            this.breakpoints = breakpoints;
+        }
+    }
+
     public static class ContinueResponseBody extends ResponseBody {
         public boolean allThreadsContinued;
 
@@ -195,4 +313,64 @@ public ContinueResponseBody(boolean allThreadsContinued) {
             this.allThreadsContinued = allThreadsContinued;
         }
     }
+
+    public static class ExceptionInfoResponse extends ResponseBody {
+        public String exceptionId;
+        public String description;
+        public ExceptionBreakMode breakMode;
+        public ExceptionDetails details;
+
+        /**
+         * Constructs a ExceptionInfoResponse.
+         */
+        public ExceptionInfoResponse(String exceptionId, String description, ExceptionBreakMode breakMode) {
+            this.exceptionId = exceptionId;
+            this.description = description;
+            this.breakMode = breakMode;
+        }
+
+        /**
+         * Constructs a ExceptionInfoResponse.
+         */
+        public ExceptionInfoResponse(String exceptionId, String description, ExceptionBreakMode breakMode, ExceptionDetails details) {
+            this(exceptionId, description, breakMode);
+            this.details = details;
+        }
+    }
+
+    public static class RedefineClassesResponse extends ResponseBody {
+        public String[] changedClasses = new String[0];
+        public String errorMessage = null;
+
+        /**
+         * Constructor.
+         */
+        public RedefineClassesResponse(String[] changedClasses) {
+            this(changedClasses, null);
+        }
+
+        /**
+         * Constructor.
+         */
+        public RedefineClassesResponse(String[] changedClasses, String errorMessage) {
+            this.changedClasses = changedClasses;
+            this.errorMessage = errorMessage;
+        }
+    }
+
+    public static class InlineValuesResponse extends ResponseBody {
+        public Types.Variable[] variables;
+
+        public InlineValuesResponse(Variable[] variables) {
+            this.variables = variables;
+        }
+    }
+
+    public static class StepInTargetsResponse extends ResponseBody {
+        public StepInTarget[] targets;
+
+        public StepInTargetsResponse(StepInTarget[] targets) {
+            this.targets = targets;
+        }
+    }
 }
diff --git a/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Types.java b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Types.java
new file mode 100644
index 000000000..9d32d4783
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/main/java/com/microsoft/java/debug/core/protocol/Types.java
@@ -0,0 +1,449 @@
+/*******************************************************************************
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.core.protocol;
+
+import java.nio.file.Paths;
+
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The data types defined by Debug Adapter Protocol.
+ */
+public class Types {
+    public static class Message {
+        public int id;
+        public String format;
+
+        /**
+         * Constructs a message with the given information.
+         *
+         * @param id
+         *          message id
+         * @param format
+         *          a format string
+         */
+        public Message(int id, String format) {
+            this.id = id;
+            this.format = format;
+        }
+    }
+
+    public static class StackFrame {
+        public int id;
+        public Source source;
+        public int line;
+        public int column;
+        public String name;
+        public String presentationHint;
+
+
+        /**
+         * Constructs a StackFrame with the given information.
+         *
+         * @param id               the stack frame id
+         * @param name             the stack frame name
+         * @param src              source info of the stack frame
+         * @param ln               line number of the stack frame
+         * @param col              column number of the stack frame
+         * @param presentationHint An optional hint for how to present this frame in the UI.
+         *                         Values: 'normal', 'label', 'subtle'
+         */
+        public StackFrame(int id, String name, Source src, int ln, int col, String presentationHint) {
+            this.id = id;
+            this.name = name;
+            this.source = src;
+            this.line = ln;
+            this.column = col;
+            this.presentationHint = presentationHint;
+        }
+    }
+
+    public static class Scope {
+        public String name;
+        public int variablesReference;
+        public boolean expensive;
+
+        /**
+         * Constructor.
+         */
+        public Scope(String name, int rf, boolean exp) {
+            this.name = name;
+            this.variablesReference = rf;
+            this.expensive = exp;
+        }
+    }
+
+    public static class Variable {
+        public String name;
+        public String value;
+        public String type;
+        public int variablesReference;
+        public int namedVariables;
+        public int indexedVariables;
+        public String evaluateName;
+        public VariablePresentationHint presentationHint;
+
+        /**
+         * Constructor.
+         */
+        public Variable(String name, String val, String type, int rf, String evaluateName) {
+            this.name = name;
+            this.value = val;
+            this.type = type;
+            this.variablesReference = rf;
+            this.evaluateName = evaluateName;
+        }
+
+        /**
+         * Constructor.
+         */
+        public Variable(String name, String value) {
+            this.name = name;
+            this.value = value;
+        }
+    }
+
+    public static class Thread {
+        public long id;
+        public String name;
+
+        /**
+         * Constructor.
+         */
+        public Thread(long l, String name) {
+            this.id = l;
+            if (name == null || name.length() == 0) {
+                this.name = String.format("Thread #%d", l);
+            } else {
+                this.name = name;
+            }
+        }
+    }
+
+    public static class Source {
+        public String name;
+        public String path;
+        public int sourceReference;
+
+        public Source() {
+        }
+
+        /**
+         * Constructor.
+         */
+        public Source(String name, String path, int rf) {
+            this.name = name;
+            this.path = path;
+            this.sourceReference = rf;
+        }
+
+        /**
+         * Constructor.
+         */
+        public Source(String path, int rf) {
+            this.name = Paths.get(path).getFileName().toString();
+            this.path = path;
+            this.sourceReference = rf;
+        }
+    }
+
+    public static class Breakpoint {
+        /**
+         * An optional identifier for the breakpoint. It is needed if breakpoint events are used to update or remove breakpoints.
+         */
+        public int id;
+        /**
+         * If true breakpoint could be set (but not necessarily at the desired location).
+         */
+        public boolean verified;
+        /**
+         * The start line of the actual range covered by the breakpoint.
+         */
+        public int line;
+        /**
+         * An optional message about the state of the breakpoint. This is shown to the user and can be used to explain why a breakpoint could not be verified.
+         */
+        public String message;
+
+        public Breakpoint(boolean verified) {
+            this.verified = verified;
+        }
+
+        public Breakpoint(int id, boolean verified) {
+            this.id = id;
+            this.verified = verified;
+        }
+
+        /**
+         * Constructor.
+         */
+        public Breakpoint(int id, boolean verified, int line, String message) {
+            this.id = id;
+            this.verified = verified;
+            this.line = line;
+            this.message = message;
+        }
+    }
+
+    /**
+     * Properties of a breakpoint or logpoint passed to the setBreakpoints request.
+     */
+    public static class SourceBreakpoint {
+        public int line;
+        public int column;
+        public String hitCondition;
+        public String condition;
+        public String logMessage;
+
+        public SourceBreakpoint(int line, int column) {
+            this.line = line;
+            this.column = column;
+        }
+
+        /**
+         * Constructor.
+         */
+        public SourceBreakpoint(int line, String condition, String hitCondition) {
+            this.line = line;
+            this.condition = condition;
+            this.hitCondition = hitCondition;
+        }
+
+        /**
+         * Constructor.
+         */
+        public SourceBreakpoint(int line, String condition, String hitCondition, int column) {
+            this.line = line;
+            this.column = column;
+            this.condition = condition;
+            this.hitCondition = hitCondition;
+        }
+    }
+
+    public static class FunctionBreakpoint {
+        public String name;
+        public String condition;
+        public String hitCondition;
+
+        public FunctionBreakpoint() {
+        }
+
+        public FunctionBreakpoint(String name) {
+            this.name = name;
+        }
+    }
+
+    public static enum DataBreakpointAccessType {
+        @SerializedName("read")
+        READ("read"),
+        @SerializedName("write")
+        WRITE("write"),
+        @SerializedName("readWrite")
+        READWRITE("readWrite");
+
+        String label;
+
+        DataBreakpointAccessType(String label) {
+            this.label = label;
+        }
+
+        public String label() {
+            return label;
+        }
+    }
+
+    public static class DataBreakpoint {
+        /**
+         * An id representing the data. This id is returned from the dataBreakpointInfo request.
+         */
+        public String dataId;
+        /**
+         * The access type of the data.
+         */
+        public DataBreakpointAccessType accessType;
+        /**
+         * An optional expression for conditional breakpoints.
+         */
+        public String condition;
+        /**
+         * An optional expression that controls how many hits of the breakpoint are ignored. The backend is expected to interpret the expression as needed.
+         */
+        public String hitCondition;
+
+        public DataBreakpoint(String dataId) {
+            this.dataId = dataId;
+        }
+
+        public DataBreakpoint(String dataId, DataBreakpointAccessType accessType) {
+            this.dataId = dataId;
+            this.accessType = accessType;
+        }
+
+        /**
+         * Constructor.
+         */
+        public DataBreakpoint(String dataId, DataBreakpointAccessType accessType, String condition, String hitCondition) {
+            this.dataId = dataId;
+            this.accessType = accessType;
+            this.condition = condition;
+            this.hitCondition = hitCondition;
+        }
+    }
+
+    /**
+     * Properties of a breakpoint location returned from the breakpointLocations request.
+     */
+    public static class BreakpointLocation {
+        /**
+         * Start line of breakpoint location.
+         */
+        public int line;
+
+        /**
+         * The start column of breakpoint location.
+         */
+        public int column;
+
+        /**
+         * The end line of breakpoint location if the location covers a range.
+         */
+        public int endLine;
+
+        /**
+         * The end column of breakpoint location if the location covers a range.
+         */
+        public int endColumn;
+
+        public BreakpointLocation() {
+        }
+
+        public BreakpointLocation(int line, int column) {
+            this.line = line;
+            this.column = column;
+        }
+
+        public BreakpointLocation(int line, int column, int endLine, int endColumn) {
+            this.line = line;
+            this.column = column;
+            this.endLine = endLine;
+            this.endColumn = endColumn;
+        }
+    }
+
+    public static class CompletionItem {
+        public String label;
+        public String text;
+        public String type;
+        /**
+         * A string that should be used when comparing this item with other items.
+         */
+        public String sortText;
+
+        public int start;
+        public int number;
+
+        public CompletionItem() {
+        }
+
+        public CompletionItem(String label, String text) {
+            this.label = label;
+            this.text = text;
+        }
+    }
+
+    public static class ExceptionBreakpointFilter {
+        public static final String UNCAUGHT_EXCEPTION_FILTER_NAME = "uncaught";
+        public static final String CAUGHT_EXCEPTION_FILTER_NAME = "caught";
+        public static final String UNCAUGHT_EXCEPTION_FILTER_LABEL = "Uncaught Exceptions";
+        public static final String CAUGHT_EXCEPTION_FILTER_LABEL = "Caught Exceptions";
+
+        public String label;
+        public String filter;
+
+        public ExceptionBreakpointFilter(String value, String label) {
+            this.filter = value;
+            this.label = label;
+        }
+
+        public static final ExceptionBreakpointFilter UNCAUGHT_EXCEPTION_FILTER =
+                new ExceptionBreakpointFilter(UNCAUGHT_EXCEPTION_FILTER_NAME, UNCAUGHT_EXCEPTION_FILTER_LABEL);
+        public static final ExceptionBreakpointFilter CAUGHT_EXCEPTION_FILTER =
+                new ExceptionBreakpointFilter(CAUGHT_EXCEPTION_FILTER_NAME, CAUGHT_EXCEPTION_FILTER_LABEL);
+    }
+
+    public static enum ExceptionBreakMode {
+        @SerializedName("never")
+        NEVER,
+        @SerializedName("always")
+        ALWAYS,
+        @SerializedName("unhandled")
+        UNHANDLED,
+        @SerializedName("userUnhandled")
+        USERUNHANDLED
+    }
+
+    public static class ExceptionDetails {
+        public String message;
+        public String typeName;
+        public String fullTypeName;
+        public String evaluateName;
+        public String stackTrace;
+        public ExceptionDetails[] innerException;
+    }
+
+    public static class VariablePresentationHint {
+        public boolean lazy;
+        public String[] attributes;
+
+        public VariablePresentationHint(boolean lazy, String[] attributes) {
+            this.lazy = lazy;
+            this.attributes = attributes;
+        }
+    }
+
+    public static class Capabilities {
+        public boolean supportsConfigurationDoneRequest;
+        public boolean supportsHitConditionalBreakpoints;
+        public boolean supportsConditionalBreakpoints;
+        public boolean supportsEvaluateForHovers;
+        public boolean supportsCompletionsRequest;
+        public boolean supportsRestartFrame;
+        public boolean supportsSetVariable;
+        public boolean supportsRestartRequest;
+        public boolean supportTerminateDebuggee;
+        public boolean supportsDelayedStackTraceLoading;
+        public boolean supportsLogPoints;
+        public boolean supportsExceptionInfoRequest;
+        public ExceptionBreakpointFilter[] exceptionBreakpointFilters = new ExceptionBreakpointFilter[0];
+        public boolean supportsDataBreakpoints;
+        public boolean supportsClipboardContext;
+        public boolean supportsFunctionBreakpoints;
+        // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_BreakpointLocations
+        public boolean supportsBreakpointLocationsRequest;
+        public boolean supportsStepInTargetsRequest;
+    }
+
+    public static class StepInTarget {
+        public int id;
+        public String label;
+        public int line;
+        public int column;
+        public int endLine;
+        public int endColumn;
+
+        public StepInTarget(int id, String label) {
+            this.id = id;
+            this.label = label;
+        }
+    }
+
+}
diff --git a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/AbstractJdiTestCase.java b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/AbstractJdiTestCase.java
index 171ef4081..4d0a122a5 100644
--- a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/AbstractJdiTestCase.java
+++ b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/AbstractJdiTestCase.java
@@ -38,12 +38,12 @@ protected BreakpointEvent waitForBreakPointEvent(String breakpointAtClass, int l
         }
         IDebugSession debugSession = getCurrentDebugSession();
 
-        IBreakpoint breakpointToAdd = getCurrentDebugSession().createBreakpoint(breakpointAtClass, line);
+        IBreakpoint breakpointToAdd = debugSession.createBreakpoint(breakpointAtClass, line, 0, null, null);
         breakpointToAdd.install().thenAccept(t -> {
             System.out.println("Breakpoint is accepted.");
         });
         debugSession.start();
-        debugSession.eventHub().breakpointEvents().subscribe(breakpoint -> {
+        debugSession.getEventHub().breakpointEvents().subscribe(breakpoint -> {
             System.out.println("Breakpoint is hit.");
             breakpoint.shouldResume = false;
             staticBreakpointEvent = (BreakpointEvent) breakpoint.event;
diff --git a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/BreakpointTest.java b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/BreakpointTest.java
new file mode 100644
index 000000000..5cc6fa3d7
--- /dev/null
+++ b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/BreakpointTest.java
@@ -0,0 +1,17 @@
+package com.microsoft.java.debug.core;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class BreakpointTest {
+    @Test
+    public void testToNoneGeneric() {
+        assertEquals("Ljava.util.List;", Breakpoint.toNoneGeneric("Ljava.util.List<java.lang.String;>;"));
+        assertEquals("(Ljava/util/Map;)Ljava/util/Map;", Breakpoint.toNoneGeneric(
+                "(Ljava/util/Map<Ljava/lang/String;Ljava/util/List<Ljava/lang/Integer;>;>;)Ljava/util/Map<Ljava/lang/String;Ljava/util/List<Ljava/lang/Integer;>;>;"));
+        assertEquals("(Ljava/util/Map;)Ljava/util/Map;",
+                Breakpoint.toNoneGeneric(
+                        "(Ljava/util/Map<Ljava/util/List<Ljava/lang/Integer;>;Ljava/util/List<Ljava/lang/Integer;>;>;)Ljava/util/Map<Ljava/util/List<Ljava/lang/Integer;>;Ljava/util/List<Ljava/lang/Integer;>;>;"));
+    }
+}
diff --git a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/DebugSessionFactory.java b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/DebugSessionFactory.java
index 9392d0507..9589c9bdc 100644
--- a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/DebugSessionFactory.java
+++ b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/DebugSessionFactory.java
@@ -52,11 +52,11 @@ public static IDebugSession getDebugSession(String projectName, String mainClass
             String projectRoot = new File(rootPath, name).getAbsolutePath();
             try {
                 final IDebugSession debugSession = DebugUtility.launch(Bootstrap.virtualMachineManager(), mainClass, "", "",
-                        new File(projectRoot, "bin").getAbsolutePath());
-                debugSession.eventHub().events().subscribe(debugEvent -> {
+                        null, new File(projectRoot, "bin").getAbsolutePath(), null, null);
+                debugSession.getEventHub().events().subscribe(debugEvent -> {
                     if (debugEvent.event instanceof VMDisconnectEvent) {
                         try {
-                            debugSession.eventHub().close();
+                            debugSession.getEventHub().close();
                         } catch (Exception e) {
                             // do nothing.
                         }
diff --git a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ArrayObjectFormatterTest.java b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ArrayObjectFormatterTest.java
index d86b82d9d..bf867ec72 100644
--- a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ArrayObjectFormatterTest.java
+++ b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ArrayObjectFormatterTest.java
@@ -58,7 +58,7 @@ public void testAcceptType() throws Exception {
     @Test
     public void testToString() throws Exception {
         Value arrays = this.getLocalValue("arrays");
-        assertEquals("Should be able to format array type.", String.format("int[1] (id=%d)",
+        assertEquals("Should be able to format array type.", String.format("int[1]@%d",
             ((ObjectReference) arrays).uniqueID()),
             formatter.toString(arrays, new HashMap<>()));
     }
diff --git a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ClassObjectFormatterTest.java b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ClassObjectFormatterTest.java
index 7ea62ecc4..9abafd48b 100644
--- a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ClassObjectFormatterTest.java
+++ b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ClassObjectFormatterTest.java
@@ -73,7 +73,7 @@ public void testValueOfNotUnsupported() {
     @Test
     public void testToString() throws Exception {
         Value clazzValue = this.getLocalValue("b");
-        assertEquals("Should be able to format clazz type.", String.format("java.lang.Class (A) (id=%d)",
+        assertEquals("Should be able to format clazz type.", String.format("java.lang.Class (A)@%d",
             ((ObjectReference)clazzValue).uniqueID()),
             formatter.toString(clazzValue, new HashMap<>()));
     }
diff --git a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/NumericFormatterTest.java b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/NumericFormatterTest.java
index 001b928e9..372eb8163 100644
--- a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/NumericFormatterTest.java
+++ b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/NumericFormatterTest.java
@@ -29,6 +29,8 @@
 import com.sun.jdi.Value;
 import com.sun.jdi.VirtualMachine;
 
+import java.util.Locale;
+
 import static com.microsoft.java.debug.core.adapter.formatter.NumericFormatter.NUMERIC_FORMAT_OPTION;
 import static com.microsoft.java.debug.core.adapter.formatter.NumericFormatter.NUMERIC_PRECISION_OPTION;
 import static org.junit.Assert.*;
@@ -38,6 +40,7 @@ public class NumericFormatterTest extends BaseJdiTestCase {
     @Before
     public void setup() throws Exception {
         super.setup();
+        Locale.setDefault(Locale.US);
         formatter = new NumericFormatter();
     }
 
diff --git a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ObjectFormatterTest.java b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ObjectFormatterTest.java
index 4f63ea607..430220d3c 100644
--- a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ObjectFormatterTest.java
+++ b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/ObjectFormatterTest.java
@@ -63,7 +63,7 @@ public void testAcceptType() throws Exception {
     @Test
     public void testToStringDec() throws Exception {
         ObjectReference or = this.getObjectReference("Foo");
-        assertEquals("Failed to format an object.", String.format("MockType (id=%d)", or.uniqueID()),
+        assertEquals("Failed to format an object.", String.format("MockType@%d", or.uniqueID()),
             formatter.toString(or, new HashMap<>()));
     }
 
@@ -72,7 +72,7 @@ public void testToStringHex() throws Exception {
         ObjectReference or = this.getObjectReference("Foo");
         Map<String, Object> options = formatter.getDefaultOptions();
         options.put(NUMERIC_FORMAT_OPTION, NumericFormatEnum.HEX);
-        assertEquals("Failed to format an object.", String.format("MockType (id=%#x)", or.uniqueID()),
+        assertEquals("Failed to format an object.", String.format("MockType@%#x", or.uniqueID()),
             formatter.toString(or, options));
     }
 
@@ -81,7 +81,7 @@ public void testToStringOct() throws Exception {
         ObjectReference or = this.getObjectReference("Foo");
         Map<String, Object> options = formatter.getDefaultOptions();
         options.put(NUMERIC_FORMAT_OPTION, NumericFormatEnum.OCT);
-        assertEquals("Failed to format an object.", String.format("MockType (id=%#o)", or.uniqueID()),
+        assertEquals("Failed to format an object.", String.format("MockType@%#o", or.uniqueID()),
             formatter.toString(or, options));
     }
 
diff --git a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/StringObjectFormatterTest.java b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/StringObjectFormatterTest.java
index b572e5c6b..63b388e1a 100644
--- a/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/StringObjectFormatterTest.java
+++ b/com.microsoft.java.debug.core/src/test/java/com/microsoft/java/debug/core/adapter/formatter/StringObjectFormatterTest.java
@@ -11,6 +11,13 @@
 
 package com.microsoft.java.debug.core.adapter.formatter;
 
+import static com.microsoft.java.debug.core.adapter.formatter.StringObjectFormatter.MAX_STRING_LENGTH_OPTION;
+import static junit.framework.TestCase.assertNull;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
 import java.util.HashMap;
 import java.util.Map;
 
@@ -23,15 +30,9 @@
 import com.sun.jdi.StringReference;
 import com.sun.jdi.Value;
 
-import static junit.framework.TestCase.assertNull;
-import static com.microsoft.java.debug.core.adapter.formatter.StringObjectFormatter.MAX_STRING_LENGTH_OPTION;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
 public class StringObjectFormatterTest extends BaseJdiTestCase {
     protected StringObjectFormatter formatter;
+    @Override
     @Before
     public void setup() throws Exception {
         super.setup();
@@ -64,16 +65,14 @@ public void testToString() throws Exception {
         Value string = this.getLocalValue("str");
         Map<String, Object> options = formatter.getDefaultOptions();
         options.put(MAX_STRING_LENGTH_OPTION, 4);
-        assertEquals("Should be able to format string type.", String.format("\"s...\" (id=%d)",
-            ((ObjectReference) string).uniqueID()),
+        assertEquals("Should be able to format string type.", "\"s...\"",
             formatter.toString(string, options));
 
         options.put(MAX_STRING_LENGTH_OPTION, 5);
-        assertEquals("Should be able to format string type.", String.format("\"st...\" (id=%d)",
-            ((ObjectReference) string).uniqueID()),
+        assertEquals("Should be able to format string type.", "\"st...\"",
             formatter.toString(string, options));
-        assertTrue("Should be able to trim long string..",
-            formatter.toString(string, new HashMap<>()).contains("aaaaaaaaaaaaaaaaaaaaaaa...\""));
+        assertTrue("Should not trim long string by default",
+            formatter.toString(string, new HashMap<>()).contains(((StringReference) string).value()));
     }
 
     @Test
diff --git a/com.microsoft.java.debug.plugin/.classpath b/com.microsoft.java.debug.plugin/.classpath
new file mode 100644
index 000000000..b2be945c8
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/.classpath
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-21">
+		<attributes>
+			<attribute name="module" value="true"/>
+			<attribute name="limit-modules" value="java.base,java.logging,java.xml,jdk.jdi,java.compiler"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry exported="true" kind="lib" path="lib/commons-io-2.19.0.jar"/>
+	<classpathentry kind="src" path="src/main/java"/>
+	<classpathentry exported="true" kind="lib" path="lib/rxjava-2.2.21.jar"/>
+	<classpathentry exported="true" kind="lib" path="lib/reactive-streams-1.0.4.jar"/>
+	<classpathentry exported="true" kind="lib" path="lib/com.microsoft.java.debug.core-0.53.2.jar" sourcepath="/com.microsoft.java.debug.core"/>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
diff --git a/com.microsoft.java.debug.plugin/.project b/com.microsoft.java.debug.plugin/.project
new file mode 100644
index 000000000..529a656dd
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/.project
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>com.microsoft.java.debug.plugin</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>net.sf.eclipsecs.core.CheckstyleBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>net.sf.eclipsecs.core.CheckstyleNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1665543654719</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>
diff --git a/com.microsoft.java.debug.plugin/META-INF/MANIFEST.MF b/com.microsoft.java.debug.plugin/META-INF/MANIFEST.MF
index 69c462bb8..f2ceffb53 100644
--- a/com.microsoft.java.debug.plugin/META-INF/MANIFEST.MF
+++ b/com.microsoft.java.debug.plugin/META-INF/MANIFEST.MF
@@ -1,11 +1,12 @@
 Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
-Bundle-Name: Debug
+Bundle-Name: Java Debug Server Plugin
 Bundle-SymbolicName: com.microsoft.java.debug.plugin;singleton:=true
-Bundle-Version: 0.1.0
-Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Bundle-Version: 0.53.2
+Bundle-RequiredExecutionEnvironment: JavaSE-21
 Bundle-ActivationPolicy: lazy
 Bundle-Activator: com.microsoft.java.debug.plugin.internal.JavaDebuggerServerPlugin
+Bundle-Vendor: Microsoft
 Import-Package: org.eclipse.jdt.core,
  org.eclipse.jdt.launching,
  org.osgi.framework;version="1.3.0"
@@ -13,12 +14,15 @@ Require-Bundle: org.eclipse.core.runtime,
  org.eclipse.debug.core,
  org.eclipse.jdt.debug,
  org.eclipse.jdt.core,
- org.eclipse.jdt.ls.core
-Bundle-ClassPath: lib/gson-2.7.jar,
+ org.eclipse.jdt.core.manipulation,
+ org.eclipse.jdt.ls.core,
+ org.eclipse.jdt.launching,
+ com.google.gson,
+ org.apache.commons.lang3,
+ org.eclipse.lsp4j,
+ com.google.guava
+Bundle-ClassPath: lib/commons-io-2.19.0.jar,
  .,
- lib/rxjava-2.1.1.jar,
- lib/reactive-streams-1.0.0.jar,
- lib/com.microsoft.java.debug.core-0.1.0.jar,
- lib/commons-io-2.5.jar,
- lib/commons-lang3-3.6.jar
-
+ lib/rxjava-2.2.21.jar,
+ lib/reactive-streams-1.0.4.jar,
+ lib/com.microsoft.java.debug.core-0.53.2.jar
diff --git a/com.microsoft.java.debug.plugin/plugin.xml b/com.microsoft.java.debug.plugin/plugin.xml
index 5ab528c46..69d76830d 100644
--- a/com.microsoft.java.debug.plugin/plugin.xml
+++ b/com.microsoft.java.debug.plugin/plugin.xml
@@ -5,9 +5,22 @@
       <delegateCommandHandler class="com.microsoft.java.debug.plugin.internal.JavaDebugDelegateCommandHandler">
             <command id="vscode.java.startDebugSession"/>
             <command id="vscode.java.resolveClasspath"/>
+            <command id="vscode.java.resolveMainClass"/>
             <command id="vscode.java.buildWorkspace"/>
             <command id="vscode.java.fetchUsageData"/>
-            <command id="vscode.java.configLogLevel"/>
+            <command id="vscode.java.updateDebugSettings"/>
+            <command id="vscode.java.validateLaunchConfig"/>
+            <command id="vscode.java.resolveMainMethod"/>
+            <command id="vscode.java.inferLaunchCommandLength"/>
+            <command id="vscode.java.checkProjectSettings"/>
+            <command id="vscode.java.resolveElementAtSelection"/>
+            <command id="vscode.java.resolveBuildFiles"/>
+            <command id="vscode.java.isOnClasspath"/>
+            <command id="vscode.java.resolveJavaExecutable"/>
+            <command id="vscode.java.fetchPlatformSettings"/>
+            <command id="vscode.java.resolveClassFilters"/>
+            <command id="vscode.java.resolveSourceUri"/>
+            <command id="vscode.java.resolveInlineVariables"/>
        </delegateCommandHandler>
    </extension>
 </plugin>
diff --git a/com.microsoft.java.debug.plugin/pom.xml b/com.microsoft.java.debug.plugin/pom.xml
index 696eb783a..2e2c0e6a8 100644
--- a/com.microsoft.java.debug.plugin/pom.xml
+++ b/com.microsoft.java.debug.plugin/pom.xml
@@ -4,8 +4,8 @@
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>com.microsoft.java</groupId>
-        <artifactId>parent</artifactId>
-        <version>0.1.0</version>
+        <artifactId>java-debug-parent</artifactId>
+        <version>0.53.2</version>
     </parent>
     <artifactId>com.microsoft.java.debug.plugin</artifactId>
     <packaging>eclipse-plugin</packaging>
@@ -17,6 +17,17 @@
                 <artifactId>tycho-maven-plugin</artifactId>
                 <version>${tycho-version}</version>
                 <extensions>true</extensions>
+            </plugin>
+             <plugin>
+                <groupId>org.eclipse.tycho</groupId>
+                <artifactId>tycho-compiler-plugin</artifactId>
+                <version>${tycho-version}</version>
+                <configuration>
+                    <compilerArgs>
+                        <arg>--limit-modules</arg>
+                        <arg>java.base,java.logging,java.xml,jdk.jdi,java.compiler</arg>
+                    </compilerArgs>
+                </configuration>
             </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
@@ -27,39 +38,29 @@
                 <artifactId>maven-dependency-plugin</artifactId>
                 <configuration>
                     <artifactItems>
-                        <artifactItem>
-                            <groupId>com.google.code.gson</groupId>
-                            <artifactId>gson</artifactId>
-                            <version>2.7</version>
-                        </artifactItem>
                         <artifactItem>
                             <groupId>io.reactivex.rxjava2</groupId>
                             <artifactId>rxjava</artifactId>
-                            <version>2.1.1</version>
+                            <version>2.2.21</version>
                         </artifactItem>
                         <artifactItem>
                             <groupId>org.reactivestreams</groupId>
                             <artifactId>reactive-streams</artifactId>
-                            <version>1.0.0</version>
-                        </artifactItem>
-                        <artifactItem>
-                            <groupId>org.apache.commons</groupId>
-                            <artifactId>commons-lang3</artifactId>
-                            <version>3.6</version>
+                            <version>1.0.4</version>
                         </artifactItem>
                         <artifactItem>
                             <groupId>commons-io</groupId>
                             <artifactId>commons-io</artifactId>
-                            <version>2.5</version>
+                            <version>2.19.0</version>
                         </artifactItem>
                         <artifactItem>
                             <groupId>com.microsoft.java</groupId>
                             <artifactId>com.microsoft.java.debug.core</artifactId>
-                            <version>0.1.0</version>
+                            <version>0.53.2</version>
                         </artifactItem>
                     </artifactItems>
                 </configuration>
             </plugin>
         </plugins>
     </build>
-</project>
\ No newline at end of file
+</project>
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/BindingUtils.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/BindingUtils.java
new file mode 100644
index 000000000..085bf0d4c
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/BindingUtils.java
@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug;
+
+import org.eclipse.jdt.core.dom.IMethodBinding;
+import org.eclipse.jdt.internal.debug.core.breakpoints.LambdaLocationLocatorHelper;
+
+/**
+ * Utility methods around working with JDT Bindings.
+ */
+@SuppressWarnings("restriction")
+public final class BindingUtils {
+    private BindingUtils() {
+
+    }
+
+    /**
+     * Return the method name from the binding using either the
+     * {@link IMethodBinding#getKey()} or {@link IMethodBinding#getName()}. The key
+     * can be used to find the name of a generated lambda method if the minding
+     * represents a lambda method.
+     *
+     * @param binding the binding to extract the name from.
+     * @param fromKey use binging key to resolve the method name.
+     * @return the name of the method.
+     */
+    public static String getMethodName(IMethodBinding binding, boolean fromKey) {
+        if (fromKey) {
+            String key = binding.getKey();
+            int dotAt = key.indexOf('.');
+            int end = key.indexOf('<', dotAt);
+            if (end == -1) {
+                end = key.indexOf('(');
+            } else {
+                end = Math.min(end, key.indexOf('('));
+            }
+            return key.substring(dotAt + 1, end);
+        } else {
+            return binding.getName();
+        }
+    }
+
+    /**
+     * Returns the method signature of the method represented by the binding
+     * including the synthetic outer locals.
+     *
+     * @param binding the binding which the signature must be resolved for.
+     * @return the signature or null if the signature could not be resolved.
+     */
+    public static String toSignature(IMethodBinding binding) {
+        return LambdaLocationLocatorHelper.toMethodSignature(binding);
+    }
+
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/BreakpointLocationLocator.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/BreakpointLocationLocator.java
new file mode 100644
index 000000000..97581242e
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/BreakpointLocationLocator.java
@@ -0,0 +1,73 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Gayan Perera (gayanper@gmail.com) - initial API and implementation
+*******************************************************************************/
+package com.microsoft.java.debug;
+
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.IMethodBinding;
+import org.eclipse.jdt.core.dom.MethodDeclaration;
+
+@SuppressWarnings("restriction")
+public class BreakpointLocationLocator
+        extends org.eclipse.jdt.internal.debug.core.breakpoints.ValidBreakpointLocationLocator {
+
+    private IMethodBinding methodBinding;
+
+    public BreakpointLocationLocator(CompilationUnit compilationUnit, int lineNumber,
+            boolean bindingsResolved,
+            boolean bestMatch, int offset, int end) {
+        super(compilationUnit, lineNumber, bindingsResolved, bestMatch, offset, end);
+    }
+
+    @Override
+    public boolean visit(MethodDeclaration node) {
+        boolean result = super.visit(node);
+        if (methodBinding == null && getLocationType() == LOCATION_METHOD) {
+            this.methodBinding = node.resolveBinding();
+        }
+        return result;
+    }
+
+    /**
+     * Returns the signature of method found if the
+     * {@link org.eclipse.jdt.internal.debug.core.breakpoints.ValidBreakpointLocationLocator#getLocationType()}
+     * is
+     * {@link org.eclipse.jdt.internal.debug.core.breakpoints.ValidBreakpointLocationLocator#LOCATION_METHOD}.
+     * Otherwise return null.
+     */
+    public String getMethodSignature() {
+        if (this.methodBinding == null) {
+            return null;
+        }
+        return BindingUtils.toSignature(this.methodBinding);
+    }
+
+    /**
+     * Returns the name of method found if the
+     * {@link org.eclipse.jdt.internal.debug.core.breakpoints.ValidBreakpointLocationLocator#getLocationType()}
+     * is
+     * {@link org.eclipse.jdt.internal.debug.core.breakpoints.ValidBreakpointLocationLocator#LOCATION_METHOD}.
+     * Otherwise return null.
+     */
+    public String getMethodName() {
+        if (this.methodBinding == null) {
+            return null;
+        }
+        return this.methodBinding.getName();
+    }
+
+    @Override
+    public String getFullyQualifiedTypeName() {
+        if (this.methodBinding != null) {
+            return this.methodBinding.getDeclaringClass().getQualifiedName();
+        }
+        return super.getFullyQualifiedTypeName();
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/LambdaExpressionLocator.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/LambdaExpressionLocator.java
new file mode 100644
index 000000000..a5456809a
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/LambdaExpressionLocator.java
@@ -0,0 +1,103 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Gayan Perera (gayanper@gmail.com) - initial API and implementation
+*******************************************************************************/
+package com.microsoft.java.debug;
+
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.IMethodBinding;
+import org.eclipse.jdt.core.dom.LambdaExpression;
+
+public class LambdaExpressionLocator extends ASTVisitor {
+    private CompilationUnit compilationUnit;
+    private int line;
+    private int column;
+    private boolean found;
+
+    private IMethodBinding lambdaMethodBinding;
+    private LambdaExpression lambdaExpression;
+
+    public LambdaExpressionLocator(CompilationUnit compilationUnit, int line, int column) {
+        this.compilationUnit = compilationUnit;
+        this.line = line;
+        this.column = column;
+    }
+
+    @Override
+    public boolean visit(LambdaExpression node) {
+        if (column > -1) {
+            int startPosition = node.getStartPosition();
+            int breakOffset = this.compilationUnit.getPosition(line, column);
+            // lambda on same line:
+            // list.stream().map(i -> i + 1);
+            //
+            // lambda on multiple lines:
+            // list.stream().map(user
+            // -> user.isSystem() ? new SystemUser(user) : new EndUser(user));
+
+            // Since the debugger supports BreakpointLocations Request to hint user
+            // about possible inline breakpoint locations, we will only support
+            // inline breakpoints added where a lambda expression begins.
+            if (breakOffset == startPosition) {
+                this.lambdaMethodBinding = node.resolveMethodBinding();
+                this.found = true;
+                this.lambdaExpression = node;
+                return false;
+            }
+        }
+        return super.visit(node);
+    }
+
+    /**
+     * Returns <code>true</code> if a lambda is found at given location.
+     */
+    public boolean isFound() {
+        return found;
+    }
+
+    /**
+     * Returns the signature of lambda method otherwise return null.
+     */
+    public String getMethodSignature() {
+        if (!this.found) {
+            return null;
+        }
+        return BindingUtils.toSignature(this.lambdaMethodBinding);
+    }
+
+    /**
+     * Returns the name of lambda method otherwise return null.
+     */
+    public String getMethodName() {
+        if (!this.found) {
+            return null;
+        }
+        return BindingUtils.getMethodName(lambdaMethodBinding, true);
+    }
+
+    /**
+     * Returns the name of the type which the lambda method is found.
+     */
+    public String getFullyQualifiedTypeName() {
+        if (this.found) {
+            ASTNode parent = lambdaExpression.getParent();
+            while (parent != null) {
+                if (parent instanceof AbstractTypeDeclaration) {
+                    AbstractTypeDeclaration declaration = (AbstractTypeDeclaration) parent;
+                    return declaration.resolveBinding().getBinaryName();
+                }
+                parent = parent.getParent();
+            }
+        }
+        return null;
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/AdvancedLaunchingConnector.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/AdvancedLaunchingConnector.java
new file mode 100644
index 000000000..24c65785d
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/AdvancedLaunchingConnector.java
@@ -0,0 +1,282 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2021 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+import org.apache.commons.io.IOUtils;
+import org.eclipse.jdi.internal.VirtualMachineImpl;
+import org.eclipse.jdi.internal.VirtualMachineManagerImpl;
+import org.eclipse.jdi.internal.connect.SocketLaunchingConnectorImpl;
+import org.eclipse.jdi.internal.connect.SocketListeningConnectorImpl;
+
+import com.microsoft.java.debug.core.DebugUtility;
+import com.microsoft.java.debug.core.LaunchException;
+import com.sun.jdi.VirtualMachine;
+import com.sun.jdi.connect.Connector;
+import com.sun.jdi.connect.IllegalConnectorArgumentsException;
+import com.sun.jdi.connect.LaunchingConnector;
+import com.sun.jdi.connect.VMStartException;
+
+/**
+ * An advanced launching connector that supports cwd and enviroment variables.
+ *
+ */
+public class AdvancedLaunchingConnector extends SocketLaunchingConnectorImpl implements LaunchingConnector {
+    private static final int ACCEPT_TIMEOUT = 10 * 1000;
+
+    public AdvancedLaunchingConnector(VirtualMachineManagerImpl virtualMachineManager) {
+        super(virtualMachineManager);
+    }
+
+    @Override
+    public Map<String, Argument> defaultArguments() {
+        Map<String, Argument> defaultArgs = super.defaultArguments();
+
+        Argument cwdArg = new JDIStringArgumentImpl(DebugUtility.CWD, "Current working directory", DebugUtility.CWD, false);
+        cwdArg.setValue(null);
+        defaultArgs.put(DebugUtility.CWD, cwdArg);
+
+        Argument envArg = new JDIStringArgumentImpl(DebugUtility.ENV, "Environment variables", DebugUtility.ENV, false);
+        envArg.setValue(null);
+        defaultArgs.put(DebugUtility.ENV, envArg);
+
+        return defaultArgs;
+    }
+
+    @Override
+    public String name() {
+        return "com.microsoft.java.debug.AdvancedLaunchingConnector";
+    }
+
+    @Override
+    public VirtualMachine launch(Map<String, ? extends Argument> connectionArgs)
+            throws IOException, IllegalConnectorArgumentsException, VMStartException {
+        String cwd = connectionArgs.get(DebugUtility.CWD).value();
+        File workingDir = null;
+        if (cwd != null && Files.isDirectory(Paths.get(cwd))) {
+            workingDir = new File(cwd);
+        }
+
+        String[] envVars = null;
+        try {
+            envVars = DebugUtility.decodeArrayArgument(connectionArgs.get(DebugUtility.ENV).value());
+        } catch (IllegalArgumentException e) {
+            // do nothing.
+        }
+
+        SocketListeningConnectorImpl listenConnector = new SocketListeningConnectorImpl(
+                virtualMachineManager());
+        Map<String, Connector.Argument> args = listenConnector.defaultArguments();
+        ((Connector.IntegerArgument) args.get("timeout")).setValue(ACCEPT_TIMEOUT); //$NON-NLS-1$
+        String address = listenConnector.startListening(args);
+
+        String[] cmds = constructLaunchCommand(connectionArgs, address);
+
+        /* Launch the Java process */
+        final Process process = Runtime.getRuntime().exec(cmds, envVars, workingDir);
+
+        /* A Future that will be completed if we successfully connect to the launched process, or
+           will fail with an Exception if we do not.
+         */
+        final CompletableFuture<VirtualMachineImpl> result = new CompletableFuture<>();
+
+        /* Listen for the debug connection from the Java process */
+        CompletableFuture.runAsync(() -> {
+            try {
+                VirtualMachineImpl vm = (VirtualMachineImpl) listenConnector.accept(args);
+                vm.setLaunchedProcess(process);
+                result.complete(vm);
+            } catch (IllegalConnectorArgumentsException e) {
+                result.completeExceptionally(e);
+            } catch (IOException e) {
+                if (result.isDone()) {
+                    /* The result Future has already been completed by the Process onExit hook */
+                    return;
+                }
+
+                final String stdout = streamToString(process.getInputStream());
+                final String stderr = streamToString(process.getErrorStream());
+
+                process.destroy();
+
+                result.completeExceptionally(new LaunchException(
+                    String.format("VM did not connect within given time: %d ms", ACCEPT_TIMEOUT),
+                    process,
+                    false,
+                    -1,
+                    stdout,
+                    stderr
+                ));
+            } catch (RuntimeException e) {
+                result.completeExceptionally(e);
+            }
+        });
+
+        /* Wait for the Java process to exit; if it exits before the debug connection is made, report it as an error. */
+        process.onExit().thenAcceptAsync(theProcess -> {
+            if (result.isDone()) {
+                /* The result Future has already been completed by successfully connecting to the debug connection */
+                return;
+            }
+
+            final int exitStatus = theProcess.exitValue();
+            final String stdout = streamToString(process.getInputStream());
+            final String stderr = streamToString(process.getErrorStream());
+
+            result.completeExceptionally(new LaunchException(
+                String.format("VM exited with status %d", exitStatus),
+                theProcess,
+                true,
+                exitStatus,
+                stdout,
+                stderr
+            ));
+
+            /* Stop the debug connection attempt */
+            try {
+                listenConnector.stopListening(args);
+            } catch (IOException e) {
+                /* Ignore */
+            }
+        });
+
+        try {
+            return result.get();
+        } catch (ExecutionException e) {
+            if (e.getCause() instanceof IOException) {
+                throw (IOException) e.getCause();
+            } else if (e.getCause() instanceof IllegalConnectorArgumentsException) {
+                throw (IllegalConnectorArgumentsException) e.getCause();
+            } else if (e.getCause() instanceof VMStartException) {
+                throw (VMStartException) e.getCause();
+            } else if (e.getCause() instanceof RuntimeException) {
+                throw (RuntimeException) e.getCause();
+            } else {
+                throw new IllegalStateException("Unexpected exception thrown when launching VM", e.getCause());
+            }
+        } catch (InterruptedException e) {
+            throw new VMStartException("VM start interrupted", process);
+        }
+    }
+
+    private String streamToString(final InputStream inputStream) {
+        try {
+            return IOUtils.toString(inputStream, StandardCharsets.UTF_8);
+        } catch (IOException ioe) {
+            return null;
+        }
+    }
+
+    private static String[] constructLaunchCommand(Map<String, ? extends Argument> launchingOptions, String address) {
+        final String javaHome = launchingOptions.get(DebugUtility.HOME).value();
+        final String javaExec = launchingOptions.get(DebugUtility.EXEC).value();
+        final String slash = System.getProperty("file.separator");
+        boolean suspend = Boolean.valueOf(launchingOptions.get(DebugUtility.SUSPEND).value());
+        final String javaOptions = launchingOptions.get(DebugUtility.OPTIONS).value();
+        final String main = launchingOptions.get(DebugUtility.MAIN).value();
+
+        StringBuilder execString = new StringBuilder();
+        execString.append("\"" + javaHome + slash + "bin" + slash + javaExec + "\"");
+        execString.append(" -Xrunjdwp:transport=dt_socket,address=" + address + ",server=n,suspend=" + (suspend ? "y" : "n"));
+        if (javaOptions != null) {
+            execString.append(" " + javaOptions);
+        }
+        execString.append(" " + main);
+
+        return DebugUtility.parseArguments(execString.toString()).toArray(new String[0]);
+    }
+
+    abstract class JDIArgumentImpl implements Argument {
+        private static final long serialVersionUID = 8850533280769854833L;
+        private String name;
+        private String description;
+        private String label;
+        private boolean mustSpecify;
+
+        protected JDIArgumentImpl(String name, String description, String label, boolean mustSpecify) {
+            this.name = name;
+            this.description = description;
+            this.label = label;
+            this.mustSpecify = mustSpecify;
+        }
+
+        @Override
+        public String name() {
+            return name;
+        }
+
+        @Override
+        public String description() {
+            return description;
+        }
+
+        @Override
+        public String label() {
+            return label;
+        }
+
+        @Override
+        public boolean mustSpecify() {
+            return mustSpecify;
+        }
+
+        @Override
+        public abstract String value();
+
+        @Override
+        public abstract void setValue(String value);
+
+        @Override
+        public abstract boolean isValid(String value);
+
+        @Override
+        public abstract String toString();
+    }
+
+    class JDIStringArgumentImpl extends JDIArgumentImpl implements StringArgument {
+        private static final long serialVersionUID = 6009335074727417445L;
+        private String value;
+
+        protected JDIStringArgumentImpl(String name, String description, String label, boolean mustSpecify) {
+            super(name, description, label, mustSpecify);
+        }
+
+        @Override
+        public String value() {
+            return value;
+        }
+
+        @Override
+        public void setValue(String value) {
+            this.value = value;
+        }
+
+        @Override
+        public boolean isValid(String value) {
+            return true;
+        }
+
+        @Override
+        public String toString() {
+            return value;
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/AdvancedVirtualMachineManager.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/AdvancedVirtualMachineManager.java
new file mode 100644
index 000000000..a77bdda62
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/AdvancedVirtualMachineManager.java
@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2020 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.DebugSettings.IDebugSettingChangeListener;
+import com.microsoft.java.debug.core.adapter.IVirtualMachineManager;
+import com.sun.jdi.VirtualMachine;
+import com.sun.jdi.VirtualMachineManager;
+import com.sun.jdi.connect.LaunchingConnector;
+
+import org.eclipse.core.runtime.preferences.IEclipsePreferences;
+import org.eclipse.core.runtime.preferences.InstanceScope;
+import org.eclipse.jdi.internal.VirtualMachineManagerImpl;
+import org.eclipse.jdt.debug.core.JDIDebugModel;
+import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
+
+public class AdvancedVirtualMachineManager extends VirtualMachineManagerImpl
+        implements VirtualMachineManager, IDebugSettingChangeListener, IVirtualMachineManager {
+    List<VirtualMachine> connectedVMs = Collections.synchronizedList(new ArrayList());
+
+    public AdvancedVirtualMachineManager() {
+        super();
+        update(DebugSettings.getCurrent(), DebugSettings.getCurrent());
+        DebugSettings.addDebugSettingChangeListener(this);
+    }
+
+    @Override
+    public List<LaunchingConnector> launchingConnectors() {
+        List<LaunchingConnector> connectors = new ArrayList<>();
+        connectors.add(new AdvancedLaunchingConnector(this));
+        connectors.addAll(super.launchingConnectors());
+        return connectors;
+    }
+
+    @Override
+    public void update(DebugSettings oldSettings, DebugSettings newSettings) {
+        int currentTimeout = getGlobalRequestTimeout();
+        int newTimeout = newSettings.jdwpRequestTimeout;
+        if (newTimeout != currentTimeout) {
+            setRequestTimeout(newTimeout);
+        }
+    }
+
+    private void setRequestTimeout(int timeout) {
+        IEclipsePreferences prefs = InstanceScope.INSTANCE.getNode(JDIDebugPlugin.getUniqueIdentifier());
+        if (prefs != null) {
+            prefs.putInt(JDIDebugModel.PREF_REQUEST_TIMEOUT, timeout);
+        }
+
+        if (!connectedVMs.isEmpty()) {
+            connectedVMs.forEach(vm -> {
+                if (vm instanceof org.eclipse.jdi.VirtualMachine) {
+                    try {
+                        ((org.eclipse.jdi.VirtualMachine) vm).setRequestTimeout(timeout);
+                    } catch (Exception e) {
+                        // do nothing.
+                    }
+                }
+            });
+        }
+    }
+
+    @Override
+    public boolean connectVirtualMachine(VirtualMachine vm) {
+        return connectedVMs.add(vm);
+    }
+
+    @Override
+    public boolean disconnectVirtualMachine(VirtualMachine vm) {
+        return connectedVMs.remove(vm);
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/Compile.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/Compile.java
new file mode 100644
index 000000000..245281816
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/Compile.java
@@ -0,0 +1,190 @@
+/*******************************************************************************
+ * Copyright (c) 2022 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.resources.IBuildConfiguration;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceStatus;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.IncrementalProjectBuilder;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.ls.core.internal.BuildWorkspaceStatus;
+import org.eclipse.jdt.ls.core.internal.JavaLanguageServerPlugin;
+import org.eclipse.jdt.ls.core.internal.ProjectUtils;
+import org.eclipse.jdt.ls.core.internal.ResourceUtils;
+import org.eclipse.jdt.ls.core.internal.handlers.BuildWorkspaceHandler;
+import org.eclipse.jdt.ls.core.internal.managers.ProjectsManager;
+import org.eclipse.lsp4j.TextDocumentIdentifier;
+import org.eclipse.lsp4j.extended.ProjectBuildParams;
+
+import com.microsoft.java.debug.core.Configuration;
+
+public class Compile {
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+
+    private static final int GRADLE_BS_COMPILATION_ERROR = 100;
+
+    public static Object compile(CompileParams params, IProgressMonitor monitor) {
+        if (params == null) {
+            throw new IllegalArgumentException("The compile parameters should not be null.");
+        }
+
+        IProject mainProject = JdtUtils.getMainProject(params.getProjectName(), params.getMainClass());
+        if (JdtUtils.isBspProject(mainProject) && !ProjectUtils.isGradleProject(mainProject)) {
+            // Just need to trigger a build for the target project, the Gradle build server will
+            // handle the build dependencies for us.
+            try {
+                ResourcesPlugin.getWorkspace().build(
+                    new IBuildConfiguration[]{mainProject.getActiveBuildConfig()},
+                    IncrementalProjectBuilder.INCREMENTAL_BUILD,
+                    false /*buildReference*/,
+                    monitor
+                );
+            } catch (CoreException e) {
+                if (e.getStatus().getCode() == IResourceStatus.BUILD_FAILED) {
+                    return GRADLE_BS_COMPILATION_ERROR;
+                } else {
+                    return BuildWorkspaceStatus.FAILED;
+                }
+            }
+            return BuildWorkspaceStatus.SUCCEED;
+        }
+
+        if (monitor.isCanceled()) {
+            return BuildWorkspaceStatus.CANCELLED;
+        }
+
+        ProjectBuildParams buildParams = new ProjectBuildParams();
+        List<TextDocumentIdentifier> identifiers = new LinkedList<>();
+        buildParams.setFullBuild(params.isFullBuild);
+        for (IJavaProject javaProject : ProjectUtils.getJavaProjects()) {
+            if (ProjectsManager.getDefaultProject().equals(javaProject.getProject())) {
+                continue;
+            }
+            // we only build project which is not a BSP project, in case that the compile request is triggered by
+            // HCR with auto-build disabled, the build for BSP projects will be triggered by JavaHotCodeReplaceProvider.
+            if (!JdtUtils.isBspProject(javaProject.getProject())) {
+                identifiers.add(new TextDocumentIdentifier(javaProject.getProject().getLocationURI().toString()));
+            }
+        }
+        if (identifiers.size() == 0) {
+            return BuildWorkspaceStatus.SUCCEED;
+        }
+
+        buildParams.setIdentifiers(identifiers);
+        long compileAt = System.currentTimeMillis();
+        BuildWorkspaceHandler buildWorkspaceHandler = new BuildWorkspaceHandler(JavaLanguageServerPlugin.getProjectsManager());
+        BuildWorkspaceStatus status = buildWorkspaceHandler.buildProjects(buildParams, monitor);
+        logger.info("Time cost for ECJ: " + (System.currentTimeMillis() - compileAt) + "ms");
+        if (status == BuildWorkspaceStatus.FAILED || status == BuildWorkspaceStatus.CANCELLED) {
+            return status;
+        }
+
+        try {
+            IResource currentResource = mainProject;
+            if (isUnmanagedFolder(mainProject) && StringUtils.isNotBlank(params.getMainClass())) {
+                IType mainType = ProjectUtils.getJavaProject(mainProject).findType(params.getMainClass());
+                if (mainType != null && mainType.getResource() != null) {
+                    currentResource = mainType.getResource();
+                }
+            }
+
+            List<IMarker> problemMarkers = new ArrayList<>();
+            if (currentResource != null) {
+                List<IMarker> markers = ResourceUtils.getErrorMarkers(currentResource);
+                if (markers != null) {
+                    problemMarkers.addAll(markers);
+                }
+
+                // Check if the referenced projects contain compilation errors.
+                if (currentResource instanceof IProject && ProjectUtils.isJavaProject((IProject) currentResource)) {
+                    IJavaProject currentJavaProject = ProjectUtils.getJavaProject((IProject) currentResource);
+                    IJavaProject[] javaProjects = ProjectUtils.getJavaProjects();
+                    for (IJavaProject otherJavaProject : javaProjects) {
+                        IProject other = otherJavaProject.getProject();
+                        if (!other.equals(getDefaultProject()) && !other.equals((IProject) currentResource)
+                            && currentJavaProject.isOnClasspath(otherJavaProject)) {
+                            markers = ResourceUtils.getErrorMarkers(other);
+                            if (markers != null) {
+                                problemMarkers.addAll(markers);
+                            }
+                        }
+                    }
+                }
+            } else {
+                IJavaProject[] javaProjects = ProjectUtils.getJavaProjects();
+                for (IJavaProject javaProject : javaProjects) {
+                    IProject project = javaProject.getProject();
+                    if (!project.equals(getDefaultProject())) {
+                        List<IMarker> markers = ResourceUtils.getErrorMarkers(project);
+                        if (markers != null) {
+                            problemMarkers.addAll(markers);
+                        }
+                    }
+                }
+            }
+
+            if (!problemMarkers.isEmpty()) {
+                return BuildWorkspaceStatus.WITH_ERROR;
+            }
+        } catch (CoreException e) {
+            JavaLanguageServerPlugin.log(e);
+        }
+
+        return BuildWorkspaceStatus.SUCCEED;
+    }
+
+    private static boolean isUnmanagedFolder(IProject project) {
+        return project != null && ProjectUtils.isUnmanagedFolder(project)
+            && ProjectUtils.isJavaProject(project);
+    }
+
+    private static IProject getDefaultProject() {
+        return getWorkspaceRoot().getProject(ProjectsManager.DEFAULT_PROJECT_NAME);
+    }
+
+    private static IWorkspaceRoot getWorkspaceRoot() {
+        return ResourcesPlugin.getWorkspace().getRoot();
+    }
+
+    class CompileParams {
+        String projectName;
+        String mainClass;
+        boolean isFullBuild = false;
+
+        public String getMainClass() {
+            return mainClass;
+        }
+
+        public boolean isFullBuild() {
+            return isFullBuild;
+        }
+
+        public String getProjectName() {
+            return projectName;
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/CompletionProposalRequestor.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/CompletionProposalRequestor.java
new file mode 100644
index 000000000..431c283f5
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/CompletionProposalRequestor.java
@@ -0,0 +1,400 @@
+/*******************************************************************************
+ * Copyright (c) 2016-2018 Red Hat Inc. and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Copied form org.eclipse.jdt.ls.core.internal.contentassist.CompletionsProvider and modified it for class file completion.
+ *
+ * Contributors:
+ *     Red Hat Inc. - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.jdt.core.CompletionContext;
+import org.eclipse.jdt.core.CompletionProposal;
+import org.eclipse.jdt.core.CompletionRequestor;
+import org.eclipse.jdt.core.Flags;
+import org.eclipse.jdt.core.IClassFile;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.ITypeRoot;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jdt.ls.core.internal.JavaLanguageServerPlugin;
+import org.eclipse.jdt.ls.core.internal.contentassist.CompletionProposalDescriptionProvider;
+import org.eclipse.jdt.ls.core.internal.contentassist.GetterSetterCompletionProposal;
+import org.eclipse.jdt.ls.core.internal.contentassist.SortTextHelper;
+import org.eclipse.jdt.ls.core.internal.handlers.CompletionResolveHandler;
+import org.eclipse.jdt.ls.core.internal.handlers.CompletionResponse;
+import org.eclipse.jdt.ls.core.internal.handlers.CompletionResponses;
+import org.eclipse.lsp4j.CompletionItem;
+import org.eclipse.lsp4j.CompletionItemKind;
+import org.eclipse.lsp4j.CompletionItemLabelDetails;
+
+import com.google.common.collect.ImmutableSet;
+import com.microsoft.java.debug.core.Configuration;
+
+
+@SuppressWarnings("restriction")
+public final class CompletionProposalRequestor extends CompletionRequestor {
+
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+
+    private List<CompletionProposal> proposals = new ArrayList<>();
+    private final ITypeRoot typeRoot;
+    private CompletionProposalDescriptionProvider descriptionProvider;
+    private CompletionResponse response;
+    private boolean isTestCodeExcluded;
+    private CompletionContext context;
+
+    // Update SUPPORTED_KINDS when mapKind changes
+    // @formatter:off
+    public static final Set<CompletionItemKind> SUPPORTED_KINDS = ImmutableSet.of(CompletionItemKind.Constructor,
+            CompletionItemKind.Class, CompletionItemKind.Module, CompletionItemKind.Field, CompletionItemKind.Keyword,
+            CompletionItemKind.Reference, CompletionItemKind.Variable, CompletionItemKind.Function,
+            CompletionItemKind.Text);
+    // @formatter:on
+
+    private static boolean isFilterFailed = false;
+
+    /**
+     * Constructor.
+     * @param typeRoot ITypeRoot
+     * @param offset within the source file
+     */
+    public CompletionProposalRequestor(ITypeRoot typeRoot, int offset) {
+        this.typeRoot = typeRoot;
+        response = new CompletionResponse();
+        response.setOffset(offset);
+        if (typeRoot instanceof IClassFile)  {
+            isTestCodeExcluded = true;
+        } else {
+            isTestCodeExcluded = !isTestSource(typeRoot.getJavaProject(), typeRoot);
+        }
+        setRequireExtendedContext(true);
+    }
+
+    private boolean isTestSource(IJavaProject project, ITypeRoot cu) {
+        if (project == null) {
+            return true;
+        }
+        try {
+            IClasspathEntry[] resolvedClasspath = project.getResolvedClasspath(true);
+            final IPath resourcePath = cu.getResource().getFullPath();
+            for (IClasspathEntry e : resolvedClasspath) {
+                if (e.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
+                    if (e.isTest()) {
+                        if (e.getPath().isPrefixOf(resourcePath)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        } catch (JavaModelException e) {
+            logger.log(Level.WARNING, String.format("Failed to judge the cu scope: %s", e.toString()), e);
+        }
+        return false;
+    }
+
+    @Override
+    public void accept(CompletionProposal proposal) {
+        if (isFiltered(proposal)) {
+            return;
+        }
+
+        if (!isIgnored(proposal.getKind())) {
+            if (proposal.getKind() == CompletionProposal.POTENTIAL_METHOD_DECLARATION) {
+                acceptPotentialMethodDeclaration(proposal);
+            } else {
+                if (proposal.getKind() == CompletionProposal.PACKAGE_REF && typeRoot.getParent() != null
+                        && String.valueOf(proposal.getCompletion()).equals(typeRoot.getParent().getElementName())) {
+                    // Hacky way to boost relevance of current package, for package completions,
+                    // until
+                    // https://bugs.eclipse.org/518140 is fixed
+                    proposal.setRelevance(proposal.getRelevance() + 1);
+                }
+                proposals.add(proposal);
+            }
+        }
+    }
+
+    /**
+     * Return the completion list requested.
+     * @return list of the completion item.
+     */
+    public List<CompletionItem> getCompletionItems() {
+        response.setProposals(proposals);
+        CompletionResponses.store(response);
+        List<CompletionItem> completionItems = new ArrayList<>(proposals.size());
+        for (int i = 0; i < proposals.size(); i++) {
+            completionItems.add(toCompletionItem(proposals.get(i), i));
+        }
+        return completionItems;
+    }
+
+    /**
+     * To completion item.
+     * @param proposal proposal
+     * @param index index
+     * @return CompletionItem
+     */
+    public CompletionItem toCompletionItem(CompletionProposal proposal, int index) {
+        final CompletionItem $ = new CompletionItem();
+        $.setKind(mapKind(proposal.getKind(), proposal.getFlags()));
+        Map<String, String> data = new HashMap<>();
+        data.put(CompletionResolveHandler.DATA_FIELD_REQUEST_ID, String.valueOf(response.getId()));
+        data.put(CompletionResolveHandler.DATA_FIELD_PROPOSAL_ID, String.valueOf(index));
+        $.setData(data);
+        this.descriptionProvider.updateDescription(proposal, $);
+        // Use fully qualified name as needed.
+        $.setInsertText(String.valueOf(proposal.getCompletion()));
+        adjustCompleteItem($);
+        $.setSortText(SortTextHelper.computeSortText(proposal));
+        return $;
+    }
+
+    private void adjustCompleteItem(CompletionItem item) {
+        CompletionItemKind itemKind = item.getKind();
+        if (itemKind == CompletionItemKind.Class || itemKind == CompletionItemKind.Interface
+            || itemKind == CompletionItemKind.Enum) {
+            // Display the package name in the label property.
+            CompletionItemLabelDetails labelDetails = item.getLabelDetails();
+            if (labelDetails != null && StringUtils.isNotBlank(labelDetails.getDescription())) {
+                item.setLabel(item.getLabel() + " - " + labelDetails.getDescription());
+            }
+        } else if (itemKind == CompletionItemKind.Function) {
+            // Merge the label details into the label property
+            // because the completion provider in DEBUG CONSOLE
+            // doesn't support the label details.
+            CompletionItemLabelDetails labelDetails = item.getLabelDetails();
+            if (labelDetails != null && StringUtils.isNotBlank(labelDetails.getDetail())) {
+                item.setLabel(item.getLabel() + labelDetails.getDetail());
+            }
+            if (labelDetails != null && StringUtils.isNotBlank(labelDetails.getDescription())) {
+                item.setLabel(item.getLabel() + " : " + labelDetails.getDescription());
+            }
+
+            String text = item.getInsertText();
+            if (StringUtils.isNotBlank(text) && !text.endsWith(")")) {
+                item.setInsertText(text + "()");
+            }
+        }
+    }
+
+    @Override
+    public void acceptContext(CompletionContext context) {
+        super.acceptContext(context);
+        this.context = context;
+        response.setContext(context);
+        this.descriptionProvider = new CompletionProposalDescriptionProvider(context);
+    }
+
+    private CompletionItemKind mapKind(final int kind, final int flags) {
+        // When a new CompletionItemKind is added, don't forget to update
+        // SUPPORTED_KINDS
+        switch (kind) {
+            case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION:
+            case CompletionProposal.CONSTRUCTOR_INVOCATION:
+                return CompletionItemKind.Constructor;
+            case CompletionProposal.ANONYMOUS_CLASS_DECLARATION:
+            case CompletionProposal.TYPE_REF:
+                if (Flags.isInterface(flags)) {
+                    return CompletionItemKind.Interface;
+                } else if (Flags.isEnum(flags)) {
+                    return CompletionItemKind.Enum;
+                }
+                return CompletionItemKind.Class;
+            case CompletionProposal.FIELD_IMPORT:
+            case CompletionProposal.METHOD_IMPORT:
+            case CompletionProposal.METHOD_NAME_REFERENCE:
+            case CompletionProposal.PACKAGE_REF:
+            case CompletionProposal.TYPE_IMPORT:
+                return CompletionItemKind.Module;
+            case CompletionProposal.FIELD_REF:
+            case CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER:
+                if (Flags.isStatic(flags) && Flags.isFinal(flags)) {
+                    return CompletionItemKind.Constant;
+                }
+                return CompletionItemKind.Field;
+            case CompletionProposal.KEYWORD:
+                return CompletionItemKind.Keyword;
+            case CompletionProposal.LABEL_REF:
+                return CompletionItemKind.Reference;
+            case CompletionProposal.LOCAL_VARIABLE_REF:
+            case CompletionProposal.VARIABLE_DECLARATION:
+                return CompletionItemKind.Variable;
+            case CompletionProposal.METHOD_DECLARATION:
+            case CompletionProposal.METHOD_REF:
+            case CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER:
+            case CompletionProposal.POTENTIAL_METHOD_DECLARATION:
+                return CompletionItemKind.Function;
+            // text
+            case CompletionProposal.ANNOTATION_ATTRIBUTE_REF:
+            case CompletionProposal.JAVADOC_BLOCK_TAG:
+            case CompletionProposal.JAVADOC_FIELD_REF:
+            case CompletionProposal.JAVADOC_INLINE_TAG:
+            case CompletionProposal.JAVADOC_METHOD_REF:
+            case CompletionProposal.JAVADOC_PARAM_REF:
+            case CompletionProposal.JAVADOC_TYPE_REF:
+            case CompletionProposal.JAVADOC_VALUE_REF:
+            default:
+                return CompletionItemKind.Text;
+        }
+    }
+
+    @Override
+    public void setIgnored(int completionProposalKind, boolean ignore) {
+        super.setIgnored(completionProposalKind, ignore);
+        if (completionProposalKind == CompletionProposal.METHOD_DECLARATION && !ignore) {
+            setRequireExtendedContext(true);
+        }
+    }
+
+    private void acceptPotentialMethodDeclaration(CompletionProposal proposal) {
+        try {
+            IJavaElement enclosingElement = null;
+            if (response.getContext().isExtended()) {
+                enclosingElement = response.getContext().getEnclosingElement();
+            } else if (typeRoot != null) {
+                // kept for backward compatibility: CU is not reconciled at this moment,
+                // information is missing (bug 70005)
+                enclosingElement = typeRoot.getElementAt(proposal.getCompletionLocation() + 1);
+            }
+            if (enclosingElement == null) {
+                return;
+            }
+            IType type = (IType) enclosingElement.getAncestor(IJavaElement.TYPE);
+            if (type != null) {
+                String prefix = String.valueOf(proposal.getName());
+                int completionStart = proposal.getReplaceStart();
+                int completionEnd = proposal.getReplaceEnd();
+                int relevance = proposal.getRelevance() + 6;
+
+                GetterSetterCompletionProposal.evaluateProposals(type, prefix, completionStart,
+                        completionEnd - completionStart, relevance, proposals);
+            }
+        } catch (CoreException e) {
+            JavaLanguageServerPlugin.logException("Accept potential method declaration failed for completion ", e);
+        }
+    }
+
+    @Override
+    public boolean isTestCodeExcluded() {
+        return isTestCodeExcluded;
+    }
+
+    public CompletionContext getContext() {
+        return context;
+    }
+
+    /**
+     * copied from
+     * org.eclipse.jdt.ui.text.java.CompletionProposalCollector.isFiltered(CompletionProposal)
+     */
+    private boolean isFiltered(CompletionProposal proposal) {
+        if (isIgnored(proposal.getKind())) {
+            return true;
+        }
+
+        try {
+            // Only filter types and constructors from completion.
+            // Methods from already imported types and packages can still be proposed.
+            // See https://github.com/eclipse/eclipse.jdt.ls/issues/1212
+            switch (proposal.getKind()) {
+                case CompletionProposal.CONSTRUCTOR_INVOCATION:
+                case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION:
+                case CompletionProposal.JAVADOC_TYPE_REF:
+                case CompletionProposal.TYPE_REF: {
+                    char[] declaringType = getDeclaringType(proposal);
+                    return declaringType != null && isFiltered(declaringType);
+                }
+                default: // do nothing
+            }
+        } catch (Exception e) {
+            // do nothing
+        }
+
+        return false;
+    }
+
+    // Temp workaround for the completion error https://github.com/microsoft/java-debug/issues/534
+    private static boolean isFiltered(char[] fullTypeName) {
+        if (isFilterFailed) {
+            return false;
+        }
+
+        try {
+            return JavaLanguageServerPlugin.getInstance().getTypeFilter().filter(new String(fullTypeName));
+        } catch (NoSuchMethodError ex) {
+            isFilterFailed = true;
+            JavaLanguageServerPlugin.logException("isFiltered for the completion failed.", ex);
+        }
+
+        return false;
+    }
+
+    /**
+     * copied from
+     * org.eclipse.jdt.ui.text.java.CompletionProposalCollector.getDeclaringType(CompletionProposal)
+     */
+    private final char[] getDeclaringType(CompletionProposal proposal) {
+        switch (proposal.getKind()) {
+            case CompletionProposal.METHOD_DECLARATION:
+            case CompletionProposal.METHOD_NAME_REFERENCE:
+            case CompletionProposal.JAVADOC_METHOD_REF:
+            case CompletionProposal.METHOD_REF:
+            case CompletionProposal.CONSTRUCTOR_INVOCATION:
+            case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION:
+            case CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER:
+            case CompletionProposal.ANNOTATION_ATTRIBUTE_REF:
+            case CompletionProposal.POTENTIAL_METHOD_DECLARATION:
+            case CompletionProposal.ANONYMOUS_CLASS_DECLARATION:
+            case CompletionProposal.FIELD_REF:
+            case CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER:
+            case CompletionProposal.JAVADOC_FIELD_REF:
+            case CompletionProposal.JAVADOC_VALUE_REF:
+                char[] declaration = proposal.getDeclarationSignature();
+                // special methods may not have a declaring type: methods defined on arrays etc.
+                // Currently known: class literals don't have a declaring type - use Object
+                if (declaration == null) {
+                    return "java.lang.Object".toCharArray(); //$NON-NLS-1$
+                }
+                return Signature.toCharArray(declaration);
+            case CompletionProposal.PACKAGE_REF:
+            case CompletionProposal.MODULE_REF:
+            case CompletionProposal.MODULE_DECLARATION:
+                return proposal.getDeclarationSignature();
+            case CompletionProposal.JAVADOC_TYPE_REF:
+            case CompletionProposal.TYPE_REF:
+                return Signature.toCharArray(proposal.getSignature());
+            case CompletionProposal.LOCAL_VARIABLE_REF:
+            case CompletionProposal.VARIABLE_DECLARATION:
+            case CompletionProposal.KEYWORD:
+            case CompletionProposal.LABEL_REF:
+            case CompletionProposal.JAVADOC_BLOCK_TAG:
+            case CompletionProposal.JAVADOC_INLINE_TAG:
+            case CompletionProposal.JAVADOC_PARAM_REF:
+                return null;
+            default:
+                Assert.isTrue(false);
+                return null;
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/CompletionsProvider.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/CompletionsProvider.java
new file mode 100644
index 000000000..19b808161
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/CompletionsProvider.java
@@ -0,0 +1,125 @@
+/*******************************************************************************
+* Copyright (c) 2018 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jdt.core.CompletionProposal;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.ITypeRoot;
+import org.eclipse.jdt.ls.core.internal.handlers.JsonRpcHelpers;
+
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.adapter.ICompletionsProvider;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
+import com.microsoft.java.debug.core.protocol.Types.CompletionItem;
+import com.sun.jdi.StackFrame;
+
+public class CompletionsProvider implements ICompletionsProvider {
+
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+
+    private IDebugAdapterContext context;
+
+    @Override
+    public void initialize(IDebugAdapterContext context, Map<String, Object> options) {
+        this.context = context;
+    }
+
+    @Override
+    public List<CompletionItem> codeComplete(StackFrame frame, String snippet, int line, int column) {
+        List<CompletionItem> res = new ArrayList<CompletionItem>();
+
+        try {
+            IType type = resolveType(frame);
+            if (type != null) {
+                ITypeRoot r = type.getCompilationUnit() != null ? type.getCompilationUnit() : type.getClassFile();
+                final int offset = JsonRpcHelpers.toOffset(r.getBuffer(), frame.location().lineNumber(), 0);
+                CompletionProposalRequestor collector = new CompletionProposalRequestor(r, offset);
+
+                collector.setAllowsRequiredProposals(CompletionProposal.FIELD_REF, CompletionProposal.TYPE_REF, true);
+                collector.setAllowsRequiredProposals(CompletionProposal.FIELD_REF, CompletionProposal.TYPE_IMPORT, true);
+                collector.setAllowsRequiredProposals(CompletionProposal.FIELD_REF, CompletionProposal.FIELD_IMPORT, true);
+
+                collector.setAllowsRequiredProposals(CompletionProposal.METHOD_REF, CompletionProposal.TYPE_REF, true);
+                collector.setAllowsRequiredProposals(CompletionProposal.METHOD_REF, CompletionProposal.TYPE_IMPORT, true);
+                collector.setAllowsRequiredProposals(CompletionProposal.METHOD_REF, CompletionProposal.METHOD_IMPORT, true);
+
+                collector.setAllowsRequiredProposals(CompletionProposal.CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF, true);
+
+                collector.setAllowsRequiredProposals(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF, true);
+                collector.setAllowsRequiredProposals(CompletionProposal.ANONYMOUS_CLASS_DECLARATION, CompletionProposal.TYPE_REF, true);
+
+                collector.setAllowsRequiredProposals(CompletionProposal.TYPE_REF, CompletionProposal.TYPE_REF, true);
+
+                int position = getInsertPosition(snippet, line, column);
+                type.codeComplete(snippet.toCharArray(), offset, position, null, null, null, frame.location().method().isStatic(), collector);
+
+                List<org.eclipse.lsp4j.CompletionItem> items = collector.getCompletionItems();
+
+                if (items != null) {
+                    for (org.eclipse.lsp4j.CompletionItem lspItem : items) {
+                        res.add(convertFromLsp(lspItem));
+                    }
+                }
+            }
+
+        } catch (DebugException | CoreException e) {
+            logger.log(Level.SEVERE, String.format("Failed to code complete because of %s", e.toString()), e);
+        }
+
+        return res;
+    }
+
+    private int getInsertPosition(String snippet, int line, int column) {
+        int lineInSnippet = context.isClientLinesStartAt1() ? line - 1 : line;
+        int offsetInSnippet = -1;
+        for (int i = 0; i < lineInSnippet; i++) {
+            offsetInSnippet = snippet.indexOf('\n', offsetInSnippet + 1);
+        }
+
+        offsetInSnippet++;
+        return offsetInSnippet + column + (context.isClientColumnsStartAt1() ?  -1 : 0);
+    }
+
+    private IType resolveType(StackFrame frame) throws CoreException, DebugException {
+        ISourceLookUpProvider sourceProvider = context.getProvider(ISourceLookUpProvider.class);
+        if (sourceProvider instanceof JdtSourceLookUpProvider) {
+            IJavaProject project = JdtUtils.findProject(frame, ((JdtSourceLookUpProvider) sourceProvider).getSourceContainers());
+            if (project != null) {
+                return project.findType(JdtUtils.getDeclaringTypeName(frame));
+            }
+        }
+        return null;
+    }
+
+    private CompletionItem convertFromLsp(org.eclipse.lsp4j.CompletionItem lspItem) {
+        CompletionItem item = new CompletionItem(lspItem.getLabel(), lspItem.getInsertText());
+        if (lspItem.getKind() != null) {
+            item.type = lspItem.getKind().name().toLowerCase();
+        }
+
+        if (lspItem.getSortText() != null) {
+            item.sortText = lspItem.getSortText();
+        }
+
+        return item;
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/DebugSettingUtils.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/DebugSettingUtils.java
new file mode 100644
index 000000000..183c5571c
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/DebugSettingUtils.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.google.gson.JsonSyntaxException;
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.protocol.JsonUtils;
+
+public final class DebugSettingUtils {
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+
+    /**
+     * Configure setting for java debugger.
+     *
+     * @param arguments
+     *            the arguments for the settings, the format is json,
+     *            eg:{"showHex":true,"showStaticVariables":true,"maxStringLength":100}
+     */
+    public static Object configDebugSettings(List<Object> arguments) {
+        if (arguments != null && arguments.size() > 0) {
+            arguments.forEach(arg -> {
+                if (arg instanceof String) {
+                    String jsonStr = (String) arg;
+
+                    try {
+                        DebugSettings.getCurrent().updateSettings(jsonStr);
+                        DebugSettings.getCurrent().logLevel = LogUtils.configLogLevel(DebugSettings.getCurrent().logLevel);
+                    } catch (JsonSyntaxException ex) {
+                        logger.severe(String.format("Parameters for userSettings must be a valid json: %s", String.valueOf(arg)));
+                    }
+
+                } else {
+                    logger.severe(String.format("Parameters for userSettings must be json string: %s", String.valueOf(arg)));
+                }
+            });
+
+        } else {
+            logger.severe(String.format("Invalid parameters for debugSettings: %s", StringUtils.join(arguments.toArray(), ',')));
+        }
+        return JsonUtils.toJson(DebugSettings.getCurrent());
+    }
+
+    /**
+     * Private constructor to prevent creating instance of this class.
+     */
+    private DebugSettingUtils() {
+
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/InlineValueHandler.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/InlineValueHandler.java
new file mode 100644
index 000000000..15aeeb2b4
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/InlineValueHandler.java
@@ -0,0 +1,644 @@
+/*******************************************************************************
+* Copyright (c) 2021 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jdt.core.Flags;
+import org.eclipse.jdt.core.IBuffer;
+import org.eclipse.jdt.core.IClassFile;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.ISourceRange;
+import org.eclipse.jdt.core.ISourceReference;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.ITypeRoot;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
+import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
+import org.eclipse.jdt.core.dom.Block;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.DoStatement;
+import org.eclipse.jdt.core.dom.ForStatement;
+import org.eclipse.jdt.core.dom.IBinding;
+import org.eclipse.jdt.core.dom.ITypeBinding;
+import org.eclipse.jdt.core.dom.SimpleName;
+import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
+import org.eclipse.jdt.core.dom.SwitchStatement;
+import org.eclipse.jdt.core.dom.TypeDeclarationStatement;
+import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
+import org.eclipse.jdt.core.dom.WhileStatement;
+import org.eclipse.jdt.core.dom.IVariableBinding;
+import org.eclipse.jdt.core.dom.IfStatement;
+import org.eclipse.jdt.core.dom.ImportDeclaration;
+import org.eclipse.jdt.core.dom.LambdaExpression;
+import org.eclipse.jdt.core.dom.MethodDeclaration;
+import org.eclipse.jdt.core.dom.ModuleDeclaration;
+import org.eclipse.jdt.core.dom.PackageDeclaration;
+import org.eclipse.jdt.core.dom.QualifiedName;
+import org.eclipse.jdt.core.dom.QualifiedType;
+import org.eclipse.jdt.core.manipulation.CoreASTProvider;
+import org.eclipse.jdt.ls.core.internal.JDTUtils;
+import org.eclipse.jdt.ls.core.internal.handlers.JsonRpcHelpers;
+import org.eclipse.lsp4j.Position;
+import org.eclipse.lsp4j.Range;
+
+public class InlineValueHandler {
+
+    /**
+     * Find the valid inline variables belonging to the visible view port.
+     */
+    public static InlineVariable[] resolveInlineVariables(InlineParams params, IProgressMonitor monitor) {
+        ITypeRoot root = JDTUtils.resolveTypeRoot(params.uri);
+        try {
+            if (root == null || root.getBuffer() == null) {
+                return new InlineVariable[0];
+            }
+
+            Position stoppedLocation = params.stoppedLocation.getStart();
+            int stoppedOffset = JsonRpcHelpers.toOffset(root.getBuffer(), stoppedLocation.getLine(), stoppedLocation.getCharacter());
+            IMethod enclosingMethod = findEnclosingMethod(root, stoppedOffset);
+            if (enclosingMethod == null) {
+                return new InlineVariable[0];
+            }
+
+            Position startLocation = getPosition(root.getBuffer(), enclosingMethod.getSourceRange().getOffset());
+            Range stoppedRange = new Range(startLocation, stoppedLocation);
+            if (params.viewPort != null
+                && (params.viewPort.getEnd().getLine() < startLocation.getLine() || params.viewPort.getStart().getLine() > stoppedLocation.getLine())) {
+                return new InlineVariable[0];
+            }
+
+            CompilationUnit astRoot = CoreASTProvider.getInstance().getAST(root, CoreASTProvider.WAIT_YES, monitor);
+            VariableVisitor visitor = new VariableVisitor(astRoot, stoppedRange, params.viewPort, Flags.isStatic(enclosingMethod.getFlags()));
+            astRoot.accept(visitor);
+            InlineVariable[] result = visitor.getInlineVariables();
+            return result;
+        } catch (JavaModelException e) {
+            return new InlineVariable[0];
+        }
+    }
+
+    private static IMethod findEnclosingMethod(ITypeRoot root, int stoppedOffset) throws JavaModelException {
+        IType enclosingType = null;
+        if (root instanceof ICompilationUnit) {
+            IType[] types = ((ICompilationUnit) root).getAllTypes();
+            for (IType type : types) {
+                if (isEnclosed(type, stoppedOffset)) {
+                    enclosingType = type;
+                }
+            }
+        } else if (root instanceof IClassFile) {
+            enclosingType = ((IClassFile) root).getType();
+        }
+
+        if (enclosingType == null) {
+            return null;
+        }
+
+        IMethod enclosingMethod = null;
+        for (IMethod method : enclosingType.getMethods()) {
+            if (isEnclosed(method, stoppedOffset)) {
+                enclosingMethod = method;
+                break;
+            }
+        }
+
+        if (enclosingMethod == null) {
+            return null;
+        }
+
+        // Deal with the scenario that the stopped location is inside the local types defined in method.
+        return findMethodInLocalTypes(enclosingMethod, stoppedOffset);
+    }
+
+    private static boolean isEnclosed(ISourceReference sourceReference, int offset) throws JavaModelException {
+        ISourceRange sourceRange = sourceReference.getSourceRange();
+        return sourceRange != null && offset >= sourceRange.getOffset()
+                && offset < sourceRange.getOffset() + sourceRange.getLength();
+    }
+
+    private static IMethod findMethodInLocalTypes(IMethod enclosingMethod, int stoppedOffset) throws JavaModelException {
+        if (enclosingMethod == null) {
+            return null;
+        }
+
+        for (IJavaElement element : enclosingMethod.getChildren()) {
+            if (element instanceof IType) {
+                if (isEnclosed((IType) element, stoppedOffset)) {
+                    for (IMethod method : ((IType) element).getMethods()) {
+                        if (isEnclosed(method, stoppedOffset)) {
+                            IMethod nearerMethod = findMethodInLocalTypes(method, stoppedOffset);
+                            return nearerMethod == null ? enclosingMethod : nearerMethod;
+                        }
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        return enclosingMethod;
+    }
+
+    /**
+     * Returns the zero based line and column number.
+     */
+    private static Position getPosition(IBuffer buffer, int offset) {
+        int[] result = JsonRpcHelpers.toLine(buffer, offset);
+        if (result == null || result.length < 1) {
+            return new Position(-1, -1);
+        }
+
+        return new Position(result[0], result[1]);
+    }
+
+    static class VariableVisitor extends ASTVisitor {
+        private CompilationUnit unit = null;
+        private Range stoppedSourceRange;
+        private Range viewPort;
+        private boolean isStoppingAtStaticMethod;
+        private int baseLine;
+        private Set<Token>[] tokens;
+        private List<String> localVarDecls = new ArrayList<>();
+        private List<Position> localVarDeclPositions = new ArrayList<>();
+        private boolean isStoppingAtLambda = false;
+        private Set<String> varDeclsAtLastLine = new HashSet<>();
+        private Range visibleInlineRange = null;
+
+        public VariableVisitor(CompilationUnit unit, Range stoppedSourceRange, Range viewPort, boolean stopAtStaticMethod) {
+            this.unit = unit;
+            this.stoppedSourceRange = stoppedSourceRange;
+            this.viewPort = viewPort;
+            this.isStoppingAtStaticMethod = stopAtStaticMethod;
+            this.baseLine = stoppedSourceRange.getStart().getLine();
+            this.tokens = new Set[stoppedSourceRange.getEnd().getLine() - stoppedSourceRange.getStart().getLine() + 1];
+            updateVisibleRange();
+        }
+
+        private void updateVisibleRange() {
+            if (viewPort == null) {
+                visibleInlineRange = stoppedSourceRange;
+            } else if (compare(viewPort.getStart(), stoppedSourceRange.getEnd()) > 0
+                    || compare(viewPort.getEnd(), stoppedSourceRange.getStart()) < 0) {
+                visibleInlineRange = null;
+            } else {
+                Position start = compare(viewPort.getStart(), stoppedSourceRange.getStart()) >= 0 ? viewPort.getStart() : stoppedSourceRange.getStart();
+                Position end = compare(viewPort.getEnd(), stoppedSourceRange.getEnd()) <= 0 ? viewPort.getEnd() : stoppedSourceRange.getEnd();
+                visibleInlineRange = new Range(start, end);
+            }
+        }
+
+        /**
+         * Handle the variables in the visible source ranges.
+         */
+        @Override
+        public boolean visit(SimpleName node) {
+            if (visibleInlineRange == null) {
+                return false;
+            }
+
+            Position startPosition = getStartPosition(node);
+            boolean isAtLastLine = isAtStopLocation(startPosition);
+            if (isEnclosed(visibleInlineRange, startPosition) || isAtLastLine) {
+                IBinding binding = node.resolveBinding();
+                if (!(binding instanceof IVariableBinding)) {
+                    return false;
+                } else if (isAtLastLine && this.varDeclsAtLastLine.contains(binding.getKey())) {
+                    return false;
+                }
+
+                String declaringClass = null;
+                if (((IVariableBinding) binding).isField()) {
+                    ITypeBinding typeBinding = ((IVariableBinding) binding).getDeclaringClass();
+                    if (typeBinding == null) {
+                        return false;
+                    }
+
+                    declaringClass = typeBinding.getBinaryName();
+                }
+
+                Token token = new Token(node.getIdentifier(), startPosition, declaringClass);
+                int index = startPosition.getLine() - baseLine;
+                if (tokens[index] == null) {
+                    tokens[index] = new LinkedHashSet<>();
+                }
+
+                if (!tokens[index].contains(token)) {
+                    tokens[index].add(token);
+                }
+            }
+
+            return false;
+        }
+
+        /**
+         * Handle local variable declarations happening in current method.
+         */
+        @Override
+        public boolean visit(VariableDeclarationFragment node) {
+            SimpleName name = node.getName();
+            Position startPosition = getStartPosition(name);
+            if (isEnclosed(stoppedSourceRange, startPosition)) {
+                this.localVarDecls.add(name.getIdentifier());
+                this.localVarDeclPositions.add(startPosition);
+            }
+
+            if (isAtStopLocation(startPosition)) {
+                IVariableBinding binding = node.resolveBinding();
+                if (binding != null) {
+                    this.varDeclsAtLastLine.add(binding.getKey());
+                }
+            }
+
+            return true;
+        }
+
+        /**
+         * Handle formal parameter declarations happening in current method.
+         */
+        @Override
+        public boolean visit(SingleVariableDeclaration node) {
+            SimpleName name = node.getName();
+            Position startPosition = getStartPosition(name);
+            if (isEnclosed(stoppedSourceRange, startPosition)) {
+                this.localVarDecls.add(name.getIdentifier());
+                this.localVarDeclPositions.add(startPosition);
+            }
+
+            return false;
+        }
+
+        /**
+         * Handle the lambda expression containing the stopped location.
+         * If the execution instruction stops on a lambda expression, then
+         * crop the visible source ranges to the lambda expression body.
+         */
+        @Override
+        public boolean visit(LambdaExpression node) {
+            Position startPosition = getStartPosition(node);
+            Position endPosition = getEndPosition(node);
+            if (compare(startPosition, stoppedSourceRange.getStart()) >= 0
+                && isEnclosed(new Range(startPosition, endPosition), stoppedSourceRange.getEnd())) {
+                stoppedSourceRange.setStart(startPosition);
+                updateVisibleRange();
+                isStoppingAtLambda = true;
+                localVarDecls.clear();
+                localVarDeclPositions.clear();
+                return true;
+            }
+
+            return super.visit(node);
+        }
+
+        /**
+         * Handle the method containing the stopped location.
+         */
+        @Override
+        public boolean visit(MethodDeclaration node) {
+            Position startPosition = getStartPosition(node);
+            Position endPosition = getEndPosition(node);
+            if (compare(startPosition, stoppedSourceRange.getStart()) <= 0 && compare(endPosition, stoppedSourceRange.getEnd()) >= 0) {
+                return true;
+            }
+
+            return false;
+        }
+
+        @Override
+        public boolean visit(Block node) {
+            if (isUnreachableNode(node)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        @Override
+        public boolean visit(DoStatement node) {
+            if (isUnreachableNode(node) && !isAtStopLocation(node)) {
+                return false;
+            }
+
+            return super.visit(node);
+        }
+
+        @Override
+        public boolean visit(ForStatement node) {
+            if (isUnreachableNode(node) && !isAtStopLocation(node)) {
+                return false;
+            }
+
+            return super.visit(node);
+        }
+
+        @Override
+        public boolean visit(IfStatement node) {
+            if (isUnreachableNode(node) && !isAtStopLocation(node)) {
+                return false;
+            }
+
+            return super.visit(node);
+        }
+
+        @Override
+        public boolean visit(SwitchStatement node) {
+            if (isUnreachableNode(node) && !isAtStopLocation(node)) {
+                return false;
+            }
+
+            return super.visit(node);
+        }
+
+        @Override
+        public boolean visit(WhileStatement node) {
+            if (isUnreachableNode(node) && !isAtStopLocation(node)) {
+                return false;
+            }
+
+            return super.visit(node);
+        }
+
+        @Override
+        public boolean visit(AnnotationTypeDeclaration node) {
+            if (isUnreachableNode(node)) {
+                return false;
+            }
+
+            return super.visit(node);
+        }
+
+        @Override
+        public boolean visit(AnonymousClassDeclaration node) {
+            if (isUnreachableNode(node)) {
+                return false;
+            }
+
+            return super.visit(node);
+        }
+
+        @Override
+        public boolean visit(TypeDeclarationStatement node) {
+            if (isUnreachableNode(node)) {
+                return false;
+            }
+
+            return super.visit(node);
+        }
+
+        @Override
+        public boolean visit(ImportDeclaration node) {
+            return false;
+        }
+
+        @Override
+        public boolean visit(ModuleDeclaration node) {
+            return false;
+        }
+
+        @Override
+        public boolean visit(PackageDeclaration node) {
+            return false;
+        }
+
+        @Override
+        public boolean visit(QualifiedName node) {
+            return Objects.equals("length", node.getName().getIdentifier());
+        }
+
+        @Override
+        public boolean visit(QualifiedType node) {
+            return false;
+        }
+
+        /**
+         * Return the valid inline variables in the visible source ranges.
+         *
+         * <p>There are four typical kinds of variable:
+         * - Local variables declared in method body.
+         * - Formal parameters declared in method declaration.
+         * - Field variables.
+         * - Captured variables from outer scope. This includes local type is accessing
+         * variables of enclosing method, and lambda expression body is accessing to
+         * variables of enclosing method.</p>
+         *
+         * <p>For the first two kinds such as local variables and formal parameters,
+         * we're going to return them with VariableLookup kind since their values are
+         * expanded by Variables View by default.</p>
+         *
+         * <p>For the last two kinds, we're going to return them with Evaluation kind
+         * since it requires additional evaluation to get its values.</p>
+         */
+        public InlineVariable[] getInlineVariables() {
+            if (visibleInlineRange == null) {
+                return new InlineVariable[0];
+            }
+
+            // Adding the local variable declarations to the token list.
+            for (int i = 0; i < localVarDecls.size(); i++) {
+                String name = localVarDecls.get(i);
+                Position position = localVarDeclPositions.get(i);
+                if (isEnclosed(visibleInlineRange, position)) {
+                    int index = position.getLine() - baseLine;
+                    if (tokens[index] == null) {
+                        tokens[index] = new LinkedHashSet<>();
+                    }
+
+                    Token token = new Token(name, position, null);
+                    if (!tokens[index].contains(token)) {
+                        tokens[index].add(token);
+                    }
+                }
+            }
+
+            // For lambda expression in non static method, the captured variable 'arg$1'
+            // points to 'this' object of the enclosing method, and the index of other
+            // captured variables starts with 2.
+            int capturedArgIndexInLambda = isStoppingAtStaticMethod ? 1 : 2;
+            Map<String, String> capturedVarsInLambda = new HashMap<>();
+            List<InlineVariable> result = new ArrayList<>();
+            for (int i = 0; i < tokens.length; i++) {
+                int line = baseLine + i;
+                if (tokens[i] == null || line < visibleInlineRange.getStart().getLine()) {
+                    continue;
+                }
+
+                for (Token token : tokens[i]) {
+                    if (!isEnclosed(visibleInlineRange, token.position) && !isAtLastVisibleLine(token.position)) {
+                        continue;
+                    }
+
+                    // Local Variables
+                    if (token.declaringClass == null && localVarDecls.contains(token.name)) {
+                        int declIndex = localVarDecls.lastIndexOf(token.name);
+                        Position declPosition = localVarDeclPositions.get(declIndex);
+                        if (compare(token.position, declPosition) >= 0) {
+                            result.add(new InlineVariable(new Range(token.position, token.position), token.name, InlineKind.VariableLookup));
+                            continue;
+                        }
+                    }
+
+                    InlineVariable value = new InlineVariable(
+                        new Range(token.position, token.position), token.name, InlineKind.Evaluation, token.declaringClass);
+                    // Captured variables by lambda expression
+                    if (isStoppingAtLambda && token.declaringClass == null) {
+                        /**
+                         * When the lambda body accesses variables from its "outer" scope such as
+                         * its enclosing method, these variables will be captured as properties of
+                         * 'this' object of a synthetic lambda instance by Java runtime. However,
+                         * when the compiler parses the lambda expression, it erases the specific
+                         * variable name but keeps the captured variable names with format like
+                         * 'arg$<index>'. In order to evaluate the correct value from Java runtime,
+                         * we have to encode the variable name using the same rule 'arg$<index>' as
+                         * the compiler.
+                         */
+                        if (capturedVarsInLambda.containsKey(token.name)) {
+                            value.expression = capturedVarsInLambda.get(token.name);
+                        } else {
+                            value.expression = "arg$" + capturedArgIndexInLambda++;
+                            capturedVarsInLambda.put(token.name, value.expression);
+                        }
+                    }
+
+                    result.add(value);
+                }
+            }
+
+            return result.toArray(new InlineVariable[0]);
+        }
+
+        private Position getStartPosition(ASTNode node) {
+            // Line number returned by AST unit is one based, converts it to zero based.
+            int lineNumber = unit.getLineNumber(node.getStartPosition()) - 1;
+            int columnNumber = unit.getColumnNumber(node.getStartPosition());
+            return new Position(lineNumber, columnNumber);
+        }
+
+        private Position getEndPosition(ASTNode node) {
+            // Line number returned by AST unit is one based, converts it to zero based.
+            int lineNumber = unit.getLineNumber(node.getStartPosition() + node.getLength() - 1) - 1;
+            int columnNumber = unit.getColumnNumber(node.getStartPosition() + node.getLength() - 1);
+            return new Position(lineNumber, columnNumber);
+        }
+
+        private boolean isUnreachableNode(ASTNode node) {
+            Position startPosition = getStartPosition(node);
+            Position endPosition = getEndPosition(node);
+            return compare(startPosition, stoppedSourceRange.getEnd()) > 0
+                || compare(endPosition, stoppedSourceRange.getEnd()) < 0;
+        }
+
+        private boolean isEnclosed(Range range, Position position) {
+            return compare(range.getStart(), position) <= 0 && compare(range.getEnd(), position) >= 0;
+        }
+
+        private int compare(Position p1, Position p2) {
+            if (p1.getLine() < p2.getLine()) {
+                return -1;
+            } else if (p1.getLine() == p2.getLine()) {
+                return p1.getCharacter() - p2.getCharacter();
+            }
+
+            return 1;
+        }
+
+        private boolean isAtStopLocation(Position position) {
+            return position.getLine() == stoppedSourceRange.getEnd().getLine();
+        }
+
+        private boolean isAtStopLocation(ASTNode node) {
+            Position startPosition = getStartPosition(node);
+            return isAtStopLocation(startPosition);
+        }
+
+        private boolean isAtLastVisibleLine(Position position) {
+            return visibleInlineRange != null && visibleInlineRange.getEnd().getLine() == position.getLine();
+        }
+    }
+
+    static class InlineVariable {
+        Range range;
+        String name;
+        InlineKind kind;
+        String expression;
+        String declaringClass;
+
+        public InlineVariable(Range range, String name, InlineKind kind) {
+            this.range = range;
+            this.name = name;
+            this.kind = kind;
+        }
+
+        public InlineVariable(Range range, String name, InlineKind kind, String declaringClass) {
+            this.range = range;
+            this.name = name;
+            this.kind = kind;
+            this.declaringClass = declaringClass;
+        }
+    }
+
+    static enum InlineKind {
+        VariableLookup,
+        Evaluation
+    }
+
+    static class InlineParams {
+        String uri;
+        Range viewPort;
+        Range stoppedLocation;
+    }
+
+    static class Token {
+        String name;
+        Position position;
+        String declaringClass = null;
+
+        public Token(String name, Position position) {
+            this.name = name;
+            this.position = position;
+        }
+
+        public Token(String name, Position position, String declaringClass) {
+            this.name = name;
+            this.position = position;
+            this.declaringClass = declaringClass;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(declaringClass, name);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof Token)) {
+                return false;
+            }
+            Token other = (Token) obj;
+            return Objects.equals(declaringClass, other.declaringClass) && Objects.equals(name, other.name);
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaClassFilter.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaClassFilter.java
new file mode 100644
index 000000000..5d5bc7b0b
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaClassFilter.java
@@ -0,0 +1,307 @@
+/*******************************************************************************
+ * Copyright (c) 2020 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Map.Entry;
+import java.util.Queue;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+import com.microsoft.java.debug.core.Configuration;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.launching.JavaRuntime;
+import org.eclipse.jdt.ls.core.internal.ProjectUtils;
+
+public class JavaClassFilter {
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    private static final int BLOCK_NONE = 0;
+    private static final int BLOCK_JDK = 1;
+    private static final int BLOCK_LIB = 2;
+    private static final int BLOCK_BIN = 3;
+
+    /**
+     * Substitute the variables in the exclusion filter list.
+     *
+     * <p>
+     * For example, a sample input could be:
+     * [
+     *  "$JDK",
+     *  "$Libraries",
+     *  "junit.*",
+     *  "java.lang.ClassLoader"
+     * ].
+     *
+     * Variable "$JDK" means skipping the classes from the JDK, and variable "$Libraries"
+     * means skipping the classes from the application libraries.
+     *
+     * <p>
+     * This function will resolve the packages belonging to the variable group first, and
+     * then use a greedy algorithm to generate a list of wildcards to cover these packages.
+     */
+    public static String[] resolveClassFilters(List<Object> unresolvedFilters) {
+        if (unresolvedFilters == null || unresolvedFilters.isEmpty()) {
+            return new String[0];
+        }
+
+        int variableScope = BLOCK_NONE;
+        Set<String> hardcodePatterns = new LinkedHashSet<>();
+        for (Object filter : unresolvedFilters) {
+            if (Objects.equals("$JDK", filter)) {
+                variableScope = variableScope | BLOCK_JDK;
+            } else if (Objects.equals("$Libraries", filter)) {
+                variableScope = variableScope | BLOCK_LIB;
+            } else if (filter instanceof String) {
+                String value = (String) filter;
+                if (StringUtils.isNotBlank(value)) {
+                    hardcodePatterns.add(value.trim());
+                }
+            }
+        }
+
+        if (variableScope == BLOCK_NONE) {
+            return hardcodePatterns.toArray(new String[0]);
+        }
+
+        Set<String> blackList = new LinkedHashSet<>();
+        Set<String> whiteList = new LinkedHashSet<>();
+        IJavaProject[] javaProjects = ProjectUtils.getJavaProjects();
+        for (IJavaProject javaProject : javaProjects) {
+            try {
+                IPackageFragmentRoot[] roots = javaProject.getAllPackageFragmentRoots();
+                for (IPackageFragmentRoot root : roots) {
+                    if (isOnBlackList(root, variableScope)) {
+                        collectPackages(root, blackList);
+                    } else {
+                        collectPackages(root, whiteList);
+                    }
+                }
+            } catch (JavaModelException e) {
+                logger.log(Level.SEVERE, String.format("Failed to get the classpath entry for the PackageFragmentRoot: %s", e.toString()), e);
+            }
+        }
+
+        return convertToExclusionPatterns(blackList, whiteList, hardcodePatterns);
+    }
+
+    private static boolean isOnBlackList(IPackageFragmentRoot root, int variableScope) throws JavaModelException {
+        if (root.isArchive()) {
+            if (variableScope == BLOCK_BIN) {
+                return true;
+            }
+
+            boolean isJDK = isJDKPackageFragmentRoot(root);
+            return (variableScope == BLOCK_JDK && isJDK) || (variableScope == BLOCK_LIB && !isJDK);
+        }
+
+        return false;
+    }
+
+    private static boolean isJDKPackageFragmentRoot(IPackageFragmentRoot root) throws JavaModelException {
+        if (root.getRawClasspathEntry() != null) {
+            IPath path = root.getRawClasspathEntry().getPath();
+            return path != null && path.segmentCount() > 0
+                && Objects.equals(JavaRuntime.JRE_CONTAINER, path.segment(0));
+        }
+
+        return false;
+    }
+
+    private static void collectPackages(IPackageFragmentRoot root, Set<String> result) throws JavaModelException {
+        for (IJavaElement javaElement : root.getChildren()) {
+            String elementName = javaElement.getElementName();
+            if (javaElement instanceof IPackageFragment
+                && ((IPackageFragment) javaElement).hasChildren()) {
+                if (StringUtils.isNotBlank(elementName)) {
+                    result.add(elementName);
+                }
+            }
+        }
+    }
+
+    private static String[] convertToExclusionPatterns(Collection<String> blackList,
+        Collection<String> whiteList, Collection<String> hardcodePatterns) {
+        List<String> hardcodeBlockedPackages = hardcodePatterns.stream()
+            .filter(pattern -> pattern.endsWith(".*"))
+            .map(pattern -> pattern.substring(0, pattern.length() - 2))
+            .collect(Collectors.toList());
+        Trie hardcodeBlackTree = new Trie(hardcodeBlockedPackages);
+
+        // Remove those packages that are on the user hardcode black list.
+        List<String> newWhiteList = whiteList.stream()
+            .filter(pattern -> !hardcodeBlackTree.isPrefix(pattern))
+            .collect(Collectors.toList());
+
+        // Superimpose the white tree on the black tree, then gray out the nodes
+        // with the same name.
+        Trie whiteTree = new Trie(newWhiteList);
+        Trie blackTree = new Trie(blackList);
+        superimpose(whiteTree, blackTree);
+
+        // Generate some wildcard patterns to cover all items in the black list.
+        List<String> wildcardPatterns = new ArrayList<>();
+        traverse(blackTree.root, 0, wildcardPatterns, new ArrayList<>());
+
+        // Append the hardcode patterns to the result.
+        for (String name : hardcodePatterns) {
+            if (!blackTree.wildcardMatch(name)) {
+                wildcardPatterns.add(name);
+            }
+        }
+
+        return wildcardPatterns.toArray(new String[0]);
+    }
+
+    private static void superimpose(Trie upTree, Trie downTree) {
+        Queue<TrieNode> upQueue = new LinkedList<>();
+        Queue<TrieNode> downQueue = new LinkedList<>();
+        upQueue.offer(upTree.root);
+        downQueue.offer(downTree.root);
+        while (!upQueue.isEmpty()) {
+            TrieNode upNode = upQueue.poll();
+            TrieNode downNode = downQueue.poll();
+            downNode.isGray = true;
+            for (Entry<String, TrieNode> entry : upNode.children.entrySet()) {
+                if (downNode.children.containsKey(entry.getKey())) {
+                    upQueue.offer(entry.getValue());
+                    downQueue.offer(downNode.children.get(entry.getKey()));
+                }
+            }
+        }
+    }
+
+    private static void traverse(TrieNode root, int depth, List<String> result, List<String> parent) {
+        // If the node is gray, that means it also appears in the white list.
+        // We cannot use it to generate a wildcard pattern.
+        if (!root.isGray) {
+            String[] names = new String[depth + 1];
+            for (int i = 0; i < depth - 1; i++) {
+                names[i] = parent.get(i);
+            }
+
+            names[depth - 1] = root.name;
+            names[depth] = "*";
+            result.add(String.join(".", names));
+            return;
+        }
+
+        if (depth > 0) {
+            if (parent.size() < depth) {
+                parent.add(root.name);
+            } else {
+                parent.set(depth - 1, root.name);
+            }
+        }
+
+        for (TrieNode child : root.children.values()) {
+            traverse(child, depth + 1, result, parent);
+        }
+    }
+
+    private static class Trie {
+        private TrieNode root = new TrieNode();
+
+        public Trie(Collection<String> names) {
+            for (String name : names) {
+                insert(name);
+            }
+        }
+
+        public void insert(String name) {
+            if (StringUtils.isBlank(name)) {
+                return;
+            }
+
+            String[] names = name.split("\\.");
+            TrieNode currentNode = this.root;
+            for (int i = 0; i < names.length; i++) {
+                TrieNode node;
+                if (currentNode.children.containsKey(names[i])) {
+                    node = currentNode.children.get(names[i]);
+                } else {
+                    node = new TrieNode(names[i]);
+                    currentNode.children.put(names[i], node);
+                }
+
+                currentNode = node;
+            }
+
+            currentNode.isLeaf = true;
+        }
+
+        public boolean isPrefix(String name) {
+            String[] names = name.split("\\.");
+            TrieNode currentNode = this.root;
+            for (int i = 0; i < names.length; i++) {
+                TrieNode node = currentNode.children.get(names[i]);
+                if (node == null) {
+                    break;
+                }
+
+                currentNode = node;
+            }
+
+            return currentNode != this.root && currentNode.isLeaf;
+        }
+
+        /**
+         * Check whether the name can be covered by the wildcards generated from
+         * this trie.
+         */
+        public boolean wildcardMatch(String name) {
+            String[] names = name.split("\\.");
+            Map<String, TrieNode> children = this.root.children;
+            for (int i = 0; i < names.length; i++) {
+                TrieNode node = children.get(names[i]);
+                if (node == null) {
+                    break;
+                } else if (!node.isGray) {
+                    return true;
+                }
+
+                children = node.children;
+            }
+
+            return false;
+        }
+    }
+
+    private static class TrieNode {
+        private String name;
+        private Map<String, TrieNode> children = new LinkedHashMap<>();
+        private boolean isLeaf = false;
+        private boolean isGray = false;
+
+        public TrieNode() {
+        }
+
+        public TrieNode(String name) {
+            this.name = name;
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebugDelegateCommandHandler.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebugDelegateCommandHandler.java
index f563111d8..f4e7b0ba3 100644
--- a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebugDelegateCommandHandler.java
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebugDelegateCommandHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2017 Microsoft Corporation and others.
+* Copyright (c) 2017-2022 Microsoft Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -11,44 +11,131 @@
 
 package com.microsoft.java.debug.plugin.internal;
 
+import java.util.ArrayList;
 import java.util.List;
 
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.ls.core.internal.IDelegateCommandHandler;
+import org.eclipse.jdt.ls.core.internal.JDTUtils;
+import org.eclipse.jdt.ls.core.internal.ProjectUtils;
+import org.eclipse.jdt.ls.core.internal.ResourceUtils;
 
+import com.microsoft.java.debug.core.DebugException;
 import com.microsoft.java.debug.core.UsageDataStore;
+import com.microsoft.java.debug.core.protocol.JsonUtils;
+import com.microsoft.java.debug.core.protocol.Requests.LaunchArguments;
+import com.microsoft.java.debug.plugin.internal.InlineValueHandler.InlineParams;
 
 public class JavaDebugDelegateCommandHandler implements IDelegateCommandHandler {
+    public static final String FETCH_USER_DATA = "vscode.java.fetchUsageData";
+    public static final String DEBUG_STARTSESSION = "vscode.java.startDebugSession";
+    public static final String RESOLVE_CLASSPATH = "vscode.java.resolveClasspath";
+    public static final String RESOLVE_MAINCLASS = "vscode.java.resolveMainClass";
+    public static final String BUILD_WORKSPACE = "vscode.java.buildWorkspace";
+    public static final String UPDATE_DEBUG_SETTINGS = "vscode.java.updateDebugSettings";
+    public static final String VALIDATE_LAUNCHCONFIG = "vscode.java.validateLaunchConfig";
+    public static final String RESOLVE_MAINMETHOD = "vscode.java.resolveMainMethod";
+    public static final String INFER_LAUNCH_COMMAND_LENGTH = "vscode.java.inferLaunchCommandLength";
+    public static final String CHECK_PROJECT_SETTINGS = "vscode.java.checkProjectSettings";
+    public static final String RESOLVE_ELEMENT_AT_SELECTION = "vscode.java.resolveElementAtSelection";
+    public static final String RESOLVE_BUILD_FILES = "vscode.java.resolveBuildFiles";
+    public static final String IS_ON_CLASSPATH = "vscode.java.isOnClasspath";
+    public static final String RESOLVE_JAVA_EXECUTABLE = "vscode.java.resolveJavaExecutable";
+    public static final String FETCH_PLATFORM_SETTINGS = "vscode.java.fetchPlatformSettings";
+    public static final String RESOLVE_CLASSFILTERS = "vscode.java.resolveClassFilters";
+    public static final String RESOLVE_SOURCEURI = "vscode.java.resolveSourceUri";
+    public static final String RESOLVE_INLINEVARIABLES = "vscode.java.resolveInlineVariables";
 
-    public static String FETCH_USER_DATA = "vscode.java.fetchUsageData";
+    @Override
+    public Object executeCommand(String commandId, List<Object> arguments, IProgressMonitor progress) throws Exception {
+        switch (commandId) {
+            case DEBUG_STARTSESSION:
+                IDebugServer debugServer = JavaDebugServer.getInstance();
+                debugServer.start();
+                return debugServer.getPort();
+            case RESOLVE_CLASSPATH:
+                ResolveClasspathsHandler handler = new ResolveClasspathsHandler();
+                return handler.resolveClasspaths(arguments);
+            case RESOLVE_MAINCLASS:
+                ResolveMainClassHandler resolveMainClassHandler = new ResolveMainClassHandler();
+                return resolveMainClassHandler.resolveMainClass(arguments);
+            case BUILD_WORKSPACE:
+                Compile.CompileParams params = null;
+                if (arguments != null && !arguments.isEmpty()) {
+                    params = JsonUtils.fromJson((String) arguments.get(0), Compile.CompileParams.class);
+                }
 
-    public static String DEBUG_STARTSESSION = "vscode.java.startDebugSession";
+                return Compile.compile(params, progress);
+            case FETCH_USER_DATA:
+                return UsageDataStore.getInstance().fetchAll();
+            case UPDATE_DEBUG_SETTINGS:
+                return DebugSettingUtils.configDebugSettings(arguments);
+            case VALIDATE_LAUNCHCONFIG:
+                return new ResolveMainClassHandler().validateLaunchConfig(arguments);
+            case RESOLVE_MAINMETHOD:
+                return ResolveMainMethodHandler.resolveMainMethods(arguments, progress);
+            case INFER_LAUNCH_COMMAND_LENGTH:
+                return LaunchCommandHandler.getLaunchCommandLength(JsonUtils.fromJson((String) arguments.get(0), LaunchArguments.class));
+            case CHECK_PROJECT_SETTINGS:
+                return ProjectSettingsChecker.check(JsonUtils.fromJson((String) arguments.get(0), ProjectSettingsChecker.ProjectSettingsCheckerParams.class));
+            case RESOLVE_ELEMENT_AT_SELECTION:
+                return ResolveElementHandler.resolveElementAtSelection(arguments, progress);
+            case RESOLVE_BUILD_FILES:
+                return getBuildFiles();
+            case IS_ON_CLASSPATH:
+                return isOnClasspath(arguments);
+            case RESOLVE_JAVA_EXECUTABLE:
+                return ResolveJavaExecutableHandler.resolveJavaExecutable(arguments);
+            case FETCH_PLATFORM_SETTINGS:
+                return PlatformSettings.getPlatformSettings();
+            case RESOLVE_CLASSFILTERS:
+                return JavaClassFilter.resolveClassFilters(arguments);
+            case RESOLVE_SOURCEURI:
+                return ResolveSourceMappingHandler.resolveSourceUri(arguments);
+            case RESOLVE_INLINEVARIABLES:
+                return InlineValueHandler.resolveInlineVariables(JsonUtils.fromJson((String) arguments.get(0), InlineParams.class), progress);
+            default:
+                break;
+        }
 
-    public static String RESOLVE_CLASSPATH = "vscode.java.resolveClasspath";
+        throw new UnsupportedOperationException(String.format("Java debug plugin doesn't support the command '%s'.", commandId));
+    }
 
-    public static String BUILD_WORKSPACE = "vscode.java.buildWorkspace";
+    private List<String> getBuildFiles() {
+        List<String> result = new ArrayList<>();
+        List<IJavaProject> javaProjects = JdtUtils.listJavaProjects(ResourcesPlugin.getWorkspace().getRoot());
+        for (IJavaProject javaProject : javaProjects) {
+            IFile buildFile = null;
+            if (ProjectUtils.isMavenProject(javaProject.getProject())) {
+                buildFile = javaProject.getProject().getFile("pom.xml");
+            } else if (ProjectUtils.isGradleProject(javaProject.getProject())) {
+                buildFile = javaProject.getProject().getFile("build.gradle");
+            }
 
-    public static String CONFIG_LOG_LEVEL = "vscode.java.configLogLevel";
+            if (buildFile != null && buildFile.exists() && buildFile.getLocationURI() != null) {
+                result.add(ResourceUtils.fixURI(buildFile.getLocationURI()));
+            }
+        }
 
+        return result;
+    }
 
-    @Override
-    public Object executeCommand(String commandId, List<Object> arguments, IProgressMonitor progress) throws Exception {
-        if (DEBUG_STARTSESSION.equals(commandId)) {
-            IDebugServer debugServer = JavaDebugServer.getInstance();
-            debugServer.start();
-            return debugServer.getPort();
-        } else if (RESOLVE_CLASSPATH.equals(commandId)) {
-            ResolveClasspathsHandler handler = new ResolveClasspathsHandler();
-            return handler.resolveClasspaths(arguments);
-        } else if (BUILD_WORKSPACE.equals(commandId)) {
-            // TODO
-        } else if (FETCH_USER_DATA.equals(commandId)) {
-            return UsageDataStore.getInstance().fetchAll();
-        } else if (CONFIG_LOG_LEVEL.equals(commandId)) {
-            return LogUtils.configLogLevel(arguments);
+    private boolean isOnClasspath(List<Object> arguments) throws DebugException {
+        if (arguments.size() < 1) {
+            throw new DebugException("No file uri is specified.");
         }
 
-        throw new UnsupportedOperationException(String.format("Java debug plugin doesn't support the command '%s'.", commandId));
-    }
+        String uri = (String) arguments.get(0);
+        final ICompilationUnit unit = JDTUtils.resolveCompilationUnit(uri);
+        if (unit == null || unit.getResource() == null || !unit.getResource().exists()) {
+            throw new DebugException("The compilation unit " + uri + " doesn't exist.");
+        }
 
+        IJavaProject javaProject = unit.getJavaProject();
+        return javaProject == null || javaProject.isOnClasspath(unit);
+    }
 }
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebugServer.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebugServer.java
index a1aa5a8e2..32ab195b7 100644
--- a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebugServer.java
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebugServer.java
@@ -133,7 +133,7 @@ public void run() {
                     ProtocolServer protocolServer = new ProtocolServer(connection.getInputStream(), connection.getOutputStream(),
                             JdtProviderContextFactory.createProviderContext());
                     // protocol server will dispatch request and send response in a while-loop.
-                    protocolServer.start();
+                    protocolServer.run();
                 } catch (IOException e) {
                     logger.log(Level.SEVERE, String.format("Socket connection exception: %s", e.toString()), e);
                 } finally {
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebuggerServerPlugin.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebuggerServerPlugin.java
index e4d24018f..d3307a5b2 100644
--- a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebuggerServerPlugin.java
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaDebuggerServerPlugin.java
@@ -22,7 +22,7 @@
 public class JavaDebuggerServerPlugin implements BundleActivator {
     private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
 
-    public static final String PLUGIN_ID = "com.microsoft.java.debug";
+    public static final String PLUGIN_ID = "com.microsoft.java.debug.plugin";
     public static BundleContext context = null;
 
     @Override
@@ -34,7 +34,7 @@ public void start(BundleContext context) throws Exception {
 
     @Override
     public void stop(BundleContext context) throws Exception {
-        logger.info("Stopping " + PLUGIN_ID);
+        LogUtils.cleanupHandlers();
     }
 
 }
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaHotCodeReplaceProvider.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaHotCodeReplaceProvider.java
new file mode 100644
index 000000000..3a2b2f3df
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JavaHotCodeReplaceProvider.java
@@ -0,0 +1,785 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2016 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *     Yevgen Kogan - Bug 403475 - Hot Code Replace drops too much frames in some cases
+ *******************************************************************************/
+/*******************************************************************************
+ * Copyright (c) 2017-2019 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - Adapter the code for VSCode Java Debugger
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.eclipse.core.resources.IBuildConfiguration;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceChangeEvent;
+import org.eclipse.core.resources.IResourceChangeListener;
+import org.eclipse.core.resources.IResourceDelta;
+import org.eclipse.core.resources.IResourceDeltaVisitor;
+import org.eclipse.core.resources.IncrementalProjectBuilder;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaModelMarker;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.ToolFactory;
+import org.eclipse.jdt.core.util.IClassFileReader;
+import org.eclipse.jdt.core.util.ISourceAttribute;
+import org.eclipse.jdt.internal.core.util.Util;
+import org.eclipse.jdt.ls.core.internal.JobHelpers;
+import org.eclipse.jdt.ls.core.internal.ProjectUtils;
+
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.DebugUtility;
+import com.microsoft.java.debug.core.IDebugSession;
+import com.microsoft.java.debug.core.StackFrameUtility;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.Constants;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.HotCodeReplaceEvent;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IHotCodeReplaceProvider;
+import com.microsoft.java.debug.core.protocol.Events;
+
+import com.sun.jdi.IncompatibleThreadStateException;
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.StackFrame;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.VMDisconnectedException;
+import com.sun.jdi.VirtualMachine;
+import com.sun.jdi.request.StepRequest;
+
+import io.reactivex.Observable;
+import io.reactivex.subjects.PublishSubject;
+
+/**
+ * The hot code replace provider listens for changes to class files and notifies
+ * the running debug session of the changes.
+ */
+public class JavaHotCodeReplaceProvider implements IHotCodeReplaceProvider, IResourceChangeListener {
+
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+
+    private static final String CLASS_FILE_EXTENSION = "class"; //$NON-NLS-1$
+
+    private IDebugSession currentDebugSession;
+
+    private IDebugAdapterContext context;
+
+    private Map<ThreadReference, List<StackFrame>> threadFrameMap = new HashMap<>();
+
+    private List<Consumer<List<String>>> consumers = new ArrayList<Consumer<List<String>>>();
+
+    private PublishSubject<HotCodeReplaceEvent> eventSubject = PublishSubject.<HotCodeReplaceEvent>create();
+
+    private List<IResource> deltaResources = new ArrayList<>();
+
+    private List<String> deltaClassNames = new ArrayList<>();
+
+    private String mainProjectName = "";
+
+    /**
+     * Visitor for resource deltas.
+     */
+    private ChangedClassFilesVisitor classFilesVisitor = new ChangedClassFilesVisitor();
+
+    /**
+     * A visitor which collects changed class files.
+     */
+    class ChangedClassFilesVisitor implements IResourceDeltaVisitor {
+        /**
+         * The collection of changed class files.
+         */
+        private List<IResource> changedFiles = null;
+
+        /**
+         * Collection of qualified type names, corresponding to class files.
+         */
+        private List<String> fullyQualifiedNames = null;
+
+        /**
+         * Answers whether children should be visited.
+         * <p>
+         * If the associated resource is a class file which has been changed, record it.
+         * </p>
+         */
+        @Override
+        public boolean visit(IResourceDelta delta) {
+            if (delta == null || 0 == (delta.getKind() & IResourceDelta.CHANGED)) {
+                return false;
+            }
+            IResource resource = delta.getResource();
+            if (resource != null) {
+                switch (resource.getType()) {
+                    case IResource.FILE:
+                        if (0 == (delta.getFlags() & IResourceDelta.CONTENT)) {
+                            return false;
+                        }
+                        if (CLASS_FILE_EXTENSION.equals(resource.getFullPath().getFileExtension())) {
+                            IPath localLocation = resource.getLocation();
+                            if (localLocation != null) {
+                                String path = localLocation.toOSString();
+                                IClassFileReader reader = ToolFactory.createDefaultClassFileReader(path,
+                                        IClassFileReader.CLASSFILE_ATTRIBUTES);
+                                if (reader != null) {
+                                    // this name is slash-delimited
+                                    String qualifiedName = new String(reader.getClassName());
+                                    boolean hasBlockingErrors = false;
+                                    try {
+                                        // If the user doesn't want to replace
+                                        // classfiles containing
+                                        // compilation errors, get the source
+                                        // file associated with
+                                        // the class file and query it for
+                                        // compilation errors
+                                        IJavaProject pro = JavaCore.create(resource.getProject());
+                                        ISourceAttribute sourceAttribute = reader.getSourceFileAttribute();
+                                        String sourceName = null;
+                                        if (sourceAttribute != null) {
+                                            sourceName = new String(sourceAttribute.getSourceFileName());
+                                        }
+                                        IResource sourceFile = getSourceFile(pro, qualifiedName, sourceName);
+                                        if (sourceFile != null) {
+                                            IMarker[] problemMarkers = null;
+                                            problemMarkers = sourceFile.findMarkers(
+                                                    IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, true,
+                                                    IResource.DEPTH_INFINITE);
+                                            for (IMarker problemMarker : problemMarkers) {
+                                                if (problemMarker.getAttribute(IMarker.SEVERITY,
+                                                        -1) == IMarker.SEVERITY_ERROR) {
+                                                    hasBlockingErrors = true;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    } catch (CoreException e) {
+                                        logger.log(Level.SEVERE, "Failed to visit classes: " + e.getMessage(), e);
+                                    }
+                                    if (!hasBlockingErrors) {
+                                        changedFiles.add(resource);
+                                        // dot-delimit the name
+                                        fullyQualifiedNames.add(qualifiedName.replace('/', '.'));
+                                    }
+                                }
+                            }
+                        }
+                        return false;
+
+                    default:
+                        return true;
+                }
+            }
+            return true;
+        }
+
+        /**
+         * Resets the file collection to empty.
+         */
+        public void reset() {
+            changedFiles = new ArrayList<>();
+            fullyQualifiedNames = new ArrayList<>();
+        }
+
+        /**
+         * Answers a collection of changed class files or <code>null</code>.
+         */
+        public List<IResource> getChangedClassFiles() {
+            return changedFiles;
+        }
+
+        /**
+         * Returns a collection of qualified type names corresponding to the changed
+         * class files.
+         *
+         * @return List
+         */
+        public List<String> getQualifiedNamesList() {
+            return fullyQualifiedNames;
+        }
+
+        /**
+         * Returns the source file associated with the given type, or <code>null</code>
+         * if no source file could be found.
+         *
+         * @param project
+         *            the java project containing the classfile
+         * @param qualifiedName
+         *            fully qualified name of the type, slash delimited
+         * @param sourceAttribute
+         *            debug source attribute, or <code>null</code> if none
+         */
+        private IResource getSourceFile(IJavaProject project, String qualifiedName, String sourceAttribute) {
+            String name = null;
+            IJavaElement element = null;
+            try {
+                if (sourceAttribute == null) {
+                    element = findElement(qualifiedName, project);
+                } else {
+                    int i = qualifiedName.lastIndexOf('/');
+                    if (i > 0) {
+                        name = qualifiedName.substring(0, i + 1);
+                        name = name + sourceAttribute;
+                    } else {
+                        name = sourceAttribute;
+                    }
+                    element = project.findElement(new Path(name));
+                }
+                if (element instanceof ICompilationUnit) {
+                    ICompilationUnit cu = (ICompilationUnit) element;
+                    return cu.getCorrespondingResource();
+                }
+            } catch (CoreException e) {
+                logger.log(Level.INFO, "Failed to get source file with exception" + e.getMessage(), e);
+            }
+            return null;
+        }
+    }
+
+    @Override
+    public void initialize(IDebugAdapterContext context, Map<String, Object> options) {
+        if (DebugSettings.getCurrent().hotCodeReplace != DebugSettings.HotCodeReplace.NEVER) {
+            // Listen to the built file events.
+            ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_BUILD);
+        }
+        this.context = context;
+        currentDebugSession = context.getDebugSession();
+        this.mainProjectName = ((String) options.get(Constants.PROJECT_NAME));
+    }
+
+    @Override
+    public void close() {
+        if (DebugSettings.getCurrent().hotCodeReplace != DebugSettings.HotCodeReplace.NEVER) {
+            // Remove the listener.
+            ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
+        }
+
+        eventSubject.onComplete();
+    }
+
+    @Override
+    public void resourceChanged(IResourceChangeEvent event) {
+        if (event.getType() == IResourceChangeEvent.POST_BUILD) {
+            ChangedClassFilesVisitor visitor = getChangedClassFiles(event);
+            if (visitor != null) {
+                List<IResource> resources = visitor.getChangedClassFiles();
+                List<String> classNames = visitor.getQualifiedNamesList();
+                synchronized (this) {
+                    for (int i = 0; i < classNames.size(); i++) {
+                        String className = classNames.get(i);
+                        IResource resource = resources.get(i);
+                        boolean duplicate = false;
+                        for (int j = 0; j < deltaClassNames.size(); j++) {
+                            if (Objects.equals(deltaClassNames.get(j), className)
+                                && JdtUtils.isSameFile(deltaResources.get(j), resource)) {
+                                duplicate = true;
+                                break;
+                            }
+                        }
+
+                        if (!duplicate) {
+                            deltaClassNames.add(className);
+                            deltaResources.add(resource);
+                        }
+                    }
+                }
+                publishEvent(HotCodeReplaceEvent.EventType.BUILD_COMPLETE, "Build completed.");
+            }
+        }
+    }
+
+    @Override
+    public void onClassRedefined(Consumer<List<String>> consumer) {
+        this.consumers.add(consumer);
+    }
+
+    @Override
+    public CompletableFuture<List<String>> redefineClasses() {
+        triggerBuildForBspProject();
+        JobHelpers.waitForBuildJobs(10 * 1000);
+        return CompletableFuture.supplyAsync(() -> {
+            List<String> classNames = new ArrayList<>();
+            String errorMessage = null;
+            synchronized (this) {
+                classNames.addAll(deltaClassNames);
+                errorMessage = doHotCodeReplace(deltaResources, deltaClassNames);
+                deltaResources.clear();
+                deltaClassNames.clear();
+            }
+
+            if (!classNames.isEmpty() && errorMessage != null) {
+                throw AdapterUtils.createCompletionException(errorMessage, ErrorCode.HCR_FAILURE);
+            }
+
+            return classNames;
+        });
+    }
+
+    @Override
+    public Observable<HotCodeReplaceEvent> getEventHub() {
+        return eventSubject;
+    }
+
+    private void publishEvent(HotCodeReplaceEvent.EventType type, String message) {
+        eventSubject.onNext(new HotCodeReplaceEvent(type, message));
+    }
+
+    private void publishEvent(HotCodeReplaceEvent.EventType type, String message, Object data) {
+        eventSubject.onNext(new HotCodeReplaceEvent(type, message, data));
+    }
+
+    private String doHotCodeReplace(List<IResource> resourcesToReplace, List<String> qualifiedNamesToReplace) {
+        if (context == null || currentDebugSession == null) {
+            return null;
+        }
+
+        if (resourcesToReplace == null || qualifiedNamesToReplace == null || qualifiedNamesToReplace.isEmpty()
+                || resourcesToReplace.isEmpty()) {
+            return null;
+        }
+
+        filterNotLoadedTypes(resourcesToReplace, qualifiedNamesToReplace);
+        if (qualifiedNamesToReplace.isEmpty()) {
+            return null;
+            // If none of the changed types are loaded, do nothing.
+        }
+
+        // Not supported scenario:
+        if (!currentDebugSession.getVM().canRedefineClasses()) {
+            publishEvent(HotCodeReplaceEvent.EventType.ERROR, "JVM doesn't support hot reload classes");
+            return "JVM doesn't support hot reload classes";
+        }
+
+        String errorMessage = null;
+        publishEvent(HotCodeReplaceEvent.EventType.STARTING, "Start hot code replacement procedure...");
+
+        try {
+            List<ThreadReference> poppedThreads = new ArrayList<>();
+            boolean framesPopped = false;
+            if (this.currentDebugSession.getVM().canPopFrames()) {
+                try {
+                    attemptPopFrames(resourcesToReplace, qualifiedNamesToReplace, poppedThreads);
+                    framesPopped = true; // No exception occurred
+                } catch (DebugException e) {
+                    logger.log(Level.WARNING, "Failed to pop frames " + e.getMessage(), e);
+                }
+            }
+
+            redefineTypesJDK(resourcesToReplace, qualifiedNamesToReplace);
+            for (Consumer<List<String>> consumer : consumers) {
+                consumer.accept(qualifiedNamesToReplace);
+            }
+
+            if (containsObsoleteMethods()) {
+                publishEvent(HotCodeReplaceEvent.EventType.ERROR, "JVM contains obsolete methods");
+                errorMessage = "JVM contains obsolete methods";
+            }
+
+            if (currentDebugSession.getVM().canPopFrames() && framesPopped) {
+                attemptStepIn(poppedThreads);
+            } else {
+                attemptDropToFrame(resourcesToReplace, qualifiedNamesToReplace);
+            }
+        } catch (DebugException e) {
+            logger.log(Level.SEVERE, "Failed to complete hot code replace: " + e.getMessage(), e);
+            errorMessage = e.getMessage();
+        } finally {
+            publishEvent(HotCodeReplaceEvent.EventType.END, "Completed hot code replace", qualifiedNamesToReplace);
+            threadFrameMap.clear();
+        }
+
+        return errorMessage;
+    }
+
+    private void filterNotLoadedTypes(List<IResource> resources, List<String> qualifiedNames) {
+        for (int i = 0, numElements = qualifiedNames.size(); i < numElements; i++) {
+            String name = qualifiedNames.get(i);
+            List<ReferenceType> list = getJdiClassesByName(name);
+            if (list.isEmpty()) {
+                // If no classes with the given name are loaded in the VM, don't
+                // waste
+                // cycles trying to replace.
+                qualifiedNames.remove(i);
+                resources.remove(i);
+                // Decrement the index and number of elements to compensate for
+                // item removal
+                i--;
+                numElements--;
+            }
+        }
+    }
+
+    /**
+     * Returns VirtualMachine.classesByName(String), logging any JDI exceptions.
+     *
+     * @see com.sun.jdi.VirtualMachine
+     */
+    private List<ReferenceType> getJdiClassesByName(String className) {
+        try {
+            VirtualMachine vm = this.currentDebugSession.getVM();
+            if (vm != null) {
+                return vm.classesByName(className);
+            }
+        } catch (VMDisconnectedException ex) {
+            // Ignore this exception since it will happen when the VM is still running.
+        }
+        return Collections.emptyList();
+    }
+
+    /**
+     * Looks for the deepest affected stack frames in the stack and forces pop
+     * affected frames. Does this for all of the active stack frames in the session.
+     */
+    private void attemptPopFrames(List<IResource> resources, List<String> replacedClassNames,
+            List<ThreadReference> poppedThreads) throws DebugException {
+        List<StackFrame> popFrames = getAffectedFrames(currentDebugSession.getAllThreads(), replacedClassNames);
+
+        for (StackFrame popFrame : popFrames) {
+            try {
+                popStackFrame(popFrame);
+                poppedThreads.add(popFrame.thread());
+            } catch (DebugException de) {
+                poppedThreads.remove(popFrame.thread());
+            }
+        }
+    }
+
+    /**
+     * Performs a "step into" operation on the given threads.
+     */
+    private void attemptStepIn(List<ThreadReference> threads) {
+        for (ThreadReference thread : threads) {
+            stepIntoThread(thread);
+        }
+    }
+
+    /**
+     * Looks for the deepest affected stack frame in the stack and forces a drop to
+     * frame. Does this for all of the active stack frames in the target.
+     */
+    private void attemptDropToFrame(List<IResource> resources, List<String> replacedClassNames)
+            throws DebugException {
+        List<StackFrame> dropFrames = getAffectedFrames(currentDebugSession.getAllThreads(), replacedClassNames);
+
+        // All threads that want to drop to frame are able. Proceed with the
+        // drop
+        for (StackFrame dropFrame : dropFrames) {
+            dropToStackFrame(dropFrame);
+        }
+    }
+
+    /**
+     * Returns a list of frames which should be popped in the given threads.
+     */
+    private List<StackFrame> getAffectedFrames(List<ThreadReference> threads, List<String> replacedClassNames)
+            throws DebugException {
+        List<StackFrame> popFrames = new ArrayList<>();
+        for (ThreadReference thread : threads) {
+            if (thread.isSuspended()) {
+                StackFrame affectedFrame = getAffectedFrame(thread, replacedClassNames);
+                if (affectedFrame == null) {
+                    // No frame to drop to in this thread
+                    continue;
+                }
+                if (supportsDropToFrame(thread, affectedFrame)) {
+                    popFrames.add(affectedFrame);
+                }
+            }
+        }
+        return popFrames;
+    }
+
+    /**
+     * Returns the stack frame that should be dropped to in the given thread after a
+     * hot code replace. This is calculated by determining if the threads contain
+     * stack frames that reside in one of the given replaced class names. If
+     * possible, only stack frames whose methods were directly affected (and not
+     * simply all frames in affected types) will be returned.
+     */
+    private StackFrame getAffectedFrame(ThreadReference thread, List<String> replacedClassNames)
+            throws DebugException {
+        List<StackFrame> frames = getStackFrames(thread, false);
+        StackFrame affectedFrame = null;
+        for (int i = 0; i < frames.size(); i++) {
+            StackFrame frame = frames.get(i);
+            if (containsChangedType(frame, replacedClassNames)) {
+                if (supportsDropToFrame(thread, frame)) {
+                    affectedFrame = frame;
+                    break;
+                }
+                // The frame we wanted to drop to cannot be popped.
+                // Set the affected frame to the next lowest pop-able
+                // frame on the stack.
+                int j = i;
+                while (j > 0) {
+                    j--;
+                    frame = frames.get(j);
+                    if (supportsDropToFrame(thread, frame)) {
+                        affectedFrame = frame;
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+        return affectedFrame;
+    }
+
+    private boolean containsChangedType(StackFrame frame, List<String> replacedClassNames) throws DebugException {
+        String declaringTypeName = JdtUtils.getDeclaringTypeName(frame);
+        // Check if the frame's declaring type was changed
+        if (replacedClassNames.contains(declaringTypeName)) {
+            return true;
+        }
+        // Check if one of the frame's declaring type's inner classes have
+        // changed
+        for (String className : replacedClassNames) {
+            int index = className.indexOf('$');
+            if (index > -1 && declaringTypeName.equals(className.substring(0, index))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean supportsDropToFrame(ThreadReference thread, StackFrame frame) {
+        List<StackFrame> frames = getStackFrames(thread, false);
+        for (int i = 0; i < frames.size(); i++) {
+            if (StackFrameUtility.isNative(frames.get(i))) {
+                return false;
+            }
+            if (frames.get(i) == frame) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected void popStackFrame(StackFrame frame) throws DebugException {
+        if (frame != null) {
+            ThreadReference thread = frame.thread();
+            List<StackFrame> frames = getStackFrames(thread, false);
+            int desiredSize = frames.indexOf(frame);
+            while (desiredSize >= 0) {
+                StackFrameUtility.pop(frames.get(0));
+                frames = getStackFrames(thread, true);
+                desiredSize--;
+            }
+        }
+    }
+
+    protected void dropToStackFrame(StackFrame frame) throws DebugException {
+        // Pop the drop frame and all frames above it
+        popStackFrame(frame);
+        stepIntoThread(frame.thread());
+    }
+
+    private void redefineTypesJDK(List<IResource> resources, List<String> qualifiedNames) throws DebugException {
+        Map<ReferenceType, byte[]> typesToBytes = getTypesToBytes(resources, qualifiedNames);
+        try {
+            currentDebugSession.getVM().redefineClasses(typesToBytes);
+        } catch (UnsupportedOperationException | NoClassDefFoundError | VerifyError | ClassFormatError
+                | ClassCircularityError e) {
+            publishEvent(HotCodeReplaceEvent.EventType.ERROR, e.getMessage());
+            throw new DebugException("Failed to redefine classes: " + e.getMessage());
+        }
+    }
+
+    private void stepIntoThread(ThreadReference thread) {
+        StepRequest request = DebugUtility.createStepIntoRequest(thread,
+                this.context.getStepFilters().classNameFilters);
+        currentDebugSession.getEventHub().stepEvents().filter(debugEvent -> request.equals(debugEvent.event.request()))
+                .take(1).subscribe(debugEvent -> {
+                    debugEvent.shouldResume = false;
+                    // Have to send to events to keep the UI sync with the step in operations:
+                    context.getProtocolServer().sendEvent(new Events.StoppedEvent("step", thread.uniqueID()));
+                    context.getProtocolServer().sendEvent(new Events.ContinuedEvent(thread.uniqueID()));
+                });
+        request.enable();
+        thread.resume();
+    }
+
+    /**
+     * Returns a mapping of class files to the bytes that make up those class files.
+     *
+     * @param resources
+     *            the classfiles
+     * @param qualifiedNames
+     *            the fully qualified type names corresponding to the classfiles.
+     *            The typeNames correspond to the resources on a one-to-one basis.
+     * @return a mapping of class files to bytes key: class file value: the bytes
+     *         which make up that classfile
+     */
+    private Map<ReferenceType, byte[]> getTypesToBytes(List<IResource> resources, List<String> qualifiedNames) {
+        Map<ReferenceType, byte[]> typesToBytes = new HashMap<>(resources.size());
+        Iterator<IResource> resourceIter = resources.iterator();
+        Iterator<String> nameIter = qualifiedNames.iterator();
+        IResource resource;
+        String name;
+        while (resourceIter.hasNext()) {
+            resource = resourceIter.next();
+            name = nameIter.next();
+            List<ReferenceType> classes = getJdiClassesByName(name);
+            byte[] bytes = null;
+            try {
+                bytes = Util.getResourceContentsAsByteArray((IFile) resource);
+            } catch (CoreException e) {
+                continue;
+            }
+            for (ReferenceType type : classes) {
+                typesToBytes.put(type, bytes);
+            }
+        }
+        return typesToBytes;
+    }
+
+    /**
+     * Returns the class file visitor after visiting the resource change. The
+     * visitor contains the changed class files and qualified type names. Returns
+     * <code>null</code> if the visitor encounters an exception, or the delta is not
+     * a POST_BUILD.
+     */
+    private ChangedClassFilesVisitor getChangedClassFiles(IResourceChangeEvent event) {
+        IResourceDelta delta = event.getDelta();
+        if (event.getType() != IResourceChangeEvent.POST_BUILD || delta == null) {
+            return null;
+        }
+        classFilesVisitor.reset();
+        try {
+            delta.accept(classFilesVisitor);
+        } catch (CoreException e) {
+            return null; // quiet failure
+        }
+        return classFilesVisitor;
+    }
+
+    /**
+     * Returns the class file or compilation unit containing the given fully
+     * qualified name in the specified project. All registered java like file
+     * extensions are considered.
+     *
+     * @param qualifiedTypeName
+     *            fully qualified type name
+     * @param project
+     *            project to search in
+     * @return class file or compilation unit or <code>null</code>
+     * @throws CoreException
+     *             if an exception occurs
+     */
+    public static IJavaElement findElement(String qualifiedTypeName, IJavaProject project) throws CoreException {
+        String path = qualifiedTypeName;
+
+        final String[] javaLikeExtensions = JavaCore.getJavaLikeExtensions();
+        int pos = path.indexOf('$');
+        if (pos != -1) {
+            path = path.substring(0, pos);
+        }
+        path = path.replace('.', IPath.SEPARATOR);
+        path += "."; //$NON-NLS-1$
+        for (String ext : javaLikeExtensions) {
+            IJavaElement element = project.findElement(new Path(path + ext));
+            if (element != null) {
+                return element;
+            }
+        }
+        return null;
+    }
+
+    private boolean containsObsoleteMethods() throws DebugException {
+        List<ThreadReference> threads = currentDebugSession.getAllThreads();
+        for (ThreadReference thread : threads) {
+            if (!thread.isSuspended()) {
+                continue;
+            }
+            List<StackFrame> frames = getStackFrames(thread, true);
+            if (frames == null || frames.isEmpty()) {
+                continue;
+            }
+            for (StackFrame frame : frames) {
+                if (StackFrameUtility.isObsolete(frame)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private List<StackFrame> getStackFrames(ThreadReference thread, boolean refresh) {
+        return threadFrameMap.compute(thread, (key, oldValue) -> {
+            try {
+                return oldValue == null || refresh ? key.frames() : oldValue;
+            } catch (IncompatibleThreadStateException e) {
+                logger.log(Level.SEVERE, "Failed to get stack frames: " + e.getMessage(), e);
+                return oldValue;
+            }
+        });
+    }
+
+    /**
+     * Trigger build separately if the main project is a BSP project.
+     * This is because auto build for BSP project will not update the class files to disk.
+     */
+    private void triggerBuildForBspProject() {
+        // check if the workspace contains BSP project first. This is for performance consideration.
+        // Due to that getJavaProjectFromType() is a heavy operation.
+        if (!containsBspProjects()) {
+            return;
+        }
+
+        IProject mainProject = JdtUtils.getMainProject(this.mainProjectName, context.getMainClass());
+        if (mainProject != null && JdtUtils.isBspProject(mainProject)) {
+            try {
+                ResourcesPlugin.getWorkspace().build(
+                    new IBuildConfiguration[]{mainProject.getActiveBuildConfig()},
+                    IncrementalProjectBuilder.INCREMENTAL_BUILD,
+                    false /*buildReference*/,
+                    new NullProgressMonitor()
+                );
+            } catch (CoreException e) {
+                // ignore compilation errors
+            }
+        }
+    }
+
+    private boolean containsBspProjects() {
+        for (IJavaProject javaProject : ProjectUtils.getJavaProjects()) {
+            if (JdtUtils.isBspProject(javaProject.getProject())) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtProviderContextFactory.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtProviderContextFactory.java
index 0c8a1f812..7213f8e9a 100644
--- a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtProviderContextFactory.java
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtProviderContextFactory.java
@@ -11,10 +11,14 @@
 
 package com.microsoft.java.debug.plugin.internal;
 
+import com.microsoft.java.debug.core.adapter.ICompletionsProvider;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.adapter.IHotCodeReplaceProvider;
 import com.microsoft.java.debug.core.adapter.IProviderContext;
 import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
 import com.microsoft.java.debug.core.adapter.IVirtualMachineManagerProvider;
 import com.microsoft.java.debug.core.adapter.ProviderContext;
+import com.microsoft.java.debug.plugin.internal.eval.JdtEvaluationProvider;
 
 /**
  * <code>IProviderContext</code> creator using language server.
@@ -28,6 +32,10 @@ public static IProviderContext createProviderContext() {
         IProviderContext context = new ProviderContext();
         context.registerProvider(ISourceLookUpProvider.class, new JdtSourceLookUpProvider());
         context.registerProvider(IVirtualMachineManagerProvider.class, new JdtVirtualMachineManagerProvider());
+        context.registerProvider(IHotCodeReplaceProvider.class, new JavaHotCodeReplaceProvider());
+        context.registerProvider(IEvaluationProvider.class, new JdtEvaluationProvider());
+        context.registerProvider(ICompletionsProvider.class, new CompletionsProvider());
+
         return context;
     }
 }
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtSourceLookUpProvider.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtSourceLookUpProvider.java
index 614b1b295..2c39425ed 100644
--- a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtSourceLookUpProvider.java
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtSourceLookUpProvider.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2017 Microsoft Corporation and others.
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -17,66 +17,107 @@
 import java.io.InputStreamReader;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.jar.Attributes;
+import java.util.jar.Manifest;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
-import org.eclipse.core.resources.IProject;
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.URIUtil;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
 import org.eclipse.jdt.core.IBuffer;
 import org.eclipse.jdt.core.IClassFile;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
 import org.eclipse.jdt.core.ITypeRoot;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.core.ToolFactory;
+import org.eclipse.jdt.core.Signature;
 import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.ASTParser;
+import org.eclipse.jdt.core.dom.ASTVisitor;
 import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jdt.core.search.IJavaSearchConstants;
-import org.eclipse.jdt.core.search.IJavaSearchScope;
-import org.eclipse.jdt.core.search.SearchEngine;
-import org.eclipse.jdt.core.search.SearchMatch;
-import org.eclipse.jdt.core.search.SearchParticipant;
-import org.eclipse.jdt.core.search.SearchPattern;
-import org.eclipse.jdt.core.search.SearchRequestor;
-import org.eclipse.jdt.core.util.ClassFileBytesDisassembler;
-import org.eclipse.jdt.internal.debug.core.breakpoints.ValidBreakpointLocationLocator;
+import org.eclipse.jdt.core.dom.IMethodBinding;
+import org.eclipse.jdt.core.dom.ITypeBinding;
+import org.eclipse.jdt.core.dom.LambdaExpression;
+import org.eclipse.jdt.core.manipulation.CoreASTProvider;
+import org.eclipse.jdt.internal.core.JarPackageFragmentRoot;
+import org.eclipse.jdt.launching.IVMInstall;
+import org.eclipse.jdt.launching.JavaRuntime;
+import org.eclipse.jdt.launching.LibraryLocation;
+import org.eclipse.jdt.ls.core.internal.DecompilerResult;
+import org.eclipse.jdt.ls.core.internal.JDTUtils;
+import org.eclipse.jdt.ls.core.internal.JavaLanguageServerPlugin;
+import org.eclipse.jdt.ls.core.internal.managers.ContentProviderManager;
 
+import com.microsoft.java.debug.BindingUtils;
+import com.microsoft.java.debug.BreakpointLocationLocator;
+import com.microsoft.java.debug.LambdaExpressionLocator;
 import com.microsoft.java.debug.core.Configuration;
 import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.DebugSettings;
+import com.microsoft.java.debug.core.DebugSettings.Switch;
+import com.microsoft.java.debug.core.JavaBreakpointLocation;
 import com.microsoft.java.debug.core.adapter.AdapterUtils;
 import com.microsoft.java.debug.core.adapter.Constants;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
 import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
+import com.microsoft.java.debug.core.protocol.Types.BreakpointLocation;
+import com.microsoft.java.debug.core.protocol.Types.SourceBreakpoint;
 
 public class JdtSourceLookUpProvider implements ISourceLookUpProvider {
     private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
     private static final String JDT_SCHEME = "jdt";
     private static final String PATH_SEPARATOR = "/";
-    private static final String MISSING_SOURCES_HEADER = " // Failed to get sources. Instead, stub sources have been generated.\n"
-            + " // Implementation of methods is unavailable.\n";
-    private static final String LF = "\n";
+    private static final Set<String> IMPLICITLY_DECLARED_CLASSES = new HashSet<>(
+        Arrays.asList("org.eclipse.jdt.core.dom.UnnamedClass",
+            "org.eclipse.jdt.core.dom.ImplicitTypeDeclaration"));
+    private ISourceContainer[] sourceContainers = null;
 
-    private HashMap<String, Object> context = new HashMap<String, Object>();
+    private HashMap<String, Object> options = new HashMap<String, Object>();
+    private String latestJavaVersion = null;
+    private int latestASTLevel;
+
+    public JdtSourceLookUpProvider() {
+        // Get the latest supported Java version by JDT tooling.
+        this.latestJavaVersion = JavaCore.latestSupportedJavaVersion();
+        // Get the mapped AST level for the latest Java version.
+        Map<String, String> javaOptions = JavaCore.getOptions();
+        javaOptions.put(JavaCore.COMPILER_SOURCE, latestJavaVersion);
+        this.latestASTLevel = new AST(javaOptions).apiLevel();
+    }
 
     @Override
-    public void initialize(Map<String, Object> props) {
+    public void initialize(IDebugAdapterContext context, Map<String, Object> props) {
         if (props == null) {
             throw new IllegalArgumentException("argument is null");
         }
-        context.putAll(props);
+        options.putAll(props);
+        // During initialization, trigger a background job to load the source containers
+        // to improve the perf.
+        new Thread(() -> {
+            getSourceContainers();
+        }).start();
     }
 
     @Override
@@ -106,85 +147,294 @@ public String[] getFullyQualifiedName(String uri, int[] lines, int[] columns) th
             return new String[0];
         }
 
-        // Currently the highest version the debugger supports is Java SE 8 Edition (JLS8).
-        final ASTParser parser = ASTParser.newParser(AST.JLS8);
+        SourceBreakpoint[] sourceBreakpoints = new SourceBreakpoint[lines.length];
+        for (int i = 0; i < lines.length; i++) {
+            sourceBreakpoints[i] = new SourceBreakpoint(lines[i], columns[i]);
+        }
+
+        JavaBreakpointLocation[] locations = getBreakpointLocations(uri, sourceBreakpoints);
+        return Stream.of(locations).map(location -> {
+            if (location.className() != null && location.methodName() != null) {
+                return location.className()
+                        .concat("#").concat(location.methodName())
+                        .concat("#").concat(location.methodSignature());
+            }
+            return location.className();
+        }).toArray(String[]::new);
+    }
+
+    @Override
+    public JavaBreakpointLocation[] getBreakpointLocations(String sourceUri, SourceBreakpoint[] sourceBreakpoints)
+            throws DebugException {
+        if (sourceUri == null) {
+            throw new IllegalArgumentException("sourceUri is null");
+        }
+
+        if (sourceBreakpoints == null || sourceBreakpoints.length == 0) {
+            return new JavaBreakpointLocation[0];
+        }
+
+        CompilationUnit astUnit = asCompilationUnit(sourceUri);
+        JavaBreakpointLocation[] sourceLocations = Stream.of(sourceBreakpoints)
+                .map(sourceBreakpoint -> new JavaBreakpointLocation(sourceBreakpoint.line, sourceBreakpoint.column))
+                .toArray(JavaBreakpointLocation[]::new);
+        if (astUnit != null) {
+            List<?> types = astUnit.types();
+            String unnamedClass = null;
+            // See https://github.com/eclipse-jdt/eclipse.jdt.core/pull/2220
+            // Given that the JDT plans to rename UnamedClass to ImplicitTypeDeclaration, we will check
+            // the class name of the ASTNode to prevent the potential breaking in the future.
+            if (types.size() == 1 && IMPLICITLY_DECLARED_CLASSES.contains(types.get(0).getClass().getName())) {
+                unnamedClass = inferPrimaryTypeName(sourceUri, astUnit);
+            }
+            Map<Integer, BreakpointLocation[]> resolvedLocations = new HashMap<>();
+            for (JavaBreakpointLocation sourceLocation : sourceLocations) {
+                int sourceLine = sourceLocation.lineNumber();
+                int sourceColumn = sourceLocation.columnNumber();
+                if (sourceColumn > -1) {
+                    // if we have a column, try to find the lambda expression at that column
+                    LambdaExpressionLocator lambdaExpressionLocator = new LambdaExpressionLocator(astUnit,
+                            sourceLine, sourceColumn);
+                    astUnit.accept(lambdaExpressionLocator);
+                    if (lambdaExpressionLocator.isFound()) {
+                        sourceLocation.setClassName(lambdaExpressionLocator.getFullyQualifiedTypeName());
+                        sourceLocation.setMethodName(lambdaExpressionLocator.getMethodName());
+                        sourceLocation.setMethodSignature(lambdaExpressionLocator.getMethodSignature());
+                    }
+
+                    if (resolvedLocations.containsKey(sourceLine)) {
+                        sourceLocation.setAvailableBreakpointLocations(resolvedLocations.get(sourceLine));
+                    } else {
+                        BreakpointLocation[] inlineLocations = getInlineBreakpointLocations(astUnit, sourceLine);
+                        sourceLocation.setAvailableBreakpointLocations(inlineLocations);
+                        resolvedLocations.put(sourceLine, inlineLocations);
+                    }
+
+                    continue;
+                }
+
+                // TODO
+                // The ValidBreakpointLocationLocator will verify if the current line is a valid
+                // location or not.
+                // If so, it will return the fully qualified name of the class type that
+                // contains the current line.
+                // Otherwise, it will try to find a valid location from the next lines and
+                // return it's fully qualified name.
+                // In current stage, we don't support to move the invalid breakpoint down to the
+                // next valid location, and just
+                // mark it as "unverified".
+                // In future, we could consider supporting to update the breakpoint to a valid
+                // location.
+
+                // passing the offset to the constructor, it can recognize the multiline lambda
+                // expression well
+                BreakpointLocationLocator locator = new BreakpointLocationLocator(astUnit,
+                        sourceLine, true, true, astUnit.getPosition(sourceLine, 0), 0);
+                astUnit.accept(locator);
+                // When the final valid line location is same as the original line, that
+                // represents it's a valid breakpoint.
+                // Add location type check to avoid breakpoint on method/field which will never
+                // be hit in current implementation.
+                if (sourceLine == locator.getLineLocation()
+                        && locator.getLocationType() == BreakpointLocationLocator.LOCATION_LINE) {
+                    sourceLocation.setClassName(StringUtils.isBlank(unnamedClass) ? locator.getFullyQualifiedTypeName() : unnamedClass);
+                    if (resolvedLocations.containsKey(sourceLine)) {
+                        sourceLocation.setAvailableBreakpointLocations(resolvedLocations.get(sourceLine));
+                    } else {
+                        BreakpointLocation[] inlineLocations = getInlineBreakpointLocations(astUnit, sourceLine);
+                        sourceLocation.setAvailableBreakpointLocations(inlineLocations);
+                        resolvedLocations.put(sourceLine, inlineLocations);
+                    }
+                } else if (locator.getLocationType() == BreakpointLocationLocator.LOCATION_METHOD) {
+                    sourceLocation.setClassName(StringUtils.isBlank(unnamedClass) ? locator.getFullyQualifiedTypeName() : unnamedClass);
+                    sourceLocation.setMethodName(locator.getMethodName());
+                    sourceLocation.setMethodSignature(locator.getMethodSignature());
+                }
+            }
+        }
+
+        return sourceLocations;
+    }
+
+    private String inferPrimaryTypeName(String uri, CompilationUnit astUnit) {
+        String fileName = "";
+        String filePath = AdapterUtils.toPath(uri);
+        if (filePath != null && Files.isRegularFile(Paths.get(filePath))) {
+            fileName = Paths.get(filePath).getFileName().toString();
+        } else if (astUnit.getTypeRoot() != null) {
+            fileName = astUnit.getTypeRoot().getElementName();
+        }
+
+        if (StringUtils.isNotBlank(fileName)) {
+            String[] extensions = JavaCore.getJavaLikeExtensions();
+            for (String extension : extensions) {
+                if (fileName.endsWith("." + extension)) {
+                    return fileName.substring(0, fileName.length() - 1 - extension.length());
+                }
+            }
+        }
+
+        return fileName;
+    }
+
+    private BreakpointLocation[] getInlineBreakpointLocations(final CompilationUnit astUnit, int sourceLine) {
+        List<BreakpointLocation> locations = new ArrayList<>();
+        // The starting position of each line is the default breakpoint location for
+        // that line.
+        locations.add(new BreakpointLocation(sourceLine, 0));
+        astUnit.accept(new ASTVisitor() {
+            @Override
+            public boolean visit(LambdaExpression node) {
+                int lambdaStart = node.getStartPosition();
+                int startLine = astUnit.getLineNumber(lambdaStart);
+                if (startLine == sourceLine) {
+                    int startColumn = astUnit.getColumnNumber(lambdaStart);
+                    int lambdaEnd = lambdaStart + node.getLength();
+                    int endLine = astUnit.getLineNumber(lambdaEnd);
+                    int endColumn = astUnit.getColumnNumber(lambdaEnd);
+                    BreakpointLocation location = new BreakpointLocation(startLine, startColumn, endLine, endColumn);
+                    locations.add(location);
+                }
+                return super.visit(node);
+            }
+        });
+
+        return locations.toArray(BreakpointLocation[]::new);
+    }
+
+    private CompilationUnit asCompilationUnit(String uri) {
+        final ASTParser parser = ASTParser.newParser(this.latestASTLevel);
         parser.setResolveBindings(true);
         parser.setBindingsRecovery(true);
         parser.setStatementsRecovery(true);
         CompilationUnit astUnit = null;
         String filePath = AdapterUtils.toPath(uri);
-        // For file uri, read the file contents directly and pass them to the ast parser.
+        // For file uri, read the file contents directly and pass them to the ast
+        // parser.
         if (filePath != null && Files.isRegularFile(Paths.get(filePath))) {
-            Charset cs = (Charset) this.context.get(Constants.DEBUGGEE_ENCODING);
-            if (cs == null) {
-                cs = Charset.defaultCharset();
-            }
-            String source = readFile(filePath, cs);
+            String source = readFile(filePath);
             parser.setSource(source.toCharArray());
             /**
              * See the java doc for { @link ASTParser#setResolveBindings(boolean) }.
-             * Binding information is obtained from the Java model. This means that the compilation unit must be located relative to the Java model.
-             * This happens automatically when the source code comes from either setSource(ICompilationUnit) or setSource(IClassFile).
-             * When source is supplied by setSource(char[]), the location must be established explicitly
-             * by setting an environment using setProject(IJavaProject) or setEnvironment(String [], String [], String [], boolean)
+             * Binding information is obtained from the Java model. This means that the
+             * compilation unit must be located relative to the Java model.
+             * This happens automatically when the source code comes from either
+             * setSource(ICompilationUnit) or setSource(IClassFile).
+             * When source is supplied by setSource(char[]), the location must be
+             * established explicitly
+             * by setting an environment using setProject(IJavaProject) or
+             * setEnvironment(String [], String [], String [], boolean)
              * and a unit name setUnitName(String).
              */
-            parser.setEnvironment(new String[0], new String[0], null, true);
+            IFile resource = (IFile) JDTUtils.findResource(JDTUtils.toURI(uri),
+                    ResourcesPlugin.getWorkspace().getRoot()::findFilesForLocationURI);
+            if (resource != null && JdtUtils.isJavaProject(resource.getProject())) {
+                parser.setProject(JavaCore.create(resource.getProject()));
+            } else {
+                parser.setEnvironment(new String[0], new String[0], null, true);
+                /**
+                 * See the java doc for { @link ASTParser#setSource(char[]) },
+                 * the user need specify the compiler options explicitly.
+                 */
+                Map<String, String> javaOptions = JavaCore.getOptions();
+                javaOptions.put(JavaCore.COMPILER_SOURCE, this.latestJavaVersion);
+                javaOptions.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, this.latestJavaVersion);
+                javaOptions.put(JavaCore.COMPILER_COMPLIANCE, this.latestJavaVersion);
+                javaOptions.put(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED);
+                parser.setCompilerOptions(javaOptions);
+            }
             parser.setUnitName(Paths.get(filePath).getFileName().toString());
-            /**
-             * See the java doc for { @link ASTParser#setSource(char[]) },
-             * the user need specify the compiler options explicitly.
-             */
-            Map<String, String> options = JavaCore.getOptions();
-            options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_8);
-            options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_8);
-            options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_8);
-            parser.setCompilerOptions(options);
             astUnit = (CompilationUnit) parser.createAST(null);
         } else {
             // For non-file uri (e.g. jdt://contents/rt.jar/java.io/PrintStream.class),
             // leverage jdt to load the source contents.
-            ITypeRoot typeRoot = resolveClassFile(uri);
-            if (typeRoot != null) {
-                parser.setSource(typeRoot);
-                astUnit = (CompilationUnit) parser.createAST(null);
-            }
-        }
-
-        String[] fqns = new String[lines.length];
-        if (astUnit != null) {
-            for (int i = 0; i < lines.length; i++) {
-                // TODO
-                // The ValidBreakpointLocationLocator will verify if the current line is a valid location or not.
-                // If so, it will return the fully qualified name of the class type that contains the current line.
-                // Otherwise, it will try to find a valid location from the next lines and return it's fully qualified name.
-                // In current stage, we don't support to move the invalid breakpoint down to the next valid location, and just
-                // mark it as "unverified".
-                // In future, we could consider supporting to update the breakpoint to a valid location.
-                ValidBreakpointLocationLocator locator = new ValidBreakpointLocationLocator(astUnit, lines[i], true, true);
-                astUnit.accept(locator);
-                // When the final valid line location is same as the original line, that represents it's a valid breakpoint.
-                if (lines[i] == locator.getLineLocation()) {
-                    fqns[i] = locator.getFullyQualifiedTypeName();
+            IClassFile typeRoot = resolveClassFile(uri);
+            try {
+                if (typeRoot != null && typeRoot.getSourceRange() != null) {
+                    parser.setSource(typeRoot);
+                    astUnit = (CompilationUnit) parser.createAST(null);
+                } else if (typeRoot != null && DebugSettings.getCurrent().debugSupportOnDecompiledSource == Switch.ON) {
+                    ContentProviderManager contentProvider = JavaLanguageServerPlugin.getContentProviderManager();
+                    try {
+                        String contents = contentProvider.getSource(typeRoot, new NullProgressMonitor());
+                        if (contents != null && !contents.isBlank()) {
+                            IJavaProject javaProject = typeRoot.getJavaProject();
+                            if (javaProject != null) {
+                                parser.setProject(javaProject);
+                            } else {
+                                parser.setEnvironment(new String[0], new String[0], null, true);
+                                /**
+                                 * See the java doc for { @link ASTParser#setSource(char[]) },
+                                 * the user need specify the compiler options explicitly.
+                                 */
+                                Map<String, String> javaOptions = JavaCore.getOptions();
+                                javaOptions.put(JavaCore.COMPILER_SOURCE, this.latestJavaVersion);
+                                javaOptions.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, this.latestJavaVersion);
+                                javaOptions.put(JavaCore.COMPILER_COMPLIANCE, this.latestJavaVersion);
+                                javaOptions.put(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED);
+                                parser.setCompilerOptions(javaOptions);
+                            }
+                            parser.setUnitName(typeRoot.getElementName());
+                            parser.setSource(contents.toCharArray());
+                            astUnit = (CompilationUnit) parser.createAST(null);
+                        }
+                    } catch (Exception e) {
+                        JavaLanguageServerPlugin.logException(e.getMessage(), e);
+                    }
                 }
+            } catch (JavaModelException e) {
+                // ignore
             }
         }
-        return fqns;
+        return astUnit;
     }
 
     @Override
     public String getSourceFileURI(String fullyQualifiedName, String sourcePath) {
-        if (fullyQualifiedName == null) {
-            throw new IllegalArgumentException("fullyQualifiedName is null");
+        if (sourcePath == null) {
+            return null;
         }
-        // Jdt Search Engine doesn't support searching anonymous class or local type directly.
-        // But because the inner class and anonymous class have the same java file as the enclosing type,
-        // search their enclosing type instead.
-        if (fullyQualifiedName.indexOf("$") >= 0) {
-            return searchDeclarationFileByFqn(AdapterUtils.parseEnclosingType(fullyQualifiedName));
-        } else {
-            return searchDeclarationFileByFqn(fullyQualifiedName);
+
+        Object sourceElement = JdtUtils.findSourceElement(sourcePath, getSourceContainers());
+        if (sourceElement instanceof IResource) {
+            return getFileURI((IResource) sourceElement);
+        } else if (sourceElement instanceof IClassFile) {
+            return getFileURI((IClassFile) sourceElement);
         }
+        return null;
+    }
+
+    @Override
+    public String getJavaRuntimeVersion(String projectName) {
+        IJavaProject project = JdtUtils.getJavaProject(projectName);
+        if (project != null) {
+            try {
+                IVMInstall vmInstall = JavaRuntime.getVMInstall(project);
+                if (vmInstall == null || vmInstall.getInstallLocation() == null) {
+                    return null;
+                }
+
+                return resolveSystemLibraryVersion(project, vmInstall);
+            } catch (CoreException e) {
+                logger.log(Level.SEVERE,
+                        "Failed to get Java runtime version for project '" + projectName + "': " + e.getMessage(), e);
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Get the project associated source containers.
+     *
+     * @return the initialized source container list
+     */
+    public synchronized ISourceContainer[] getSourceContainers() {
+        if (sourceContainers == null) {
+            sourceContainers = JdtUtils.getSourceContainers((String) options.get(Constants.PROJECT_NAME));
+        }
+
+        return sourceContainers;
     }
 
     @Override
@@ -204,11 +454,9 @@ private String getContents(IClassFile cf) {
                 if (buffer != null) {
                     source = buffer.getContents();
                 }
-                if (source == null) {
-                    source = disassemble(cf);
-                }
             } catch (JavaModelException e) {
-                logger.log(Level.SEVERE, String.format("Failed to parse the source contents of the class file: %s", e.toString()), e);
+                logger.log(Level.SEVERE,
+                        String.format("Failed to parse the source contents of the class file: %s", e.toString()), e);
             }
             if (source == null) {
                 source = "";
@@ -217,80 +465,15 @@ private String getContents(IClassFile cf) {
         return source;
     }
 
-    private IJavaProject getJavaProjectFromName(String projectName) throws CoreException {
-        IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
-        IProject project = root.getProject(projectName);
-        if (!project.exists()) {
-            throw new CoreException(new Status(IStatus.ERROR, JavaDebuggerServerPlugin.PLUGIN_ID, "Not an existing project."));
-        }
-        if (!project.isNatureEnabled("org.eclipse.jdt.core.javanature")) {
-            throw new CoreException(new Status(IStatus.ERROR, JavaDebuggerServerPlugin.PLUGIN_ID, "Not a project with java nature."));
-        }
-        IJavaProject javaProject = JavaCore.create(project);
-        return javaProject;
-    }
-
-    private String searchDeclarationFileByFqn(String fullyQualifiedName) {
-        String projectName = (String) context.get(Constants.PROJECTNAME);
-        try {
-            IJavaSearchScope searchScope = projectName != null
-                ? createSearchScope(getJavaProjectFromName(projectName))
-                : SearchEngine.createWorkspaceScope();
-            SearchPattern pattern = SearchPattern.createPattern(
-                fullyQualifiedName,
-                IJavaSearchConstants.TYPE,
-                IJavaSearchConstants.DECLARATIONS,
-                SearchPattern.R_EXACT_MATCH);
-            ArrayList<String> uris = new ArrayList<String>();
-            SearchRequestor requestor = new SearchRequestor() {
-                @Override
-                public void acceptSearchMatch(SearchMatch match) {
-                    Object element = match.getElement();
-                    if (element instanceof IType) {
-                        IType type = (IType) element;
-                        if (type.isBinary()) {
-                            try {
-                                // let the search engine to ignore those class files without attached source.
-                                if (type.getSource() != null) {
-                                    uris.add(getFileURI(type.getClassFile()));
-                                }
-                            } catch (JavaModelException e) {
-                                // ignore
-                            }
-                        } else {
-                            uris.add(getFileURI(type.getResource()));
-                        }
-                    }
-                }
-            };
-            SearchEngine searchEngine = new SearchEngine();
-            searchEngine.search(pattern, new SearchParticipant[] {
-                    SearchEngine.getDefaultSearchParticipant()
-                }, searchScope, requestor, null /* progress monitor */);
-            return uris.size() == 0 ? null : uris.get(0);
-        } catch (CoreException e) {
-            logger.log(Level.SEVERE, String.format("Failed to parse java project: %s", e.toString()), e);
-        }
-        return null;
-    }
-
     private static String getFileURI(IClassFile classFile) {
-        String packageName = classFile.getParent().getElementName();
-        String jarName = classFile.getParent().getParent().getElementName();
-        try {
-            return new URI(JDT_SCHEME, "contents", PATH_SEPARATOR + jarName + PATH_SEPARATOR + packageName
-                    + PATH_SEPARATOR + classFile.getElementName(), classFile.getHandleIdentifier(), null)
-                            .toASCIIString();
-        } catch (URISyntaxException e) {
-            e.printStackTrace();
-            return null;
-        }
+        return JDTUtils.toUri(classFile);
     }
 
     private static String getFileURI(IResource resource) {
         URI uri = resource.getLocationURI();
         if (uri != null) {
-            String uriString = uri.toString();
+            // If the file path contains non ASCII characters, encode the result.
+            String uriString = uri.toASCIIString();
             // Fix uris by adding missing // to single file:/ prefix.
             return uriString.replaceFirst("file:/([^/])", "file:///$1");
         }
@@ -315,31 +498,9 @@ private static IClassFile resolveClassFile(String uriString) {
         return null;
     }
 
-    private static String disassemble(IClassFile classFile) {
-        ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
-        String disassembledByteCode = null;
-        try {
-            disassembledByteCode = disassembler.disassemble(classFile.getBytes(), LF,
-                    ClassFileBytesDisassembler.WORKING_COPY);
-            disassembledByteCode = MISSING_SOURCES_HEADER + LF + disassembledByteCode;
-        } catch (Exception e) {
-            // ignore
-        }
-        return disassembledByteCode;
-    }
-
-    private static IJavaSearchScope createSearchScope(IJavaProject project) {
-        if (project == null) {
-            return SearchEngine.createWorkspaceScope();
-        }
-        return SearchEngine.createJavaSearchScope(new IJavaProject[] {project},
-                IJavaSearchScope.SOURCES | IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.SYSTEM_LIBRARIES);
-    }
-
-    private static String readFile(String filePath, Charset cs) {
+    private static String readFile(String filePath) {
         StringBuilder builder = new StringBuilder();
-        try (BufferedReader bufferReader =
-                new BufferedReader(new InputStreamReader(new FileInputStream(filePath), cs))) {
+        try (BufferedReader bufferReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)))) {
             final int BUFFER_SIZE = 4096;
             char[] buffer = new char[BUFFER_SIZE];
             while (true) {
@@ -354,4 +515,145 @@ private static String readFile(String filePath, Charset cs) {
         }
         return builder.toString();
     }
+
+    private static String resolveSystemLibraryVersion(IJavaProject project, IVMInstall vmInstall)
+            throws JavaModelException {
+        LibraryLocation[] libraries = JavaRuntime.getLibraryLocations(vmInstall);
+        if (libraries != null && libraries.length > 0) {
+            IPackageFragmentRoot root = project.findPackageFragmentRoot(libraries[0].getSystemLibraryPath());
+            if (!(root instanceof JarPackageFragmentRoot)) {
+                return null;
+            }
+            Manifest manifest = ((JarPackageFragmentRoot) root).getManifest();
+            if (manifest == null) {
+                return null;
+            }
+            Attributes attributes = manifest.getMainAttributes();
+            return attributes.getValue("Implementation-Version");
+        }
+
+        return null;
+    }
+
+    public List<MethodInvocation> findMethodInvocations(String uri, int line) {
+        if (uri == null) {
+            return Collections.emptyList();
+        }
+
+        boolean useCache = false;
+        CompilationUnit cachedUnit = CoreASTProvider.getInstance().getCachedAST();
+        if (cachedUnit != null) {
+            ITypeRoot cachedElement = cachedUnit.getTypeRoot();
+            if (cachedElement != null && isSameURI(JDTUtils.toUri(cachedElement), uri)) {
+                useCache = true;
+            }
+        }
+
+        final CompilationUnit astUnit = useCache ? cachedUnit : asCompilationUnit(uri);
+        if (astUnit == null) {
+            return Collections.emptyList();
+        }
+
+        MethodInvocationLocator locator = new MethodInvocationLocator(line, astUnit);
+        astUnit.accept(locator);
+
+        return locator.getTargets().entrySet().stream().map(entry -> {
+            MethodInvocation invocation = new MethodInvocation();
+            ASTNode astNode = entry.getKey();
+            invocation.expression = astNode.toString();
+            IMethodBinding binding = entry.getValue().getMethodDeclaration();
+            invocation.methodName = binding.isConstructor() ? "<init>" : binding.getName();
+            if (binding.getDeclaringClass().isAnonymous()) {
+                ITypeBinding superclass = binding.getDeclaringClass().getSuperclass();
+                if (superclass != null
+                        && !superclass.isEqualTo(astUnit.getAST().resolveWellKnownType("java.lang.Object"))) {
+                    invocation.declaringTypeName = superclass.getBinaryName();
+                } else {
+                    return null;
+                }
+            } else {
+                // Keep consistent with JDI since JDI uses binary class name
+                invocation.declaringTypeName = binding.getDeclaringClass().getBinaryName();
+            }
+            invocation.methodGenericSignature = BindingUtils.toSignature(binding);
+            invocation.methodSignature = Signature.getTypeErasure(invocation.methodGenericSignature);
+            int startOffset = astNode.getStartPosition();
+            if (astNode instanceof org.eclipse.jdt.core.dom.MethodInvocation) {
+                // The range covered by the stepIn target should start with the method name.
+                startOffset = ((org.eclipse.jdt.core.dom.MethodInvocation) astNode).getName().getStartPosition();
+            }
+            invocation.lineStart = astUnit.getLineNumber(startOffset);
+            invocation.columnStart = astUnit.getColumnNumber(startOffset);
+            int endOffset = astNode.getStartPosition() + astNode.getLength();
+            invocation.lineEnd = astUnit.getLineNumber(endOffset);
+            invocation.columnEnd = astUnit.getColumnNumber(endOffset);
+            return invocation;
+        }).filter(Objects::nonNull).collect(Collectors.toList());
+    }
+
+    private boolean isSameURI(String uri1, String uri2) {
+        if (Objects.equals(uri1, uri2)) {
+            return true;
+        }
+
+        try {
+            return URIUtil.sameURI(new URI(uri1), new URI(uri2));
+        } catch (URISyntaxException e) {
+            return false;
+        }
+    }
+
+    public int[] getOriginalLineMappings(String uri) {
+        IClassFile classFile = resolveClassFile(uri);
+        try {
+            if (classFile == null) {
+                return null;
+            }
+
+            IPackageFragmentRoot packageRoot = (IPackageFragmentRoot) classFile.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
+            if (packageRoot != null && packageRoot.getSourceAttachmentPath() != null) {
+                return null;
+            }
+
+            if (classFile.getSourceRange() == null) {
+                ContentProviderManager contentProvider = JavaLanguageServerPlugin.getContentProviderManager();
+                try {
+                    DecompilerResult result = contentProvider.getSourceResult(classFile, new NullProgressMonitor());
+                    if (result != null) {
+                        return result.getOriginalLineMappings();
+                    }
+                } catch (NoSuchMethodError e) {
+                    // ignore it if old language server version is installed.
+                } catch (Exception e) {
+                    JavaLanguageServerPlugin.logException(e.getMessage(), e);
+                }
+            }
+        } catch (JavaModelException e) {
+            // ignore
+        }
+        return null;
+    }
+
+    public int[] getDecompiledLineMappings(String uri) {
+        IClassFile classFile = resolveClassFile(uri);
+        try {
+            if (classFile != null && classFile.getSourceRange() == null) {
+                ContentProviderManager contentProvider = JavaLanguageServerPlugin.getContentProviderManager();
+                try {
+                    DecompilerResult result = contentProvider.getSourceResult(classFile, new NullProgressMonitor());
+                    if (result != null) {
+                        return result.getDecompiledLineMappings();
+                    }
+                } catch (NoSuchMethodError e) {
+                    // ignore it if old Java language server version is installed.
+                } catch (Exception e) {
+                    JavaLanguageServerPlugin.logException(e.getMessage(), e);
+                }
+            }
+        } catch (JavaModelException e) {
+            // ignore
+        }
+
+        return null;
+    }
 }
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtUtils.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtUtils.java
new file mode 100644
index 000000000..66562ae74
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtUtils.java
@@ -0,0 +1,452 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
+import org.eclipse.jdt.core.IClassFile;
+import org.eclipse.jdt.core.IClasspathAttribute;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IModuleDescription;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
+import org.eclipse.jdt.launching.JavaRuntime;
+import org.eclipse.jdt.launching.sourcelookup.containers.JavaProjectSourceContainer;
+import org.eclipse.jdt.launching.sourcelookup.containers.PackageFragmentRootSourceContainer;
+import org.eclipse.jdt.ls.core.internal.JavaLanguageServerPlugin;
+import org.eclipse.jdt.ls.core.internal.ProjectUtils;
+
+import com.microsoft.java.debug.core.DebugException;
+import com.microsoft.java.debug.core.StackFrameUtility;
+import com.sun.jdi.AbsentInformationException;
+import com.sun.jdi.ArrayType;
+import com.sun.jdi.ClassNotLoadedException;
+import com.sun.jdi.Location;
+import com.sun.jdi.ReferenceType;
+import com.sun.jdi.StackFrame;
+import com.sun.jdi.Type;
+
+public class JdtUtils {
+    private static final String TEST_SCOPE = "test";
+    private static final String MAVEN_SCOPE_ATTRIBUTE = "maven.scope";
+    private static final String GRADLE_SCOPE_ATTRIBUTE = "gradle_scope";
+
+    /**
+     * Returns the module this project represents or null if the Java project doesn't represent any named module.
+     */
+    public static String getModuleName(IJavaProject project) {
+        if (project == null || !JavaRuntime.isModularProject(project)) {
+            return null;
+        }
+        IModuleDescription module;
+        try {
+            module = project.getModuleDescription();
+        } catch (CoreException e) {
+            return null;
+        }
+        return module == null ? null : module.getElementName();
+    }
+
+    /**
+     * Check if the project is a java project or not.
+     */
+    public static boolean isJavaProject(IProject project) {
+        if (project == null || !project.exists()) {
+            return false;
+        }
+        try {
+            if (!project.isNatureEnabled(JavaCore.NATURE_ID)) {
+                return false;
+            }
+        } catch (CoreException e) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * If the project represents a java project, then convert it to a java project.
+     * Otherwise, return null.
+     */
+    public static IJavaProject getJavaProject(IProject project) {
+        if (isJavaProject(project)) {
+            return JavaCore.create(project);
+        }
+        return null;
+    }
+
+    /**
+     * Given the project name, return the corresponding java project model.
+     * If the project doesn't exist or not a java project, return null.
+     */
+    public static IJavaProject getJavaProject(String projectName) {
+        if (StringUtils.isBlank(projectName)) {
+            return null;
+        }
+        IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+        IProject project = root.getProject(projectName);
+        return getJavaProject(project);
+    }
+
+    /**
+     * List all available Java projects of the specified workspace.
+     */
+    public static List<IJavaProject> listJavaProjects(IWorkspaceRoot workspace) {
+        List<IJavaProject> results = new ArrayList<>();
+        for (IProject project : workspace.getProjects()) {
+            if (isJavaProject(project)) {
+                results.add(JavaCore.create(project));
+            }
+        }
+        return results;
+    }
+
+    /**
+     * Given the project name, return the corresponding project object.
+     * If the project doesn't exist, return null.
+     */
+    public static IProject getProject(String projectName) {
+        if (StringUtils.isBlank(projectName)) {
+            return null;
+        }
+        IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+        return root.getProject(projectName);
+    }
+
+    /**
+     * Compute the fragment roots for each test source folders.
+     *
+     * @param project the java project.
+     * @return the fragment roots for each test source folders.
+     */
+    public static IPackageFragmentRoot[] getTestPackageFragmentRoots(IJavaProject project) {
+        try {
+            IPackageFragmentRoot[] packageFragmentRoot = project.getPackageFragmentRoots();
+            List<IPackageFragmentRoot> sources = new ArrayList<>();
+            for (int i = 0; i < packageFragmentRoot.length; i++) {
+                if (packageFragmentRoot[i].getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT
+                        && packageFragmentRoot[i].getKind() == IPackageFragmentRoot.K_SOURCE) {
+                    IClasspathEntry cpe = packageFragmentRoot[i].getResolvedClasspathEntry();
+
+                    if (isTest(cpe)) {
+                        sources.add(packageFragmentRoot[i]);
+                    }
+                }
+            }
+            return sources.toArray(new IPackageFragmentRoot[0]);
+        } catch (JavaModelException e) {
+            // ignore
+            return new IPackageFragmentRoot[0];
+        }
+    }
+
+    /**
+     * There is an issue on IClasspathEntry#isTest: it will return true if the scope is runtime, so we will this method for testing whether
+     * the classpath entry is for test only.
+     *
+     * @param classpathEntry classpath entry
+     * @return whether this classpath entry is only used in test
+     */
+    public static boolean isTest(final IClasspathEntry classpathEntry) {
+        for (IClasspathAttribute attribute : classpathEntry.getExtraAttributes()) {
+            if (GRADLE_SCOPE_ATTRIBUTE.equals(attribute.getName()) || MAVEN_SCOPE_ATTRIBUTE.equals(attribute.getName())) {
+                return TEST_SCOPE.equals(attribute.getValue());
+            }
+        }
+        return classpathEntry.isTest();
+    }
+
+    /**
+     * Compute the possible source containers that the specified project could be associated with.
+     * <p>
+     * If the project name is specified, it will put the source containers parsed from the specified project's
+     * classpath entries in the front of the result, then the other projects at the same workspace.
+     * </p>
+     * <p>
+     * Otherwise, just loop every projects at the current workspace and combine the parsed source containers directly.
+     * </p>
+     * @param projectName
+     *                  the project name.
+     * @return the possible source container list.
+     */
+    public static ISourceContainer[] getSourceContainers(String projectName) {
+        Set<ISourceContainer> containers = new LinkedHashSet<>();
+        List<IProject> projects = new ArrayList<>();
+
+        // If the project name is specified, firstly compute the source containers from the specified project's
+        // classpath entries so that they can be placed in the front of the result.
+        IProject targetProject = JdtUtils.getProject(projectName);
+        if (targetProject != null) {
+            projects.add(targetProject);
+        }
+
+        List<IProject> workspaceProjects = Arrays.asList(ResourcesPlugin.getWorkspace().getRoot().getProjects());
+        projects.addAll(workspaceProjects);
+
+        Set<IRuntimeClasspathEntry> calculated = new LinkedHashSet<>();
+
+        projects.stream().distinct().map(project -> JdtUtils.getJavaProject(project))
+            .filter(javaProject -> javaProject != null && javaProject.exists())
+            .forEach(javaProject -> {
+                // Add source containers associated with the project's source folders.
+                containers.add(new JavaProjectSourceContainer(javaProject));
+                // Add source containers associated with the project's runtime classpath entries.
+                containers.addAll(Arrays.asList(getSourceContainers(javaProject, calculated)));
+            });
+
+        return containers.toArray(new ISourceContainer[0]);
+    }
+
+    private static ISourceContainer[] getSourceContainers(IJavaProject project, Set<IRuntimeClasspathEntry> calculated) {
+        if (project == null || !project.exists()) {
+            return new ISourceContainer[0];
+        }
+
+        try {
+            IRuntimeClasspathEntry[] unresolved = JavaRuntime.computeUnresolvedRuntimeClasspath(project);
+            List<IRuntimeClasspathEntry> resolved = new ArrayList<>();
+            for (IRuntimeClasspathEntry entry : unresolved) {
+                for (IRuntimeClasspathEntry resolvedEntry : JavaRuntime.resolveRuntimeClasspathEntry(entry, project)) {
+                    if (!calculated.contains(resolvedEntry)) {
+                        calculated.add(resolvedEntry);
+                        resolved.add(resolvedEntry);
+                    }
+                }
+            }
+            Set<ISourceContainer> containers = new LinkedHashSet<>();
+            containers.addAll(Arrays.asList(
+                    JavaRuntime.getSourceContainers(resolved.toArray(new IRuntimeClasspathEntry[0]))));
+
+            // Due to a known jdt java 9 support bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=525840,
+            // it would miss some JRE libraries source containers when the debugger is running on JDK9.
+            // As a workaround, recompute the possible source containers for JDK9 jrt-fs.jar libraries.
+            IRuntimeClasspathEntry jrtFs = resolved.stream().filter(entry -> {
+                return entry.getType() == IRuntimeClasspathEntry.ARCHIVE && entry.getPath().lastSegment().equals("jrt-fs.jar");
+            }).findFirst().orElse(null);
+            if (jrtFs != null && project.isOpen()) {
+                IPackageFragmentRoot[] allRoots = project.getPackageFragmentRoots();
+                for (IPackageFragmentRoot root : allRoots) {
+                    if (root.getPath().equals(jrtFs.getPath()) && isSourceAttachmentEqual(root, jrtFs)) {
+                        containers.add(new PackageFragmentRootSourceContainer(root));
+                    }
+                }
+            }
+
+            return containers.toArray(new ISourceContainer[0]);
+        } catch (CoreException ex) {
+         // do nothing.
+        }
+
+        return new ISourceContainer[0];
+    }
+
+    private static boolean isSourceAttachmentEqual(IPackageFragmentRoot root, IRuntimeClasspathEntry entry) throws JavaModelException {
+        IPath entryPath = entry.getSourceAttachmentPath();
+        if (entryPath == null) {
+            return true;
+        }
+        IPath rootPath = root.getSourceAttachmentPath();
+        if (rootPath == null) {
+            // entry has a source attachment that the package root does not
+            return false;
+        }
+        return rootPath.equals(entryPath);
+
+    }
+
+    /**
+     * Given a source name info, search the associated source file or class file from the source container list.
+     *
+     * @param sourcePath
+     *                  the target source name (e.g. com\microsoft\java\debug\xxx.java).
+     * @param containers
+     *                  the source container list.
+     * @return the associated source file or class file.
+     */
+    public static Object findSourceElement(String sourcePath, ISourceContainer[] containers) {
+        if (containers == null) {
+            return null;
+        }
+        for (ISourceContainer container : containers) {
+            try {
+                Object[] objects = container.findSourceElements(sourcePath);
+                if (objects.length > 0 && (objects[0] instanceof IResource || objects[0] instanceof IClassFile)) {
+                    return objects[0];
+                }
+            } catch (CoreException e) {
+                // do nothing.
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Given a stack frame, find the target java project that the associated source file belongs to.
+     *
+     * @param stackFrame
+     *                  the stack frame.
+     * @param containers
+     *                  the source container list.
+     * @return the java project.
+     */
+    public static IJavaProject findProject(StackFrame stackFrame, ISourceContainer[] containers) {
+        Location location = stackFrame.location();
+        try {
+            Object sourceElement = findSourceElement(location.sourcePath(), containers);
+            if (sourceElement instanceof IResource) {
+                return JavaCore.create(((IResource) sourceElement).getProject());
+            } else if (sourceElement instanceof IClassFile) {
+                IJavaProject javaProject = ((IClassFile) sourceElement).getJavaProject();
+                if (javaProject != null) {
+                    return javaProject;
+                }
+            }
+        } catch (AbsentInformationException e) {
+            // When the compiled .class file doesn't contain debug source information, return null.
+        }
+        return null;
+    }
+
+    /**
+     * Given a stack frame, get the fully qualified type name that associated with the frame.
+     * @param frame the stack frame
+     * @return the fully qualified type name
+     * @throws DebugException debug exception
+     */
+    public static String getDeclaringTypeName(StackFrame frame) throws DebugException {
+        return getGenericName(StackFrameUtility.getDeclaringType(frame));
+    }
+
+    private static String getGenericName(ReferenceType type) throws DebugException {
+        if (type instanceof ArrayType) {
+            try {
+                Type componentType;
+                componentType = ((ArrayType) type).componentType();
+                if (componentType instanceof ReferenceType) {
+                    return getGenericName((ReferenceType) componentType) + "[]"; //$NON-NLS-1$
+                }
+                return type.name();
+            } catch (ClassNotLoadedException e) {
+                // we cannot create the generic name using the component type,
+                // just try to create one with the information
+            }
+        }
+        String signature = type.signature();
+        StringBuffer res = new StringBuffer(getTypeName(signature));
+        String genericSignature = type.genericSignature();
+        if (genericSignature != null) {
+            String[] typeParameters = Signature.getTypeParameters(genericSignature);
+            if (typeParameters.length > 0) {
+                res.append('<').append(Signature.getTypeVariable(typeParameters[0]));
+                for (int i = 1; i < typeParameters.length; i++) {
+                    res.append(',').append(Signature.getTypeVariable(typeParameters[i]));
+                }
+                res.append('>');
+            }
+        }
+        return res.toString();
+    }
+
+    private static String getTypeName(String genericTypeSignature) {
+        int arrayDimension = 0;
+        while (genericTypeSignature.charAt(arrayDimension) == '[') {
+            arrayDimension++;
+        }
+        int parameterStart = genericTypeSignature.indexOf('<');
+        StringBuffer name = new StringBuffer();
+        if (parameterStart < 0) {
+            name.append(genericTypeSignature.substring(arrayDimension + 1, genericTypeSignature.length() - 1)
+                    .replace('/', '.'));
+        } else {
+            if (parameterStart != 0) {
+                name.append(genericTypeSignature.substring(arrayDimension + 1, parameterStart).replace('/', '.'));
+            }
+            try {
+                String sig = Signature.toString(genericTypeSignature)
+                        .substring(Math.max(parameterStart - 1, 0) - arrayDimension);
+                name.append(sig.replace('/', '.'));
+            } catch (IllegalArgumentException iae) {
+                // do nothing
+                name.append(genericTypeSignature);
+            }
+        }
+        for (int i = 0; i < arrayDimension; i++) {
+            name.append("[]"); //$NON-NLS-1$
+        }
+        return name.toString();
+    }
+
+    /**
+     * Check whether two resources point to the same physical file.
+     */
+    public static boolean isSameFile(IResource resource1, IResource resource2) {
+        if (resource1 == null || resource2 == null) {
+            return false;
+        }
+
+        if (Objects.equals(resource1, resource2)) {
+            return true;
+        }
+
+        return Objects.equals(resource1.getLocation(), resource2.getLocation());
+    }
+
+    /**
+     * Check if the project is managed by Gradle Build Server.
+     */
+    public static boolean isBspProject(IProject project) {
+        return project != null && ProjectUtils.isJavaProject(project)
+            && ProjectUtils.hasNature(project, "com.microsoft.gradle.bs.importer.GradleBuildServerProjectNature");
+    }
+
+    /**
+     * Get main project according to the main project name or main class name,
+     * or return <code>null</code> if the main project cannot be resolved.
+     */
+    public static IProject getMainProject(String mainProjectName, String mainClassName) {
+        IProject mainProject = null;
+        if (StringUtils.isNotBlank(mainProjectName)) {
+            mainProject = ProjectUtils.getProject(mainProjectName);
+        }
+
+        if (mainProject == null && StringUtils.isNotBlank(mainClassName)) {
+            try {
+                List<IJavaProject> javaProjects = ResolveClasspathsHandler.getJavaProjectFromType(mainClassName);
+                if (javaProjects.size() == 1) {
+                    mainProject = javaProjects.get(0).getProject();
+                }
+            } catch (CoreException e) {
+                JavaLanguageServerPlugin.logException("Failed to resolve project from main class name.", e);
+            }
+        }
+
+        return mainProject;
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtVirtualMachineManagerProvider.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtVirtualMachineManagerProvider.java
index 1739bc8ed..822251b5c 100644
--- a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtVirtualMachineManagerProvider.java
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/JdtVirtualMachineManagerProvider.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2017 Microsoft Corporation and others.
+ * Copyright (c) 2017-2020 Microsoft Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -11,21 +11,18 @@
 
 package com.microsoft.java.debug.plugin.internal;
 
-import java.util.Map;
-
-import org.eclipse.jdi.Bootstrap;
-
+import com.microsoft.java.debug.core.adapter.IVirtualMachineManager;
 import com.microsoft.java.debug.core.adapter.IVirtualMachineManagerProvider;
 import com.sun.jdi.VirtualMachineManager;
 
 public class JdtVirtualMachineManagerProvider implements IVirtualMachineManagerProvider {
+    private static IVirtualMachineManager vmManager = null;
 
     @Override
-    public VirtualMachineManager getVirtualMachineManager() {
-        return Bootstrap.virtualMachineManager();
-    }
-
-    @Override
-    public void initialize(Map<String, Object> props) {
+    public synchronized VirtualMachineManager getVirtualMachineManager() {
+        if (vmManager == null) {
+            vmManager = new AdvancedVirtualMachineManager();
+        }
+        return vmManager;
     }
 }
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/LaunchCommandHandler.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/LaunchCommandHandler.java
new file mode 100644
index 000000000..0c2b9c0ea
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/LaunchCommandHandler.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.nio.charset.StandardCharsets;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.microsoft.java.debug.core.adapter.handler.LaunchRequestHandler;
+import com.microsoft.java.debug.core.protocol.Requests.CONSOLE;
+import com.microsoft.java.debug.core.protocol.Requests.LaunchArguments;
+
+public class LaunchCommandHandler {
+
+    /**
+     * Get the approximate command line length based on the launch arguments.
+     * @param launchArguments - the launch arguments
+     * @return the approximate command line length
+     */
+    public static int getLaunchCommandLength(LaunchArguments launchArguments) {
+        String encoding = StringUtils.isBlank(launchArguments.encoding) ? StandardCharsets.UTF_8.name() : launchArguments.encoding;
+        launchArguments.vmArgs += String.format(" -Dfile.encoding=%s", encoding);
+        String address = launchArguments.noDebug ? "" : "888888";
+        String[] commands = LaunchRequestHandler.constructLaunchCommands(launchArguments, false, address);
+        int cwdLength = launchArguments.console == CONSOLE.internalConsole ? 0 : StringUtils.length("cd " + launchArguments.cwd + " && ");
+        return cwdLength + String.join(" ", commands).length();
+    }
+
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/LogUtils.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/LogUtils.java
index ad3d230dc..e4befd735 100644
--- a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/LogUtils.java
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/LogUtils.java
@@ -11,19 +11,16 @@
 
 package com.microsoft.java.debug.plugin.internal;
 
-import java.util.List;
+import java.util.logging.Handler;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
-import org.apache.commons.lang3.StringUtils;
-
 import com.microsoft.java.debug.core.Configuration;
 
 public final class LogUtils {
     private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
     private static final Logger usageDataLogger = Logger.getLogger(Configuration.USAGE_DATA_LOGGER_NAME);
 
-
     /**
      * Initialize logger for logger level and logger handler.
      * @param level the logger level for java debugger.
@@ -35,24 +32,39 @@ public static void initialize(Level level) {
         logger.setLevel(level);
     }
 
+    /**
+     * Remove the logger handlers registered to the global logger.
+     */
+    public static void cleanupHandlers() {
+        Handler[] handlers = logger.getHandlers();
+        for (Handler handler : handlers) {
+            logger.removeHandler(handler);
+        }
+
+        Handler[] usageHandlers = usageDataLogger.getHandlers();
+        for (Handler handler : usageHandlers) {
+            usageDataLogger.removeHandler(handler);
+        }
+    }
+
     /**
      * Configure log level setting for java debugger.
-     * @param arguments the first element of the arguments should be the String representation of level(info, fine, warning..).
+     *
+     * @param logLevel
+     *            the String representation of level(info, fine, warning..).
+     * @return the updated log level
      */
-    public static Object configLogLevel(List<Object> arguments) {
-        if (arguments != null && arguments.size() == 1 && arguments.get(0) instanceof String) {
-            try {
-                logger.setLevel(Level.parse((String) arguments.get(0)));
-                logger.info(String.format("Set log level to : %s", arguments.get(0)));
-                return logger.getLevel().toString();
-            } catch (IllegalArgumentException e) {
-                logger.severe(String.format("Invalid log level: %s", arguments.get(0)));
-            }
-
-        } else {
-            logger.severe(String.format("Invalid parameters for configLogLevel: %s", StringUtils.join(arguments)));
+    public static String configLogLevel(Object logLevel) {
+        try {
+            logger.setLevel(Level.parse((String) logLevel));
+            logger.info(String.format("Set log level to : %s", logLevel));
+        } catch (IllegalArgumentException e) {
+            logger.severe(String.format("Invalid log level: %s", logLevel));
+        }  catch (ClassCastException e) {
+            logger.severe("logLevel should be a string.");
         }
-        return null;
+
+        return logger.getLevel().toString();
     }
 
 }
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/MethodInvocationLocator.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/MethodInvocationLocator.java
new file mode 100644
index 000000000..654cbb00b
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/MethodInvocationLocator.java
@@ -0,0 +1,232 @@
+/*******************************************************************************
+* Copyright (c) 2022 Microsoft Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     Gayan Perera (gayanper@gmail.com) - initial API and implementation
+*******************************************************************************/
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
+import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
+import org.eclipse.jdt.core.dom.AssertStatement;
+import org.eclipse.jdt.core.dom.BreakStatement;
+import org.eclipse.jdt.core.dom.ClassInstanceCreation;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.ConstructorInvocation;
+import org.eclipse.jdt.core.dom.ContinueStatement;
+import org.eclipse.jdt.core.dom.DoStatement;
+import org.eclipse.jdt.core.dom.EmptyStatement;
+import org.eclipse.jdt.core.dom.EnhancedForStatement;
+import org.eclipse.jdt.core.dom.EnumDeclaration;
+import org.eclipse.jdt.core.dom.ExpressionStatement;
+import org.eclipse.jdt.core.dom.FieldDeclaration;
+import org.eclipse.jdt.core.dom.ForStatement;
+import org.eclipse.jdt.core.dom.IMethodBinding;
+import org.eclipse.jdt.core.dom.IfStatement;
+import org.eclipse.jdt.core.dom.LabeledStatement;
+import org.eclipse.jdt.core.dom.MethodDeclaration;
+import org.eclipse.jdt.core.dom.MethodInvocation;
+import org.eclipse.jdt.core.dom.ReturnStatement;
+import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
+import org.eclipse.jdt.core.dom.SwitchStatement;
+import org.eclipse.jdt.core.dom.SynchronizedStatement;
+import org.eclipse.jdt.core.dom.ThrowStatement;
+import org.eclipse.jdt.core.dom.TryStatement;
+import org.eclipse.jdt.core.dom.TypeDeclaration;
+import org.eclipse.jdt.core.dom.TypeDeclarationStatement;
+import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
+import org.eclipse.jdt.core.dom.WhileStatement;
+import org.eclipse.jdt.core.dom.YieldStatement;
+
+public class MethodInvocationLocator extends ASTVisitor {
+    private int line;
+    private CompilationUnit unit;
+    private Map<ASTNode, IMethodBinding> targets;
+
+    public MethodInvocationLocator(int line, CompilationUnit unit) {
+        super(false);
+        this.line = line;
+        this.unit = unit;
+        this.targets = new HashMap<>();
+    }
+
+    @Override
+    public boolean visit(FieldDeclaration node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(MethodDeclaration node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(TypeDeclaration node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(AnonymousClassDeclaration node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(EnumDeclaration node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(AnnotationTypeDeclaration node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(VariableDeclarationStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(ExpressionStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(AssertStatement node) {
+        return shouldVisitNode(node);
+
+    }
+
+    @Override
+    public boolean visit(BreakStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(ContinueStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(DoStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(EmptyStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(EnhancedForStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(ForStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(IfStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(LabeledStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(ReturnStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(SwitchStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(SynchronizedStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(ThrowStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(TryStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(TypeDeclarationStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(WhileStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(YieldStatement node) {
+        return shouldVisitNode(node);
+    }
+
+    @Override
+    public boolean visit(ConstructorInvocation node) {
+        if (shouldVisitNode(node)) {
+            targets.put(node, node.resolveConstructorBinding());
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean visit(SuperConstructorInvocation node) {
+        if (shouldVisitNode(node)) {
+            targets.put(node, node.resolveConstructorBinding());
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean visit(MethodInvocation node) {
+        targets.put(node, node.resolveMethodBinding());
+        return true;
+    }
+
+    @Override
+    public boolean visit(ClassInstanceCreation node) {
+        targets.put(node, node.resolveConstructorBinding());
+        return true;
+    }
+
+    private boolean shouldVisitNode(ASTNode node) {
+        int start = unit.getLineNumber(node.getStartPosition());
+        int end = unit.getLineNumber(node.getStartPosition() + node.getLength() - 1);
+
+        if (line >= start && line <= end) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public Map<ASTNode, IMethodBinding> getTargets() {
+        return targets;
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/PlatformSettings.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/PlatformSettings.java
new file mode 100644
index 000000000..9c2764d6a
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/PlatformSettings.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2020 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.jdt.core.JavaCore;
+
+public class PlatformSettings {
+
+    /**
+     * Resolve the JDT platform settings.
+     */
+    public static Map<String, String> getPlatformSettings() {
+        Map<String, String> result = new HashMap<>();
+        result.put("latestSupportedJavaVersion", JavaCore.latestSupportedJavaVersion());
+        return result;
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ProjectSettingsChecker.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ProjectSettingsChecker.java
new file mode 100644
index 000000000..db2b783d9
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ProjectSettingsChecker.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jdt.core.IJavaProject;
+
+public class ProjectSettingsChecker {
+    /**
+     * Check whether the project settings are all matched as the expected.
+     * @param params - The checker parameters
+     * @return true if all settings is matched
+     */
+    public static boolean check(ProjectSettingsCheckerParams params) {
+        Map<String, String> options = new HashMap<>();
+        IJavaProject javaProject = null;
+        if (StringUtils.isNotBlank(params.projectName)) {
+            javaProject = JdtUtils.getJavaProject(params.projectName);
+        } else if (StringUtils.isNotBlank(params.className)) {
+            try {
+                List<IJavaProject> projects = ResolveClasspathsHandler.getJavaProjectFromType(params.className);
+                if (!projects.isEmpty()) {
+                    javaProject = projects.get(0);
+                }
+            } catch (CoreException e) {
+                // do nothing
+            }
+        }
+
+        if (javaProject != null) {
+            options = javaProject.getOptions(params.inheritedOptions);
+        }
+
+        for (Entry<String, String> expected : params.expectedOptions.entrySet()) {
+            if (!Objects.equals(options.get(expected.getKey()), expected.getValue())) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static class ProjectSettingsCheckerParams {
+        String className;
+        String projectName;
+        boolean inheritedOptions;
+        Map<String, String> expectedOptions;
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveClasspathsHandler.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveClasspathsHandler.java
index 0b93910ea..5e7017128 100644
--- a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveClasspathsHandler.java
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveClasspathsHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2017 Microsoft Corporation and others.
+ * Copyright (c) 2017-2019 Microsoft Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -11,20 +11,36 @@
 
 package com.microsoft.java.debug.plugin.internal;
 
+import java.io.IOException;
+import java.io.StringReader;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.stream.Collectors;
 
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.apache.commons.lang3.StringUtils;
 import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.internal.core.LaunchConfiguration;
+import org.eclipse.debug.internal.core.LaunchConfigurationInfo;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.search.IJavaSearchConstants;
 import org.eclipse.jdt.core.search.IJavaSearchScope;
 import org.eclipse.jdt.core.search.SearchEngine;
@@ -32,7 +48,14 @@
 import org.eclipse.jdt.core.search.SearchParticipant;
 import org.eclipse.jdt.core.search.SearchPattern;
 import org.eclipse.jdt.core.search.SearchRequestor;
+import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
+import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
 import org.eclipse.jdt.launching.JavaRuntime;
+import org.eclipse.jdt.ls.core.internal.ProjectUtils;
+import org.w3c.dom.Element;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;
 
 import com.microsoft.java.debug.core.Configuration;
 
@@ -45,8 +68,11 @@ public class ResolveClasspathsHandler {
      * @return the class paths entries
      * @throws Exception when there are any errors during resolving class path
      */
-    public String[] resolveClasspaths(List<Object> arguments) throws Exception {
+    public String[][] resolveClasspaths(List<Object> arguments) throws Exception {
         try {
+            if (arguments.size() == 3) {
+                return computeClassPath((String) arguments.get(0), (String) arguments.get(1), (String) arguments.get(2));
+            }
             return computeClassPath((String) arguments.get(0), (String) arguments.get(1));
         } catch (CoreException e) {
             logger.log(Level.SEVERE, "Failed to resolve classpath: " + e.getMessage(), e);
@@ -64,40 +90,55 @@ public String[] resolveClasspaths(List<Object> arguments) throws Exception {
      *             CoreException
      */
     private static IJavaProject getJavaProjectFromName(String projectName) throws CoreException {
-        IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
-        IProject project = root.getProject(projectName);
-        if (!project.exists()) {
-            throw new CoreException(new Status(IStatus.ERROR, JavaDebuggerServerPlugin.PLUGIN_ID,
-                    String.format("Cannot find the project with name '%s'.", projectName)));
-        }
-        if (!project.isNatureEnabled("org.eclipse.jdt.core.javanature")) {
+        IJavaProject javaProject = JdtUtils.getJavaProject(projectName);
+        if (javaProject == null) {
             throw new CoreException(new Status(IStatus.ERROR, JavaDebuggerServerPlugin.PLUGIN_ID,
-                    String.format("The project '%s' does not have java nature enabled.", projectName)));
+                    String.format("The project '%s' is not a valid java project.", projectName)));
         }
-        IJavaProject javaProject = JavaCore.create(project);
         return javaProject;
     }
 
     /**
      * Get java project from type.
      *
-     * @param typeFullyQualifiedName
+     * @param fullyQualifiedTypeName
      *            fully qualified name of type
      * @return java project
      * @throws CoreException
      *             CoreException
      */
-    private static List<IJavaProject> getJavaProjectFromType(String typeFullyQualifiedName) throws CoreException {
-        SearchPattern pattern = SearchPattern.createPattern(typeFullyQualifiedName, IJavaSearchConstants.TYPE,
-                IJavaSearchConstants.DECLARATIONS, SearchPattern.R_EXACT_MATCH);
+    public static List<IJavaProject> getJavaProjectFromType(String fullyQualifiedTypeName) throws CoreException {
+        // If only one Java project exists in the whole workspace, return the project directly.
+        List<IJavaProject> javaProjects = JdtUtils.listJavaProjects(ResourcesPlugin.getWorkspace().getRoot());
+        if (javaProjects.size() <= 1) {
+            return javaProjects;
+        }
+
+        String[] splitItems = fullyQualifiedTypeName.split("/");
+        // If the main class name contains the module name, should trim the module info.
+        if (splitItems.length == 2) {
+            fullyQualifiedTypeName = splitItems[1];
+        }
+        final String moduleName = splitItems.length == 2 ? splitItems[0] : null;
+        final String className = fullyQualifiedTypeName;
+        SearchPattern pattern = SearchPattern.createPattern(
+                fullyQualifiedTypeName,
+                IJavaSearchConstants.TYPE,
+                IJavaSearchConstants.DECLARATIONS,
+                SearchPattern.R_EXACT_MATCH);
         IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
         ArrayList<IJavaProject> projects = new ArrayList<>();
         SearchRequestor requestor = new SearchRequestor() {
             @Override
             public void acceptSearchMatch(SearchMatch match) {
                 Object element = match.getElement();
-                if (element instanceof IJavaElement) {
-                    projects.add(((IJavaElement) element).getJavaProject());
+                if (element instanceof IType) {
+                    IType type = (IType) element;
+                    IJavaProject project = type.getJavaProject();
+                    if (className.equals(type.getFullyQualifiedName())
+                            && (moduleName == null || moduleName.equals(JdtUtils.getModuleName(project)))) {
+                        projects.add(project);
+                    }
                 }
             }
         };
@@ -106,7 +147,22 @@ public void acceptSearchMatch(SearchMatch match) {
             SearchEngine.getDefaultSearchParticipant() }, scope,
             requestor, null /* progress monitor */);
 
-        return projects;
+        return projects.stream().distinct().collect(Collectors.toList());
+    }
+
+    /**
+     * Accord to the project name and the main class, compute runtime classpath.
+     *
+     * @param mainClass
+     *            fully qualified class name
+     * @param projectName
+     *            project name
+     * @return class path
+     * @throws CoreException
+     *             CoreException
+     */
+    private static String[][] computeClassPath(String mainClass, String projectName) throws CoreException {
+        return computeClassPath(mainClass, projectName, null);
     }
 
     /**
@@ -116,15 +172,17 @@ public void acceptSearchMatch(SearchMatch match) {
      *            fully qualified class name
      * @param projectName
      *            project name
+     * @param scope
+     *            scope of the classpath
      * @return class path
      * @throws CoreException
      *             CoreException
      */
-    private static String[] computeClassPath(String mainClass, String projectName) throws CoreException {
+    private static String[][] computeClassPath(String mainClass, String projectName, String scope) throws CoreException {
         IJavaProject project = null;
         // if type exists in multiple projects, debug configuration need provide
         // project name.
-        if (projectName != null) {
+        if (StringUtils.isNotBlank(projectName)) {
             project = getJavaProjectFromName(projectName);
         } else {
             List<IJavaProject> projects = getJavaProjectFromType(mainClass);
@@ -140,22 +198,198 @@ private static String[] computeClassPath(String mainClass, String projectName) t
             }
             project = projects.get(0);
         }
-        return computeClassPath(project);
+
+        if ("test".equals(scope)) {
+            return computeClassPath(project, mainClass, false /*excludeTestCode*/, Collections.EMPTY_LIST);
+        } else if ("runtime".equals(scope)) {
+            return computeClassPath(project, mainClass, true /*excludeTestCode*/, Collections.EMPTY_LIST);
+        }
+
+        IJavaElement testElement = findMainClassInTestFolders(project, mainClass);
+        List<IResource> mappedResources = (testElement != null && testElement.getResource() != null)
+                ? Arrays.asList(testElement.getResource()) : Collections.EMPTY_LIST;
+        return computeClassPath(project, mainClass, testElement == null, mappedResources);
     }
 
     /**
      * Compute runtime classpath of a java project.
      *
-     * @param javaProject
-     *            java project
+     * @param javaProject java project
+     * @param excludeTestCode whether to exclude the test code and test dependencies
+     * @param mappedResources the associated resources with the application
      * @return class path
      * @throws CoreException
      *             CoreException
      */
-    private static String[] computeClassPath(IJavaProject javaProject) throws CoreException {
+    private static String[][] computeClassPath(IJavaProject javaProject, String mainType, boolean excludeTestCode, List<IResource> mappedResources)
+            throws CoreException {
         if (javaProject == null) {
             throw new IllegalArgumentException("javaProject is null");
         }
-        return JavaRuntime.computeDefaultRuntimeClassPath(javaProject);
+
+        ILaunchConfiguration launchConfig = new JavaApplicationLaunchConfiguration(javaProject.getProject(), mainType, excludeTestCode, mappedResources);
+        IRuntimeClasspathEntry[] unresolved = JavaRuntime.computeUnresolvedRuntimeClasspath(launchConfig);
+        IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspath(unresolved, launchConfig);
+        Set<String> classpaths = new LinkedHashSet<>();
+        Set<String> modulepaths = new LinkedHashSet<>();
+        for (IRuntimeClasspathEntry entry : resolved) {
+            String location = entry.getLocation();
+            if (location != null) {
+                if (entry.getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES
+                        || entry.getClasspathProperty() == IRuntimeClasspathEntry.CLASS_PATH) {
+                    classpaths.add(location);
+                } else if (entry.getClasspathProperty() == IRuntimeClasspathEntry.MODULE_PATH) {
+                    modulepaths.add(location);
+                }
+            }
+        }
+
+        return new String[][] {
+            modulepaths.toArray(new String[modulepaths.size()]),
+            classpaths.toArray(new String[classpaths.size()])
+        };
+    }
+
+    /**
+     * Try to find the associated java element with the main class from the test folders.
+     *
+     * @param project the java project containing the main class
+     * @param mainClass the main class name
+     * @return the associated java element
+     */
+    private static IJavaElement findMainClassInTestFolders(IJavaProject project, String mainClass) {
+        if (project == null || StringUtils.isBlank(mainClass)) {
+            return null;
+        }
+
+        // get a list of test folders and check whether main class is here
+        int constraints = IJavaSearchScope.SOURCES;
+        IJavaElement[] testFolders = JdtUtils.getTestPackageFragmentRoots(project);
+        if (testFolders.length > 0) {
+            try {
+
+                List<IJavaElement> mainClassesInTestFolder = new ArrayList<>();
+                SearchPattern pattern = SearchPattern.createPattern(mainClass, IJavaSearchConstants.CLASS,
+                        IJavaSearchConstants.DECLARATIONS,
+                        SearchPattern.R_CASE_SENSITIVE | SearchPattern.R_EXACT_MATCH);
+                SearchEngine searchEngine = new SearchEngine();
+                IJavaSearchScope scope = SearchEngine.createJavaSearchScope(testFolders, constraints);
+                SearchRequestor requestor = new SearchRequestor() {
+                    @Override
+                    public void acceptSearchMatch(SearchMatch match) {
+                        Object element = match.getElement();
+                        if (element instanceof IJavaElement) {
+                            mainClassesInTestFolder.add((IJavaElement) element);
+                        }
+                    }
+                };
+
+                searchEngine.search(pattern, new SearchParticipant[] {
+                            SearchEngine.getDefaultSearchParticipant()
+                    }, scope, requestor, null /* progress monitor */);
+
+                if (!mainClassesInTestFolder.isEmpty()) {
+                    return mainClassesInTestFolder.get(0);
+                }
+            } catch (Exception e) {
+                logger.log(Level.SEVERE, String.format("Searching the main class failure: %s", e.toString()), e);
+            }
+        }
+
+        return null;
+    }
+
+    private static class JavaApplicationLaunchConfiguration extends LaunchConfiguration {
+        public static final String JAVA_APPLICATION_LAUNCH = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
+                + "<launchConfiguration type=\"%s\">\n"
+                + "<listAttribute key=\"org.eclipse.debug.core.MAPPED_RESOURCE_PATHS\">\n"
+                + "</listAttribute>\n"
+                + "<listAttribute key=\"org.eclipse.debug.core.MAPPED_RESOURCE_TYPES\">\n"
+                + "</listAttribute>\n"
+                + "</launchConfiguration>";
+        private IProject project;
+        private String mainType;
+        private boolean excludeTestCode;
+        private List<IResource> mappedResources;
+        private String classpathProvider;
+        private String sourcepathProvider;
+        private LaunchConfigurationInfo launchInfo;
+
+        protected JavaApplicationLaunchConfiguration(IProject project, String mainType, boolean excludeTestCode, List<IResource> mappedResources)
+            throws CoreException {
+            super(String.valueOf(new Date().getTime()), null, false);
+            this.project = project;
+            this.mainType = mainType;
+            this.excludeTestCode = excludeTestCode;
+            this.mappedResources = mappedResources;
+            if (ProjectUtils.isMavenProject(project)) {
+                classpathProvider = "org.eclipse.m2e.launchconfig.classpathProvider";
+                sourcepathProvider = "org.eclipse.m2e.launchconfig.sourcepathProvider";
+            } else if (ProjectUtils.isGradleProject(project)) {
+                classpathProvider = "org.eclipse.buildship.core.classpathprovider";
+            }
+
+            // Since MavenRuntimeClasspathProvider will only including test entries when:
+            // 1. Launch configuration is JUnit/TestNG type
+            // 2. Mapped resource is in test path.
+            // That's why we use JUnit launch configuration here to make sure the result is right when excludeTestCode is false.
+            String launchXml = null;
+            if (!excludeTestCode && mappedResources.isEmpty()) {
+                launchXml = String.format(JAVA_APPLICATION_LAUNCH, "org.eclipse.jdt.junit.launchconfig");
+            } else {
+                launchXml = String.format(JAVA_APPLICATION_LAUNCH, "org.eclipse.jdt.launching.localJavaApplication");
+            }
+            this.launchInfo = new JavaLaunchConfigurationInfo(launchXml);
+        }
+
+        @Override
+        public boolean getAttribute(String attributeName, boolean defaultValue) throws CoreException {
+            if (IJavaLaunchConfigurationConstants.ATTR_EXCLUDE_TEST_CODE.equalsIgnoreCase(attributeName)) {
+                return excludeTestCode;
+            }
+
+            return super.getAttribute(attributeName, defaultValue);
+        }
+
+        @Override
+        public String getAttribute(String attributeName, String defaultValue) throws CoreException {
+            if (IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME.equalsIgnoreCase(attributeName)) {
+                return project.getName();
+            } else if (IJavaLaunchConfigurationConstants.ATTR_CLASSPATH_PROVIDER.equalsIgnoreCase(attributeName)) {
+                return classpathProvider;
+            } else if (IJavaLaunchConfigurationConstants.ATTR_SOURCE_PATH_PROVIDER.equalsIgnoreCase(attributeName)) {
+                return sourcepathProvider;
+            } else if (IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME.equalsIgnoreCase(attributeName)) {
+                return mainType;
+            }
+
+            return super.getAttribute(attributeName, defaultValue);
+        }
+
+        @Override
+        public IResource[] getMappedResources() throws CoreException {
+            return mappedResources.toArray(new IResource[0]);
+        }
+
+        @Override
+        protected LaunchConfigurationInfo getInfo() throws CoreException {
+            return this.launchInfo;
+        }
+    }
+
+    private static class JavaLaunchConfigurationInfo extends LaunchConfigurationInfo {
+        public JavaLaunchConfigurationInfo(String launchXml) {
+            super();
+            try {
+                DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+                parser.setErrorHandler(new DefaultHandler());
+                StringReader reader = new StringReader(launchXml);
+                InputSource source = new InputSource(reader);
+                Element root = parser.parse(source).getDocumentElement();
+                initializeFromXML(root);
+            } catch (ParserConfigurationException | SAXException | IOException | CoreException e) {
+                // do nothing
+            }
+        }
     }
 }
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveElementHandler.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveElementHandler.java
new file mode 100644
index 000000000..2240a2689
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveElementHandler.java
@@ -0,0 +1,73 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.ls.core.internal.JDTUtils;
+import org.eclipse.jdt.ls.core.internal.JavaLanguageServerPlugin;
+
+import com.microsoft.java.debug.core.DebugException;
+
+public class ResolveElementHandler {
+
+    /**
+     * Resolve the Java element at the selected position.
+     * @return the resolved Java element information.
+     */
+    public static Object resolveElementAtSelection(List<Object> arguments, IProgressMonitor monitor) throws DebugException {
+        if (arguments == null || arguments.size() < 3) {
+            return Collections.emptyList();
+        }
+
+        String uri = (String) arguments.get(0);
+        int line = (int) Math.round((double) arguments.get(1));
+        int column = (int) Math.round((double) arguments.get(2));
+        final ICompilationUnit unit = JDTUtils.resolveCompilationUnit(uri);
+        try {
+            IJavaElement element = JDTUtils.findElementAtSelection(unit, line, column,
+                    JavaLanguageServerPlugin.getPreferencesManager(), monitor);
+            if (element instanceof IMethod) {
+                return new JavaElement(((IMethod) element).getDeclaringType().getFullyQualifiedName(),
+                    element.getJavaProject().getProject().getName(),
+                    ((IMethod) element).isMainMethod());
+            } else if (element instanceof IType) {
+                return new JavaElement(((IType) element).getFullyQualifiedName(),
+                    element.getJavaProject().getProject().getName(),
+                    ResolveMainMethodHandler.getMainMethod((IType) element) != null);
+            }
+        } catch (JavaModelException e) {
+            throw new DebugException("Failed to resolve the selected element information: " + e.getMessage(), e);
+        }
+
+        return null;
+    }
+
+    static class JavaElement {
+        private String declaringType;
+        private String projectName;
+        private boolean hasMainMethod;
+
+        public JavaElement(String declaringType, String projectName, boolean hasMainMethod) {
+            this.declaringType = declaringType;
+            this.projectName = projectName;
+            this.hasMainMethod = hasMainMethod;
+        }
+    }
+}
\ No newline at end of file
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveJavaExecutableHandler.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveJavaExecutableHandler.java
new file mode 100644
index 000000000..362532e4f
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveJavaExecutableHandler.java
@@ -0,0 +1,109 @@
+/*******************************************************************************
+ * Copyright (c) 2020 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.io.File;
+import java.util.List;
+import java.util.Objects;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.launching.IVMInstall;
+import org.eclipse.jdt.launching.JavaRuntime;
+
+import com.microsoft.java.debug.core.Configuration;
+
+public class ResolveJavaExecutableHandler {
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    private static final String[] javaExecCandidates = {
+        "java",
+        "java.exe",
+        "javaw",
+        "javaw.exe",
+        "j9",
+        "j9.exe",
+        "j9w",
+        "j9w.exe"
+    };
+    private static final String[] javaBinCandidates = {
+        File.separator,
+        "bin" + File.separatorChar,
+        "jre" + File.separatorChar + "bin" + File.separatorChar
+    };
+
+    /**
+     * Resolve the java executable path from the project's java runtime.
+     */
+    public static String resolveJavaExecutable(List<Object> arguments) throws Exception {
+        try {
+            String mainClass = (String) arguments.get(0);
+            String projectName = (String) arguments.get(1);
+            IJavaProject targetProject = null;
+            if (StringUtils.isNotBlank(projectName)) {
+                targetProject = JdtUtils.getJavaProject(projectName);
+            } else {
+                List<IJavaProject> targetProjects = ResolveClasspathsHandler.getJavaProjectFromType(mainClass);
+                if (!targetProjects.isEmpty()) {
+                    targetProject = targetProjects.get(0);
+                }
+            }
+
+            return resolveJavaExecutable(targetProject);
+        } catch (CoreException e) {
+            logger.log(Level.SEVERE, "Failed to resolve java executable: " + e.getMessage(), e);
+        }
+
+        return null;
+    }
+
+    /**
+     * Resolve the Java executable path from the project's Java runtime.
+     */
+    public static String resolveJavaExecutable(IJavaProject javaProject) throws CoreException {
+        if (javaProject == null) {
+            return null;
+        }
+
+        IVMInstall vmInstall = JavaRuntime.getVMInstall(javaProject);
+        if (vmInstall == null || vmInstall.getInstallLocation() == null) {
+            return null;
+        }
+
+        File exe = findJavaExecutable(vmInstall.getInstallLocation());
+        if (exe == null) {
+            return null;
+        }
+
+        return exe.getAbsolutePath();
+    }
+
+    private static File findJavaExecutable(File vmInstallLocation) {
+        boolean isBin = Objects.equals("bin", vmInstallLocation.getName());
+        for (int i = 0; i < javaExecCandidates.length; i++) {
+            for (int j = 0; j < javaBinCandidates.length; j++) {
+                if (!isBin && j == 0) {
+                    continue;
+                }
+
+                File javaFile = new File(vmInstallLocation, javaBinCandidates[j] + javaExecCandidates[i]);
+                if (javaFile.isFile()) {
+                    return javaFile;
+                }
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveMainClassHandler.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveMainClassHandler.java
new file mode 100644
index 000000000..af9cdbc57
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveMainClassHandler.java
@@ -0,0 +1,444 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2022 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.lang.model.SourceVersion;
+
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.search.IJavaSearchConstants;
+import org.eclipse.jdt.core.search.IJavaSearchScope;
+import org.eclipse.jdt.core.search.SearchEngine;
+import org.eclipse.jdt.core.search.SearchMatch;
+import org.eclipse.jdt.core.search.SearchParticipant;
+import org.eclipse.jdt.core.search.SearchPattern;
+import org.eclipse.jdt.core.search.SearchRequestor;
+import org.eclipse.jdt.internal.core.SourceMethod;
+import org.eclipse.jdt.ls.core.internal.ProjectUtils;
+import org.eclipse.jdt.ls.core.internal.ResourceUtils;
+import org.eclipse.jdt.ls.core.internal.managers.ProjectsManager;
+
+import com.microsoft.java.debug.core.Configuration;
+
+public class ResolveMainClassHandler {
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    private static final int CONFIGERROR_INVALID_CLASS_NAME = 1;
+    private static final int CONFIGERROR_MAIN_CLASS_NOT_EXIST = 2;
+    private static final int CONFIGERROR_MAIN_CLASS_NOT_UNIQUE = 3;
+    private static final int CONFIGERROR_INVALID_JAVA_PROJECT = 4;
+
+    /**
+     * resolve main class and project name.
+     * @return an array of main class and project name
+     */
+    public Object resolveMainClass(List<Object> arguments) {
+        return resolveMainClassCore(arguments);
+    }
+
+    /**
+     * Validate whether the mainClass and projectName is correctly configured or not. If not, report the validation error and provide the quick fix proposal.
+     *
+     * @param arguments the mainClass and projectName configs.
+     * @return the validation response.
+     * @throws Exception when there are any errors during validating the mainClass and projectName.
+     */
+    public Object validateLaunchConfig(List<Object> arguments) throws Exception {
+        try {
+            return validateLaunchConfigCore(arguments);
+        } catch (CoreException ex) {
+            logger.log(Level.SEVERE, "Failed to validate launch config: " + ex.getMessage(), ex);
+            throw new Exception("Failed to validate launch config: " + ex.getMessage(), ex);
+        }
+    }
+
+    private List<ResolutionItem> resolveMainClassCore(List<Object> arguments) {
+        if (arguments != null && arguments.size() > 0 && arguments.get(0) != null) {
+            String argument = (String) arguments.get(0);
+            IProject[] projects = ProjectUtils.getAllProjects();
+            if (Stream.of(projects).anyMatch(project -> Objects.equals(project.getName(), argument))) {
+                return resolveMainClassUnderProject(argument);
+            }
+
+            IPath rootPath = ResourceUtils.filePathFromURI(argument);
+            if (rootPath != null) {
+                return resolveMainClassUnderPaths(Arrays.asList(rootPath));
+            }
+        }
+
+        return resolveMainClassUnderPaths(Collections.emptyList());
+    }
+
+    private List<ResolutionItem> resolveMainClassUnderPaths(List<IPath> parentPaths) {
+        // Limit to search main method from source code only.
+        IJavaProject[] projects;
+        if (parentPaths == null || parentPaths.isEmpty()) {
+            projects = ProjectUtils.getJavaProjects();
+        } else {
+            projects = Stream.of(ProjectUtils.getAllProjects())
+                .filter(p -> ProjectUtils.isJavaProject(p)  && p.getLocation() != null && ResourceUtils.isContainedIn(p.getLocation(), parentPaths))
+                .map(p -> JavaCore.create(p))
+                .filter(p -> p.exists())
+                .toArray(IJavaProject[]::new);
+        }
+        IJavaSearchScope searchScope = SearchEngine.createJavaSearchScope(projects,
+            IJavaSearchScope.SOURCES);
+        SearchPattern pattern = createMainMethodSearchPattern();
+        final List<ResolutionItem> res = new ArrayList<>();
+        SearchRequestor requestor = new SearchRequestor() {
+            @Override
+            public void acceptSearchMatch(SearchMatch match) {
+                Object element = match.getElement();
+                if (element instanceof IMethod) {
+                    IMethod method = (IMethod) element;
+                    if (isMainMethod(method)) {
+                        IResource resource = method.getResource();
+                        if (resource != null) {
+                            IProject project = resource.getProject();
+                            if (project != null) {
+                                String mainClass = method.getDeclaringType().getFullyQualifiedName();
+                                IJavaProject javaProject = JdtUtils.getJavaProject(project);
+                                if (javaProject != null) {
+                                    String moduleName = JdtUtils.getModuleName(javaProject);
+                                    if (moduleName != null) {
+                                        mainClass = moduleName + "/" + mainClass;
+                                    }
+                                }
+                                String projectName = ProjectsManager.DEFAULT_PROJECT_NAME.equals(project.getName()) ? null : project.getName();
+                                if (parentPaths.isEmpty()
+                                    || ResourceUtils.isContainedIn(project.getLocation(), parentPaths)
+                                    || isContainedInInvisibleProject(project, parentPaths)) {
+                                    String filePath = null;
+
+                                    if (match.getResource() instanceof IFile) {
+                                        try {
+                                            filePath = match.getResource().getLocation().toOSString();
+                                        } catch (Exception ex) {
+                                            // ignore
+                                        }
+                                    }
+                                    res.add(new ResolutionItem(mainClass, projectName, filePath));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        SearchEngine searchEngine = new SearchEngine();
+        try {
+            searchEngine.search(pattern, new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
+                    searchScope, requestor, null /* progress monitor */);
+        } catch (Exception e) {
+            logger.log(Level.SEVERE, String.format("Searching the main class failure: %s", e.toString()), e);
+        }
+
+        List<ResolutionItem> resolutions = res.stream().distinct().collect(Collectors.toList());
+        Collections.sort(resolutions);
+        return resolutions;
+    }
+
+    private List<ResolutionItem> resolveMainClassUnderProject(final String projectName) {
+        // Limit to search main method from source code only.
+        IJavaProject javaProject = ProjectUtils.getJavaProject(projectName);
+        IJavaSearchScope searchScope = SearchEngine.createJavaSearchScope(javaProject == null ? new IJavaProject[0] : new IJavaProject[] {javaProject},
+            IJavaSearchScope.REFERENCED_PROJECTS | IJavaSearchScope.SOURCES);
+        SearchPattern pattern = createMainMethodSearchPattern();
+        final List<ResolutionItem> res = new ArrayList<>();
+        SearchRequestor requestor = new SearchRequestor() {
+            @Override
+            public void acceptSearchMatch(SearchMatch match) {
+                Object element = match.getElement();
+                if (element instanceof IMethod) {
+                    IMethod method = (IMethod) element;
+                    if (isMainMethod(method)) {
+                        IResource resource = method.getResource();
+                        if (resource != null) {
+                            IProject project = resource.getProject();
+                            if (project != null) {
+                                String mainClass = method.getDeclaringType().getFullyQualifiedName();
+                                IJavaProject javaProject = JdtUtils.getJavaProject(project);
+                                if (javaProject != null) {
+                                    String moduleName = JdtUtils.getModuleName(javaProject);
+                                    if (moduleName != null) {
+                                        mainClass = moduleName + "/" + mainClass;
+                                    }
+                                }
+
+                                String filePath = null;
+                                if (match.getResource() instanceof IFile) {
+                                    try {
+                                        filePath = match.getResource().getLocation().toOSString();
+                                    } catch (Exception ex) {
+                                        // ignore
+                                    }
+                                }
+                                res.add(new ResolutionItem(mainClass, projectName, filePath));
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        SearchEngine searchEngine = new SearchEngine();
+        try {
+            searchEngine.search(pattern, new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
+                    searchScope, requestor, null /* progress monitor */);
+        } catch (Exception e) {
+            logger.log(Level.SEVERE, String.format("Searching the main class failure: %s", e.toString()), e);
+        }
+
+        List<ResolutionItem> resolutions = res.stream().distinct().collect(Collectors.toList());
+        Collections.sort(resolutions);
+        return resolutions;
+    }
+
+    private SearchPattern createMainMethodSearchPattern() {
+        SearchPattern pattern1 = SearchPattern.createPattern("main(String[]) void", IJavaSearchConstants.METHOD,
+                IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CASE_SENSITIVE | SearchPattern.R_EXACT_MATCH);
+        SearchPattern pattern2 = SearchPattern.createPattern("main() void", IJavaSearchConstants.METHOD,
+                IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CASE_SENSITIVE | SearchPattern.R_EXACT_MATCH);
+        return SearchPattern.createOrPattern(pattern1, pattern2);
+    }
+
+    private boolean isMainMethod(IMethod method) {
+        try {
+            if (method instanceof SourceMethod
+                    && ((SourceMethod) method).isMainMethodCandidate()) {
+                return true;
+            }
+
+            return method.isMainMethod();
+        } catch (JavaModelException e) {
+            // do nothing
+        } catch (NoSuchMethodError e) {
+            // isMainMethodCandidate() was added in JDT Core 3.36, fall back to isMainMethod()
+            try {
+                return method.isMainMethod();
+            } catch (JavaModelException ex) {
+                // do nothing
+            }
+        }
+
+        return false;
+    }
+
+    private boolean isContainedInInvisibleProject(IProject project, Collection<IPath> rootPaths) {
+        if (project == null) {
+            return false;
+        }
+
+        IFolder workspaceLinkFolder = project.getFolder(ProjectUtils.WORKSPACE_LINK);
+        return workspaceLinkFolder.exists() && ResourceUtils.isContainedIn(workspaceLinkFolder.getLocation(), rootPaths);
+    }
+
+    private ValidationResponse validateLaunchConfigCore(List<Object> arguments) throws CoreException {
+        ValidationResponse response = new ValidationResponse();
+
+        String mainClass = null;
+        String projectName = null;
+        boolean containsExternalClasspaths = false;
+        if (arguments != null) {
+            if (arguments.size() > 1) {
+                mainClass = (String) arguments.get(1);
+            }
+            if (arguments.size() > 2) {
+                projectName = (String) arguments.get(2);
+            }
+            if (arguments.size() > 3) {
+                containsExternalClasspaths = (boolean) arguments.get(3);
+            }
+        }
+
+        response.mainClass = validateMainClass(mainClass, projectName, containsExternalClasspaths);
+        response.projectName = validateProjectName(mainClass, projectName);
+
+        if (!response.mainClass.isValid || !response.projectName.isValid) {
+            response.proposals = computeProposals(arguments, mainClass, projectName);
+        }
+
+        return response;
+    }
+
+    private ValidationResult validateMainClass(final String mainClass, final String projectName, boolean containsExternalClasspaths) throws CoreException {
+        if (StringUtils.isEmpty(mainClass)) {
+            return new ValidationResult(true);
+        } else if (!isValidMainClassName(mainClass)) {
+            return new ValidationResult(false, String.format("ConfigError: '%s' is not a valid class name.", mainClass),
+                CONFIGERROR_INVALID_CLASS_NAME);
+        }
+
+        if (!containsExternalClasspaths && StringUtils.isEmpty(projectName)) {
+            List<IJavaProject> javaProjects = searchClassInProjectClasspaths(mainClass);
+            if (javaProjects.size() == 0) {
+                return new ValidationResult(false, String.format("ConfigError: Main class '%s' doesn't exist in the workspace.", mainClass),
+                    CONFIGERROR_MAIN_CLASS_NOT_EXIST);
+            }
+            if (javaProjects.size() > 1) {
+                return new ValidationResult(false, String.format("ConfigError: Main class '%s' isn't unique in the workspace.", mainClass),
+                    CONFIGERROR_MAIN_CLASS_NOT_UNIQUE);
+            }
+        }
+
+        return new ValidationResult(true);
+    }
+
+    // Java command line supports two kinds of main class format: <mainclass> and <module>[/<mainclass>]
+    private boolean isValidMainClassName(String mainClass) {
+        if (StringUtils.isEmpty(mainClass)) {
+            return true;
+        }
+
+        int index = mainClass.indexOf('/');
+        if (index == -1) {
+            return SourceVersion.isName(mainClass);
+        }
+
+        return SourceVersion.isName(mainClass.substring(0, index))
+            && SourceVersion.isName(mainClass.substring(index + 1));
+    }
+
+    private List<IJavaProject> searchClassInProjectClasspaths(String fullyQualifiedClassName) throws CoreException {
+        return ResolveClasspathsHandler.getJavaProjectFromType(fullyQualifiedClassName);
+    }
+
+    private ValidationResult validateProjectName(final String mainClass, final String projectName) {
+        if (StringUtils.isEmpty(projectName)) {
+            return new ValidationResult(true);
+        }
+
+        if (JdtUtils.getJavaProject(projectName) == null) {
+            return new ValidationResult(false, String.format("ConfigError: The project '%s' is not a valid java project.", projectName),
+                CONFIGERROR_INVALID_JAVA_PROJECT);
+        }
+
+        return new ValidationResult(true);
+    }
+
+    private List<ResolutionItem> computeProposals(List<Object> arguments, final String mainClass, final String projectName) {
+        List<ResolutionItem> proposals = resolveMainClassCore(arguments);
+
+        Collections.sort(proposals, new ProposalItemComparator((ResolutionItem item) -> {
+            if (Objects.equals(item.mainClass, mainClass)) {
+                return 1;
+            } else if (Objects.equals(item.projectName, projectName)) {
+                return 2;
+            }
+
+            return 999;
+        }));
+
+        return proposals;
+    }
+
+    private class ResolutionItem implements Comparable<ResolutionItem> {
+        private String mainClass;
+        private String projectName;
+        private String filePath;
+
+        public ResolutionItem(String mainClass, String projectName, String filePath) {
+            this.mainClass = mainClass;
+            this.projectName = projectName;
+            this.filePath = filePath;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o instanceof ResolutionItem) {
+                ResolutionItem item = (ResolutionItem) o;
+                return Objects.equals(mainClass, item.mainClass)
+                        && Objects.equals(projectName, item.projectName)
+                        && Objects.equals(filePath, item.filePath);
+            }
+            return false;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(mainClass, projectName, filePath);
+        }
+
+        @Override
+        public int compareTo(ResolutionItem o) {
+            if (isDefaultProject(this.projectName) && !isDefaultProject(o.projectName)) {
+                return 1;
+            } else if (!isDefaultProject(this.projectName) && isDefaultProject(o.projectName)) {
+                return -1;
+            }
+
+            return (this.projectName + "|" + this.mainClass).compareTo(o.projectName + "|" + o.mainClass);
+        }
+
+        private boolean isDefaultProject(String projectName) {
+            return StringUtils.isEmpty(projectName);
+        }
+    }
+
+    class ProposalItemComparator implements Comparator<ResolutionItem> {
+        Function<ResolutionItem, Integer> getRank;
+
+        ProposalItemComparator(Function<ResolutionItem, Integer> getRank) {
+            this.getRank = getRank;
+        }
+
+        @Override
+        public int compare(ResolutionItem o1, ResolutionItem o2) {
+            return getRank.apply(o1) - getRank.apply(o2);
+        }
+    }
+
+    class ValidationResponse {
+        ValidationResult mainClass;
+        ValidationResult projectName;
+        List<ResolutionItem> proposals;
+    }
+
+    class ValidationResult {
+        boolean isValid;
+        String message;
+        int kind;
+
+        ValidationResult(boolean isValid) {
+            this.isValid = isValid;
+        }
+
+        ValidationResult(boolean isValid, String message, int kind) {
+            this.isValid = isValid;
+            this.message = message;
+            this.kind = kind;
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveMainMethodHandler.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveMainMethodHandler.java
new file mode 100644
index 000000000..820bddd54
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveMainMethodHandler.java
@@ -0,0 +1,228 @@
+/*******************************************************************************
+ * Copyright (c) 2018-2021 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.OperationCanceledException;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.jdt.core.Flags;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IOpenable;
+import org.eclipse.jdt.core.ISourceRange;
+import org.eclipse.jdt.core.ISourceReference;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
+import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
+import org.eclipse.jdt.internal.core.SourceMethod;
+import org.eclipse.jdt.ls.core.internal.JDTUtils;
+import org.eclipse.jdt.ls.core.internal.handlers.DocumentLifeCycleHandler;
+import org.eclipse.jdt.ls.core.internal.managers.ProjectsManager;
+import org.eclipse.lsp4j.Range;
+
+import com.microsoft.java.debug.core.DebugException;
+
+public class ResolveMainMethodHandler {
+    /**
+     * Resolve the main methods from the current file.
+     * @return an array of main methods.
+     */
+    public static Object resolveMainMethods(List<Object> arguments, IProgressMonitor monitor) throws DebugException {
+        if (monitor.isCanceled() || arguments == null || arguments.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        // When the current document is changed, the language server will receive a didChange request about the changed text and then
+        // trigger a background job to update the change to the CompilationUnit. Because of race condition, the resolveMainMethods may read
+        // an old CompilationUnit. So add some waiting logic to wait the Document Update to finish first.
+        try {
+            Job.getJobManager().join(DocumentLifeCycleHandler.DOCUMENT_LIFE_CYCLE_JOBS, monitor);
+        } catch (OperationCanceledException e) {
+            return Collections.emptyList();
+        } catch (InterruptedException e) {
+            // Do nothing.
+        }
+
+        if (monitor.isCanceled()) {
+            return Collections.emptyList();
+        }
+
+        String uri = (String) arguments.get(0);
+        final ICompilationUnit unit = JDTUtils.resolveCompilationUnit(uri);
+        if (monitor.isCanceled() || unit == null || unit.getResource() == null || !unit.getResource().exists()) {
+            return Collections.emptyList();
+        }
+
+        try {
+            return resolveMainMethodCore(unit);
+        } catch (Exception e) {
+            throw new DebugException("Failed to resolve main method codeLens: " + e.getMessage(), e);
+        }
+    }
+
+    private static List<MainMethod> resolveMainMethodCore(ICompilationUnit compilationUnit) throws JavaModelException {
+        List<MainMethod> result = new ArrayList<>();
+        for (IMethod method : searchMainMethods(compilationUnit)) {
+            MainMethod mainMethod = extractMainMethodInfo(compilationUnit, method);
+            if (mainMethod != null) {
+                result.add(mainMethod);
+            }
+        }
+
+        return result;
+    }
+
+    private static List<IMethod> searchMainMethods(ICompilationUnit compilationUnit) throws JavaModelException {
+        List<IMethod> result = new ArrayList<>();
+        for (IType type : getPotentialMainClassTypes(compilationUnit)) {
+            IMethod method = getMainMethod(type);
+            if (method != null) {
+                result.add(method);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Returns the main method defined in the type.
+     */
+    public static IMethod getMainMethod(IType type) throws JavaModelException {
+        boolean allowInstanceMethod = isInstanceMainMethodSupported(type);
+        List<IMethod> methods = new ArrayList<>();
+        for (IMethod method : type.getMethods()) {
+            try {
+                if (method instanceof SourceMethod
+                    && ((SourceMethod) method).isMainMethodCandidate()) {
+                    methods.add(method);
+                }
+            } catch (NoSuchMethodError e) {
+                // isMainMethodCandidate() was added in JDT Core 3.36, skip if unavailable
+            }
+
+            if (method.isMainMethod()) {
+                methods.add(method);
+            }
+
+            if (!allowInstanceMethod && !methods.isEmpty()) {
+                return methods.get(0);
+            }
+        }
+
+        if (!methods.isEmpty()) {
+            methods.sort((method1, method2) -> {
+                return getMainMethodPriority(method1) - getMainMethodPriority(method2);
+            });
+
+            return methods.get(0);
+        }
+
+        return null;
+    }
+
+    private static boolean isInstanceMainMethodSupported(IType type) {
+        Map<String, String> options = type.getJavaProject().getOptions(true);
+        return CompilerOptions.versionToJdkLevel(options.get(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM)) >= ClassFileConstants.JDK21;
+    }
+
+    /**
+     * See Java 22 JEP 463 https://openjdk.org/jeps/463.
+     * It searches the main method in the launched class by following a specific order:
+     * - If the launched class contains a main method with a String[] parameter then choose that method.
+     * - Otherwise, if the class contains a main method with no parameters then choose that method.
+     */
+    private static int getMainMethodPriority(IMethod method) {
+        String[] params = method.getParameterTypes();
+        return params.length == 1 ?  1 : 2;
+    }
+
+    private static List<IType> getPotentialMainClassTypes(ICompilationUnit compilationUnit) throws JavaModelException {
+        List<IType> result = new ArrayList<>();
+        IType[] topLevelTypes = compilationUnit.getTypes();
+        result.addAll(Arrays.asList(topLevelTypes));
+        for (IType type : topLevelTypes) {
+            result.addAll(getPotentialMainClassTypesInChildren(type));
+        }
+
+        return result;
+    }
+
+    private static List<IType> getPotentialMainClassTypesInChildren(IType type) throws JavaModelException {
+        IType[] children = type.getTypes();
+        if (children.length == 0) {
+            return Collections.emptyList();
+        }
+
+        List<IType> result = new ArrayList<>();
+        for (IType child : children) {
+            // main method can only exist in the static class or top level class.
+            if (child.isClass() && Flags.isStatic(child.getFlags())) {
+                result.add(child);
+                result.addAll(getPotentialMainClassTypesInChildren(child));
+            }
+        }
+
+        return result;
+    }
+
+    private static MainMethod extractMainMethodInfo(ICompilationUnit typeRoot, IMethod method) throws JavaModelException {
+        final Range range = getRange(typeRoot, method);
+        IResource resource = typeRoot.getResource();
+        if (resource != null) {
+            IProject project = resource.getProject();
+            if (project != null) {
+                String mainClass = method.getDeclaringType().getFullyQualifiedName();
+                IJavaProject javaProject = JdtUtils.getJavaProject(project);
+                if (javaProject != null) {
+                    String moduleName = JdtUtils.getModuleName(javaProject);
+                    if (moduleName != null) {
+                        mainClass = moduleName + "/" + mainClass;
+                    }
+                }
+
+                String projectName = ProjectsManager.DEFAULT_PROJECT_NAME.equals(project.getName()) ? null : project.getName();
+                return new MainMethod(range, mainClass, projectName);
+            }
+        }
+
+        return null;
+    }
+
+    private static Range getRange(ICompilationUnit typeRoot, IJavaElement element) throws JavaModelException {
+        ISourceRange r = ((ISourceReference) element).getNameRange();
+        return JDTUtils.toRange((IOpenable) typeRoot, r.getOffset(), r.getLength());
+    }
+
+    static class MainMethod {
+        private Range range;
+        private String mainClass;
+        private String projectName;
+
+        public MainMethod(Range range, String mainClass, String projectName) {
+            this.range = range;
+            this.mainClass = mainClass;
+            this.projectName = projectName;
+        }
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveSourceMappingHandler.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveSourceMappingHandler.java
new file mode 100644
index 000000000..456474141
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/ResolveSourceMappingHandler.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2020 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+*******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal;
+
+import java.io.File;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+
+public class ResolveSourceMappingHandler {
+    private static final Pattern SOURCE_PATTERN = Pattern.compile("([\\w$\\.]+\\/)?(([\\w$]+\\.)+[<\\w$>]+)\\(([\\w-$]+\\.java:\\d+)\\)");
+    private static final JdtSourceLookUpProvider sourceProvider = new JdtSourceLookUpProvider();
+
+    public static String resolveSourceUri(List<Object> arguments) {
+        if (arguments == null || arguments.isEmpty()) {
+            return null;
+        }
+
+        return resolveSourceUri((String) arguments.get(0));
+    }
+
+    public static String resolveSourceUri(String lineText) {
+        if (lineText == null) {
+            return null;
+        }
+
+        Matcher matcher = SOURCE_PATTERN.matcher(lineText);
+        if (matcher.find()) {
+            String methodField = matcher.group(2);
+            String locationField = matcher.group(matcher.groupCount());
+            String fullyQualifiedName = methodField.substring(0, methodField.lastIndexOf("."));
+            String packageName = fullyQualifiedName.lastIndexOf(".") > -1 ? fullyQualifiedName.substring(0, fullyQualifiedName.lastIndexOf(".")) : "";
+            String[] locations = locationField.split(":");
+            String sourceName = locations[0];
+            String sourcePath = StringUtils.isBlank(packageName) ? sourceName
+                    : packageName.replace('.', File.separatorChar) + File.separatorChar + sourceName;
+            return sourceProvider.getSourceFileURI(fullyQualifiedName, sourcePath);
+        }
+
+        return null;
+    }
+}
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/UsageDataLogHandler.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/UsageDataLogHandler.java
index a3aa2b882..8bbb67edf 100644
--- a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/UsageDataLogHandler.java
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/UsageDataLogHandler.java
@@ -16,6 +16,7 @@
 import java.util.logging.Level;
 import java.util.logging.LogRecord;
 
+import com.microsoft.java.debug.core.DebugException;
 import com.microsoft.java.debug.core.UsageDataSession;
 import com.microsoft.java.debug.core.UsageDataStore;
 
@@ -30,7 +31,9 @@ public UsageDataLogHandler(Level level) {
     public void publish(LogRecord record) {
         if (record.getLevel().intValue() >= thresholdLevel.intValue()) {
             if (record.getThrown() != null) {
-                // error message
+                if (isUserError(record.getThrown())) {
+                    return;
+                }
                 UsageDataStore.getInstance().logErrorData(record.getMessage(), record.getThrown());
                 UsageDataSession.enableJdiEventSequence();
             } else if (record.getParameters() != null) {
@@ -54,4 +57,7 @@ public void close() throws SecurityException {
         // do nothing
     }
 
+    private static boolean isUserError(Throwable th) {
+        return th instanceof DebugException &&  ((DebugException) th).isUserError();
+    }
 }
diff --git a/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/eval/JdtEvaluationProvider.java b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/eval/JdtEvaluationProvider.java
new file mode 100644
index 000000000..a48cf7ead
--- /dev/null
+++ b/com.microsoft.java.debug.plugin/src/main/java/com/microsoft/java/debug/plugin/internal/eval/JdtEvaluationProvider.java
@@ -0,0 +1,547 @@
+/*******************************************************************************
+ * Copyright (c) 2017-2019 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+
+package com.microsoft.java.debug.plugin.internal.eval;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.reflect.FieldUtils;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.debug.core.DebugException;
+import org.eclipse.debug.core.ILaunch;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.model.IDebugTarget;
+import org.eclipse.debug.core.model.IProcess;
+import org.eclipse.debug.core.model.ISourceLocator;
+import org.eclipse.debug.core.model.IStackFrame;
+import org.eclipse.debug.core.sourcelookup.AbstractSourceLookupDirector;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.debug.core.IJavaObject;
+import org.eclipse.jdt.debug.core.IJavaStackFrame;
+import org.eclipse.jdt.debug.core.IJavaThread;
+import org.eclipse.jdt.debug.core.IJavaValue;
+import org.eclipse.jdt.debug.eval.ICompiledExpression;
+import org.eclipse.jdt.internal.debug.core.model.JDIDebugTarget;
+import org.eclipse.jdt.internal.debug.core.model.JDIObjectValue;
+import org.eclipse.jdt.internal.debug.core.model.JDIStackFrame;
+import org.eclipse.jdt.internal.debug.core.model.JDIThread;
+import org.eclipse.jdt.internal.debug.core.model.JDIValue;
+import org.eclipse.jdt.internal.debug.eval.ast.engine.ASTEvaluationEngine;
+import org.eclipse.jdt.internal.launching.JavaSourceLookupDirector;
+
+import com.microsoft.java.debug.core.Configuration;
+import com.microsoft.java.debug.core.IEvaluatableBreakpoint;
+import com.microsoft.java.debug.core.adapter.AdapterUtils;
+import com.microsoft.java.debug.core.adapter.Constants;
+import com.microsoft.java.debug.core.adapter.ErrorCode;
+import com.microsoft.java.debug.core.adapter.IDebugAdapterContext;
+import com.microsoft.java.debug.core.adapter.IEvaluationProvider;
+import com.microsoft.java.debug.core.adapter.ISourceLookUpProvider;
+import com.microsoft.java.debug.plugin.internal.JdtSourceLookUpProvider;
+import com.microsoft.java.debug.plugin.internal.JdtUtils;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.StackFrame;
+import com.sun.jdi.ThreadReference;
+import com.sun.jdi.Value;
+import com.sun.jdi.VirtualMachine;
+
+public class JdtEvaluationProvider implements IEvaluationProvider {
+    private static final Logger logger = Logger.getLogger(Configuration.LOGGER_NAME);
+    private IJavaProject project;
+    private ILaunch launch;
+    private JDIDebugTarget debugTarget;
+    private Map<ThreadReference, JDIThread> threadMap = new HashMap<>();
+    private HashMap<String, Object> options = new HashMap<>();
+    private IDebugAdapterContext context;
+
+    private List<IJavaProject> projectCandidates;
+
+    private Set<String> visitedClassNames = new HashSet<>();
+
+    public JdtEvaluationProvider() {
+    }
+
+    @Override
+    public void initialize(IDebugAdapterContext context, Map<String, Object> props) {
+        if (props == null) {
+            throw new IllegalArgumentException("argument is null");
+        }
+        options.putAll(props);
+        this.context = context;
+    }
+
+    @Override
+    public CompletableFuture<Value> evaluateForBreakpoint(IEvaluatableBreakpoint breakpoint, ThreadReference thread) {
+        if (breakpoint == null) {
+            throw new IllegalArgumentException("The breakpoint is null.");
+        }
+
+        if (!breakpoint.containsEvaluatableExpression()) {
+            throw new IllegalArgumentException("The breakpoint doesn't contain the evaluatable expression.");
+        }
+
+        if (StringUtils.isNotBlank(breakpoint.getLogMessage())) {
+            return evaluate(logMessageToExpression(breakpoint.getLogMessage()), thread, 0, breakpoint);
+        } else {
+            return evaluate(breakpoint.getCondition(), thread, 0, breakpoint);
+        }
+    }
+
+    @Override
+    public CompletableFuture<Value> evaluate(String expression, ThreadReference thread, int depth) {
+        return evaluate(expression, thread, depth, null);
+    }
+
+    @Override
+    public CompletableFuture<Value> evaluate(String expression, ObjectReference thisContext, ThreadReference thread) {
+        CompletableFuture<Value> completableFuture = new CompletableFuture<>();
+        try  {
+            ensureDebugTarget(thisContext.virtualMachine(), thisContext.type().name());
+            JDIThread jdiThread = getMockJDIThread(thread);
+            JDIObjectValue jdiObject = new JDIObjectValue(debugTarget, thisContext);
+            ASTEvaluationEngine engine = new ASTEvaluationEngine(project, debugTarget);
+            ICompiledExpression compiledExpression = engine.getCompiledExpression(expression, jdiObject);
+            internalEvaluate(engine, compiledExpression, jdiObject, jdiThread, completableFuture);
+            return completableFuture;
+        } catch (Exception ex) {
+            completableFuture.completeExceptionally(ex);
+            return completableFuture;
+        }
+    }
+
+    private CompletableFuture<Value> evaluate(String expression, ThreadReference thread, int depth, IEvaluatableBreakpoint breakpoint) {
+        CompletableFuture<Value> completableFuture = new CompletableFuture<>();
+        try  {
+            StackFrame sf = thread.frame(depth);
+            String typeName = sf.location().method().declaringType().name();
+            ensureDebugTarget(thread.virtualMachine(), typeName);
+            JDIThread jdiThread = getMockJDIThread(thread);
+            JDIStackFrame stackframe = createStackFrame(jdiThread, depth);
+            if (stackframe == null) {
+                throw new IllegalStateException("Cannot evaluate because the stackframe is not available.");
+            }
+
+            ICompiledExpression compiledExpression = null;
+            ASTEvaluationEngine engine = new ASTEvaluationEngine(project, debugTarget);
+            boolean newExpression = false;
+            if (breakpoint != null) {
+                long threadId = thread.uniqueID();
+                compiledExpression = (ICompiledExpression) breakpoint.getCompiledExpression(threadId);
+                if (compiledExpression == null) {
+                    newExpression = true;
+                    compiledExpression = engine.getCompiledExpression(expression, stackframe);
+                    breakpoint.setCompiledExpression(threadId, compiledExpression);
+                }
+            } else {
+                compiledExpression = engine.getCompiledExpression(expression, stackframe);
+            }
+
+            if (compiledExpression.hasErrors()) {
+                if (!newExpression && breakpoint != null) {
+                    if (StringUtils.isNotBlank(breakpoint.getLogMessage())) {
+                        // for logpoint with compilation errors, don't send errors if it is already reported
+                        Value emptyValue = thread.virtualMachine().mirrorOf("");
+                        completableFuture.complete(emptyValue);
+                    } else {
+                        // for conditional bp, report true to let breakpoint hit
+                        Value trueValue = thread.virtualMachine().mirrorOf(true);
+                        completableFuture.complete(trueValue);
+                    }
+                    return completableFuture;
+                }
+                completableFuture.completeExceptionally(AdapterUtils.createUserErrorDebugException(
+                        String.format("Cannot evaluate because of compilation error(s): %s.",
+                                StringUtils.join(compiledExpression.getErrorMessages(), "\n")),
+                        ErrorCode.EVALUATION_COMPILE_ERROR));
+                return completableFuture;
+            }
+            internalEvaluate(engine, compiledExpression, stackframe, completableFuture);
+            return completableFuture;
+        } catch (Exception ex) {
+            completableFuture.completeExceptionally(ex);
+            return completableFuture;
+        }
+    }
+
+    @Override
+    public CompletableFuture<Value> invokeMethod(ObjectReference thisContext, String methodName, String methodSignature,
+            Value[] args, ThreadReference thread, boolean invokeSuper) {
+        CompletableFuture<Value> completableFuture = new CompletableFuture<>();
+        try  {
+            ensureDebugTarget(thisContext.virtualMachine(), thisContext.type().name());
+            JDIThread jdiThread = getMockJDIThread(thread);
+            JDIObjectValue jdiObject = new JDIObjectValue(debugTarget, thisContext);
+            List<IJavaValue> arguments = null;
+            if (args == null) {
+                arguments = Collections.EMPTY_LIST;
+            } else {
+                arguments = new ArrayList<>(args.length);
+                for (Value arg : args) {
+                    arguments.add(new JDIValue(debugTarget, arg));
+                }
+            }
+            IJavaValue javaValue = jdiObject.sendMessage(methodName, methodSignature, arguments.toArray(new IJavaValue[0]), jdiThread, invokeSuper);
+            // we need to read fValue from the result Value instance implements by JDT
+            Value value = (Value) FieldUtils.readField(javaValue, "fValue", true);
+            completableFuture.complete(value);
+            return completableFuture;
+        } catch (Exception ex) {
+            completableFuture.completeExceptionally(ex);
+            return completableFuture;
+        }
+    }
+
+    private String logMessageToExpression(String logMessage) {
+        final String LOGMESSAGE_VARIABLE_REGEXP = "\\{(.*?)\\}";
+        String format = logMessage.replaceAll(LOGMESSAGE_VARIABLE_REGEXP, "%s");
+
+        Pattern pattern = Pattern.compile(LOGMESSAGE_VARIABLE_REGEXP);
+        Matcher matcher = pattern.matcher(logMessage);
+        List<String> arguments = new ArrayList<>();
+        while (matcher.find()) {
+            arguments.add("(" + matcher.group(1) + ")");
+        }
+
+        if (arguments.size() > 0) {
+            return "String.format(\"" + format + "\"," + String.join(",", arguments) + ")";
+        } else {
+            return "\"" + format + "\"";
+        }
+    }
+
+    /**
+     * Prepare a list of java project candidates in workspace which contains the main class.
+     *
+     * @param mainclass the main class specified by launch.json for finding project candidates
+     */
+    private void initializeProjectCandidates(String mainclass) {
+        IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+        projectCandidates = Arrays.stream(root.getProjects()).map(JdtUtils::getJavaProject).filter(p -> {
+            try {
+                return p != null && p.hasBuildState();
+            } catch (Exception e) {
+                // ignore
+            }
+            return false;
+        }).collect(Collectors.toList());
+
+        if (StringUtils.isNotBlank(mainclass)) {
+            filterProjectCandidatesByClass(mainclass);
+        }
+    }
+
+    private void filterProjectCandidatesByClass(String className) {
+        projectCandidates = visitedClassNames.contains(className) ? projectCandidates
+                 : projectCandidates.stream().filter(p -> {
+                     try {
+                         return p.findType(className) != null;
+                     } catch (Exception e) {
+                         // ignore
+                     }
+                     return false;
+                 }).collect(Collectors.toList());
+        visitedClassNames.add(className);
+    }
+
+    private IJavaProject findJavaProjectByType(String typeName) {
+        if (projectCandidates == null) {
+            // initial candidate projects by main class (projects contains this main class)
+            initializeProjectCandidates((String) options.get(Constants.MAIN_CLASS));
+        }
+
+        if (projectCandidates.size() == 0) {
+            logger.severe("No project is available for evaluation.");
+            throw new IllegalStateException("Cannot evaluate, please specify projectName in launch.json.");
+        }
+
+        try {
+            // narrow down candidate projects by current class
+            filterProjectCandidatesByClass(typeName);
+        } catch (Exception ex) {
+            logger.severe("Cannot evaluate when the project is not specified, due to exception: " + ex.getMessage());
+            throw new IllegalStateException("Cannot evaluate, please specify projectName in launch.json.");
+        }
+
+        if (projectCandidates.size() == 1) {
+            return projectCandidates.get(0);
+        }
+
+        if (projectCandidates.size() == 0) {
+            logger.severe("No project is available for evaluation.");
+            throw new IllegalStateException("Cannot evaluate, please specify projectName in launch.json.");
+        } else {
+            // narrow down projects
+            logger.severe("Multiple projects are valid for evaluation.");
+            throw new IllegalStateException("Cannot evaluate, please specify projectName in launch.json.");
+        }
+
+    }
+
+    private JDIStackFrame createStackFrame(JDIThread thread, int depth) {
+        try {
+            IStackFrame[] jdiStackFrames = thread.getStackFrames();
+            return jdiStackFrames.length > depth ? (JDIStackFrame) jdiStackFrames[depth] : null;
+        } catch (DebugException e) {
+            return null;
+        }
+
+    }
+
+    private JDIThread getMockJDIThread(ThreadReference thread) {
+        synchronized (threadMap) {
+            return threadMap.computeIfAbsent(thread, threadKey -> new JDIThread(debugTarget, thread) {
+                @Override
+                protected synchronized void invokeComplete(int restoreTimeout) {
+                    super.invokeComplete(restoreTimeout);
+                    context.getStackFrameManager().reloadStackFrames(thread, false);
+                }
+            });
+        }
+
+    }
+
+    private void internalEvaluate(ASTEvaluationEngine engine, ICompiledExpression compiledExpression,
+            IJavaStackFrame stackframe, CompletableFuture<Value> completableFuture) {
+        try  {
+            engine.evaluateExpression(compiledExpression, stackframe, evaluateResult -> {
+                if (evaluateResult == null || evaluateResult.hasErrors()) {
+                    DebugException debugException = evaluateResult.getException();
+                    if (debugException == null) {
+                        completableFuture.completeExceptionally(
+                              new RuntimeException(String.join(" ", evaluateResult.getErrorMessages())));
+                        return;
+                    }
+                    IStatus status = debugException.getStatus();
+                    if (status.getCode() == DebugException.TARGET_REQUEST_FAILED) {
+                        Throwable innerException = status.getException();
+                        if (innerException instanceof com.sun.jdi.InvocationException) {
+                            ObjectReference objectReference = ((com.sun.jdi.InvocationException) innerException).exception();
+                            completableFuture.complete(objectReference);
+                            return;
+                        }
+                    }
+                    completableFuture.completeExceptionally(debugException);
+                    return;
+                }
+                try {
+                    // we need to read fValue from the result Value instance implements by JDT
+                    Value value = (Value) FieldUtils.readField(evaluateResult.getValue(), "fValue", true);
+                    completableFuture.complete(value);
+                } catch (IllegalArgumentException | IllegalAccessException ex) {
+                    completableFuture.completeExceptionally(ex);
+                }
+            }, 0, false);
+        } catch (Exception ex) {
+            completableFuture.completeExceptionally(ex);
+        }
+    }
+
+    private void internalEvaluate(ASTEvaluationEngine engine, ICompiledExpression compiledExpression, IJavaObject object,
+            IJavaThread thread, CompletableFuture<Value> completableFuture) {
+        try  {
+            engine.evaluateExpression(compiledExpression, object, thread, evaluateResult -> {
+                if (evaluateResult == null || evaluateResult.hasErrors()) {
+                    Exception ex = evaluateResult.getException() != null ? evaluateResult.getException()
+                            : new RuntimeException(StringUtils.join(evaluateResult.getErrorMessages()));
+                    completableFuture.completeExceptionally(ex);
+                    return;
+                }
+                try {
+                    // we need to read fValue from the result Value instance implements by JDT
+                    Value value = (Value) FieldUtils.readField(evaluateResult.getValue(), "fValue", true);
+                    completableFuture.complete(value);
+                } catch (IllegalArgumentException | IllegalAccessException ex) {
+                    completableFuture.completeExceptionally(ex);
+                }
+            }, 0, false);
+        } catch (Exception ex) {
+            completableFuture.completeExceptionally(ex);
+        }
+    }
+
+    @Override
+    public boolean isInEvaluation(ThreadReference thread) {
+        if (debugTarget == null) {
+            return false;
+        }
+
+        JDIThread jdiThread = getMockJDIThread(thread);
+        return jdiThread != null && (jdiThread.isPerformingEvaluation() || jdiThread.isInvokingMethod());
+    }
+
+    @Override
+    public void clearState(ThreadReference thread) {
+        if (debugTarget != null) {
+            synchronized (threadMap) {
+                JDIThread jdiThread = threadMap.get(thread);
+                if (jdiThread != null) {
+                    try {
+                        jdiThread.terminateEvaluation();
+                    } catch (DebugException e) {
+                        logger.warning(String.format("Error stopping evaluation on thread %d: %s", thread.uniqueID(),
+                                e.toString()));
+                    }
+                    threadMap.remove(thread);
+                }
+            }
+        }
+    }
+
+    private void ensureDebugTarget(VirtualMachine vm, String typeName) {
+        if (debugTarget == null) {
+            if (project == null) {
+                String projectName = (String) options.get(Constants.PROJECT_NAME);
+                if (StringUtils.isBlank(projectName)) {
+                    project = findJavaProjectByType(typeName);
+                } else {
+                    IJavaProject javaProject = JdtUtils.getJavaProject(projectName);
+                    if (javaProject == null) {
+                        throw new IllegalStateException(String.format("Project %s cannot be found.", projectName));
+                    }
+                    project = javaProject;
+                }
+            }
+
+            if (launch == null) {
+                ISourceLookUpProvider sourceProvider = context.getProvider(ISourceLookUpProvider.class);
+                launch = createILaunchMock(project, ((JdtSourceLookUpProvider) sourceProvider).getSourceContainers());
+            }
+
+            debugTarget = new JDIDebugTarget(launch, vm, "", false, false, null, false) {
+                @Override
+                protected synchronized void initialize() {
+                    // use empty initialize intentionally to avoid to register jdi event listener
+                }
+            };
+        }
+    }
+
+    private static ILaunch createILaunchMock(IJavaProject project, ISourceContainer[] containers) {
+        return new ILaunch() {
+            private AbstractSourceLookupDirector locator;
+
+            @Override
+            public boolean canTerminate() {
+                return false;
+            }
+
+            @Override
+            public boolean isTerminated() {
+                return false;
+            }
+
+            @Override
+            public void terminate() throws DebugException {
+            }
+
+            @Override
+            public <T> T getAdapter(Class<T> arg0) {
+                return null;
+            }
+
+            @Override
+            public void addDebugTarget(IDebugTarget arg0) {
+            }
+
+            @Override
+            public void addProcess(IProcess arg0) {
+            }
+
+            @Override
+            public String getAttribute(String arg0) {
+                return null;
+            }
+
+            @Override
+            public Object[] getChildren() {
+                return null;
+            }
+
+            @Override
+            public IDebugTarget getDebugTarget() {
+                return null;
+            }
+
+            @Override
+            public IDebugTarget[] getDebugTargets() {
+                return null;
+            }
+
+            @Override
+            public ILaunchConfiguration getLaunchConfiguration() {
+                return null;
+            }
+
+            @Override
+            public String getLaunchMode() {
+                return null;
+            }
+
+            @Override
+            public IProcess[] getProcesses() {
+                return null;
+            }
+
+            @Override
+            public ISourceLocator getSourceLocator() {
+                if (locator != null) {
+                    return locator;
+                }
+                locator = new JavaSourceLookupDirector();
+
+                try {
+                    locator.setSourceContainers(containers);
+                } catch (Exception e) {
+                    logger.severe(String.format("Cannot initialize JavaSourceLookupDirector: %s", e.toString()));
+                }
+                locator.initializeParticipants();
+                return locator;
+            }
+
+            @Override
+            public boolean hasChildren() {
+                return false;
+            }
+
+            @Override
+            public void removeDebugTarget(IDebugTarget arg0) {
+            }
+
+            @Override
+            public void removeProcess(IProcess arg0) {
+            }
+
+            @Override
+            public void setAttribute(String arg0, String arg1) {
+            }
+
+            @Override
+            public void setSourceLocator(ISourceLocator arg0) {
+            }
+        };
+    }
+}
diff --git a/com.microsoft.java.debug.repository/.project b/com.microsoft.java.debug.repository/.project
new file mode 100644
index 000000000..255908647
--- /dev/null
+++ b/com.microsoft.java.debug.repository/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>com.microsoft.java.debug.repository</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1665543654735</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>
diff --git a/com.microsoft.java.debug.repository/category.xml b/com.microsoft.java.debug.repository/category.xml
new file mode 100644
index 000000000..f30a2f4c4
--- /dev/null
+++ b/com.microsoft.java.debug.repository/category.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<site>
+   <bundle id="com.microsoft.java.debug.plugin" version="0.53.2">
+   <category name="javadebug" />
+   </bundle>
+   <category-def name="javadebug" label="Java Debug Server"/>
+</site>
diff --git a/com.microsoft.java.debug.repository/pom.xml b/com.microsoft.java.debug.repository/pom.xml
new file mode 100644
index 000000000..573aff2ac
--- /dev/null
+++ b/com.microsoft.java.debug.repository/pom.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.microsoft.java</groupId>
+        <artifactId>java-debug-parent</artifactId>
+        <version>0.53.2</version>
+    </parent>
+	<artifactId>com.microsoft.java.debug.repository</artifactId>
+	<packaging>eclipse-repository</packaging>
+	<name>${base.name} :: P2 Update site</name>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.eclipse.tycho</groupId>
+                <artifactId>tycho-maven-plugin</artifactId>
+                <version>${tycho-version}</version>
+                <extensions>true</extensions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/com.microsoft.java.debug.repository/pushToBintray.sh b/com.microsoft.java.debug.repository/pushToBintray.sh
new file mode 100644
index 000000000..1cbada3c3
--- /dev/null
+++ b/com.microsoft.java.debug.repository/pushToBintray.sh
@@ -0,0 +1,44 @@
+#!/bin/bash
+#Usage: ./pushToBintray.sh username apikey repo package version
+BINTRAY_USER=$1
+BINTRAY_API_KEY=$2
+BINTRAY_REPO=$3
+PCK_NAME=$4
+PCK_VERSION=$5
+
+SCRIPT=$(readlink -f "$0")
+SCRIPTPATH=$(dirname "$SCRIPT")
+
+function main() {
+    cd $SCRIPTPATH/target/repository
+
+    METADATA=./*
+    PLUGINDIR=plugins/*
+
+    echo "Processing p2 metadata file..."
+    for f in $METADATA;
+        do
+            if [ ! -d $f ]; then
+                echo "Pushing metadata file $f ..."
+                filename=$(basename "$f")
+                curl -X PUT -T $f -u ${BINTRAY_USER}:${BINTRAY_API_KEY} https://api.bintray.com/content/${BINTRAY_USER}/${BINTRAY_REPO}/$f;publish=0
+                curl -X PUT -T $f -u ${BINTRAY_USER}:${BINTRAY_API_KEY} https://api.bintray.com/content/${BINTRAY_USER}/${BINTRAY_REPO}/${PCK_NAME}/${PCK_VERSION}/$filename;publish=0
+                echo ""
+            fi
+        done
+
+    echo "Processing plugins file..."
+    for f in $PLUGINDIR;
+        do
+            echo "Pushing plugin file $f ..."
+            curl -X PUT -T $f -u ${BINTRAY_USER}:${BINTRAY_API_KEY} https://api.bintray.com/content/${BINTRAY_USER}/${BINTRAY_REPO}/${PCK_NAME}/${PCK_VERSION}/$f;publish=0;override=1
+            curl -X PUT -T $f -u ${BINTRAY_USER}:${BINTRAY_API_KEY} https://api.bintray.com/content/${BINTRAY_USER}/${BINTRAY_REPO}/${PCK_NAME}/${PCK_VERSION}/${PCK_NAME}/${PCK_VERSION}/$f;publish=0
+            echo ""
+        done
+
+    echo "Publishing the new version"
+    curl -X POST -u ${BINTRAY_USER}:${BINTRAY_API_KEY} https://api.bintray.com/content/${BINTRAY_USER}/${BINTRAY_REPO}/publish -d "{ \"discard\": \"false\" }"
+    curl -X POST -u ${BINTRAY_USER}:${BINTRAY_API_KEY} https://api.bintray.com/content/${BINTRAY_USER}/${BINTRAY_REPO}/${PCK_NAME}/${PCK_VERSION}/publish -d "{ \"discard\": \"false\" }"
+}
+
+main "$@"
\ No newline at end of file
diff --git a/com.microsoft.java.debug.target/com.microsoft.java.debug.tp.target b/com.microsoft.java.debug.target/com.microsoft.java.debug.tp.target
new file mode 100644
index 000000000..31462a770
--- /dev/null
+++ b/com.microsoft.java.debug.target/com.microsoft.java.debug.tp.target
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?pde version="3.8"?>
+<target name="Java Debug" sequenceNumber="40">
+    <locations>
+        <location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+            <unit id="org.eclipse.platform.feature.group" version="0.0.0"/>
+            <repository location="https://download.eclipse.org/eclipse/updates/4.38"/>
+        </location>
+        <location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+            <unit id="org.eclipse.jdt.ls.core" version="0.0.0"/>
+            <unit id="org.eclipse.m2e.jdt" version="0.0.0"/>
+            <unit id="org.eclipse.buildship.core" version="0.0.0"/>
+            <unit id="com.google.gson" version="0.0.0"/>
+            <unit id="com.google.guava" version="0.0.0"/>
+            <unit id="org.apache.commons.lang3" version="0.0.0"/>
+            <repository location="https://download.eclipse.org/jdtls/snapshots/repository/latest"/>
+        </location>
+    </locations>
+    <targetJRE path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-21"/>
+</target>
diff --git a/com.microsoft.java.debug.target/pom.xml b/com.microsoft.java.debug.target/pom.xml
new file mode 100644
index 000000000..8e49b638b
--- /dev/null
+++ b/com.microsoft.java.debug.target/pom.xml
@@ -0,0 +1,12 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>com.microsoft.java</groupId>
+		<artifactId>java-debug-parent</artifactId>
+		<version>0.53.2</version>
+	</parent>
+	<artifactId>com.microsoft.java.debug.tp</artifactId>
+	<name>${base.name} :: Target Platform</name>
+	<packaging>eclipse-target-definition</packaging>
+</project>
diff --git a/javaConfig.json b/javaConfig.json
new file mode 100644
index 000000000..8ab611931
--- /dev/null
+++ b/javaConfig.json
@@ -0,0 +1,7 @@
+{
+    "projects": [
+        "com.microsoft.java.debug.core",
+        "com.microsoft.java.debug.plugin"
+    ],
+   "targetPlatform": "com.microsoft.java.debug.target/com.microsoft.java.debug.tp.target"
+}
diff --git a/mvnw b/mvnw
index e96ccd5fb..e9cf8d330 100755
--- a/mvnw
+++ b/mvnw
@@ -19,209 +19,277 @@
 # ----------------------------------------------------------------------------
 
 # ----------------------------------------------------------------------------
-# Maven2 Start Up Batch script
-#
-# Required ENV vars:
-# ------------------
-#   JAVA_HOME - location of a JDK home dir
+# Apache Maven Wrapper startup batch script, version 3.3.3
 #
 # Optional ENV vars
 # -----------------
-#   M2_HOME - location of maven2's installed home dir
-#   MAVEN_OPTS - parameters passed to the Java VM when running Maven
-#     e.g. to debug Maven itself, use
-#       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
-#   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+#   JAVA_HOME - location of a JDK home dir, required when download maven via java source
+#   MVNW_REPOURL - repo url base for downloading maven distribution
+#   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+#   MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output
 # ----------------------------------------------------------------------------
 
-if [ -z "$MAVEN_SKIP_RC" ] ; then
-
-  if [ -f /etc/mavenrc ] ; then
-    . /etc/mavenrc
-  fi
+set -euf
+[ "${MVNW_VERBOSE-}" != debug ] || set -x
 
-  if [ -f "$HOME/.mavenrc" ] ; then
-    . "$HOME/.mavenrc"
-  fi
+# OS specific support.
+native_path() { printf %s\\n "$1"; }
+case "$(uname)" in
+CYGWIN* | MINGW*)
+  [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")"
+  native_path() { cygpath --path --windows "$1"; }
+  ;;
+esac
 
-fi
+# set JAVACMD and JAVACCMD
+set_java_home() {
+  # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched
+  if [ -n "${JAVA_HOME-}" ]; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+      JAVACCMD="$JAVA_HOME/jre/sh/javac"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+      JAVACCMD="$JAVA_HOME/bin/javac"
 
-# OS specific support.  $var _must_ be set to either true or false.
-cygwin=false;
-darwin=false;
-mingw=false
-case "`uname`" in
-  CYGWIN*) cygwin=true ;;
-  MINGW*) mingw=true;;
-  Darwin*) darwin=true
-    # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
-    # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
-    if [ -z "$JAVA_HOME" ]; then
-      if [ -x "/usr/libexec/java_home" ]; then
-        export JAVA_HOME="`/usr/libexec/java_home`"
-      else
-        export JAVA_HOME="/Library/Java/Home"
+      if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then
+        echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2
+        echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2
+        return 1
       fi
     fi
-    ;;
-esac
+  else
+    JAVACMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v java
+    )" || :
+    JAVACCMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v javac
+    )" || :
 
-if [ -z "$JAVA_HOME" ] ; then
-  if [ -r /etc/gentoo-release ] ; then
-    JAVA_HOME=`java-config --jre-home`
+    if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then
+      echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2
+      return 1
+    fi
   fi
-fi
-
-if [ -z "$M2_HOME" ] ; then
-  ## resolve links - $0 may be a link to maven's home
-  PRG="$0"
+}
 
-  # need this for relative symlinks
-  while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-      PRG="$link"
-    else
-      PRG="`dirname "$PRG"`/$link"
-    fi
+# hash string like Java String::hashCode
+hash_string() {
+  str="${1:-}" h=0
+  while [ -n "$str" ]; do
+    char="${str%"${str#?}"}"
+    h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296))
+    str="${str#?}"
   done
+  printf %x\\n $h
+}
+
+verbose() { :; }
+[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; }
 
-  saveddir=`pwd`
+die() {
+  printf %s\\n "$1" >&2
+  exit 1
+}
+
+trim() {
+  # MWRAPPER-139:
+  #   Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds.
+  #   Needed for removing poorly interpreted newline sequences when running in more
+  #   exotic environments such as mingw bash on Windows.
+  printf "%s" "${1}" | tr -d '[:space:]'
+}
+
+scriptDir="$(dirname "$0")"
+scriptName="$(basename "$0")"
+
+# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties
+while IFS="=" read -r key value; do
+  case "${key-}" in
+  distributionUrl) distributionUrl=$(trim "${value-}") ;;
+  distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;;
+  esac
+done <"$scriptDir/.mvn/wrapper/maven-wrapper.properties"
+[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+
+case "${distributionUrl##*/}" in
+maven-mvnd-*bin.*)
+  MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/
+  case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in
+  *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;;
+  :Darwin*x86_64) distributionPlatform=darwin-amd64 ;;
+  :Darwin*arm64) distributionPlatform=darwin-aarch64 ;;
+  :Linux*x86_64*) distributionPlatform=linux-amd64 ;;
+  *)
+    echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2
+    distributionPlatform=linux-amd64
+    ;;
+  esac
+  distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip"
+  ;;
+maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;;
+*) MVN_CMD="mvn${scriptName#mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;;
+esac
 
-  M2_HOME=`dirname "$PRG"`/..
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}"
+distributionUrlName="${distributionUrl##*/}"
+distributionUrlNameMain="${distributionUrlName%.*}"
+distributionUrlNameMain="${distributionUrlNameMain%-bin}"
+MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}"
+MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")"
 
-  # make it fully qualified
-  M2_HOME=`cd "$M2_HOME" && pwd`
+exec_maven() {
+  unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || :
+  exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD"
+}
 
-  cd "$saveddir"
-  # echo Using m2 at $M2_HOME
+if [ -d "$MAVEN_HOME" ]; then
+  verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  exec_maven "$@"
 fi
 
-# For Cygwin, ensure paths are in UNIX format before anything is touched
-if $cygwin ; then
-  [ -n "$M2_HOME" ] &&
-    M2_HOME=`cygpath --unix "$M2_HOME"`
-  [ -n "$JAVA_HOME" ] &&
-    JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-  [ -n "$CLASSPATH" ] &&
-    CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
+case "${distributionUrl-}" in
+*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;;
+*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;;
+esac
+
+# prepare tmp dir
+if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then
+  clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; }
+  trap clean HUP INT TERM EXIT
+else
+  die "cannot create temp dir"
 fi
 
-# For Mingw, ensure paths are in UNIX format before anything is touched
-if $mingw ; then
-  [ -n "$M2_HOME" ] &&
-    M2_HOME="`(cd "$M2_HOME"; pwd)`"
-  [ -n "$JAVA_HOME" ] &&
-    JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
-  # TODO classpath?
+mkdir -p -- "${MAVEN_HOME%/*}"
+
+# Download and Install Apache Maven
+verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+verbose "Downloading from: $distributionUrl"
+verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+# select .zip or .tar.gz
+if ! command -v unzip >/dev/null; then
+  distributionUrl="${distributionUrl%.zip}.tar.gz"
+  distributionUrlName="${distributionUrl##*/}"
 fi
 
-if [ -z "$JAVA_HOME" ]; then
-  javaExecutable="`which javac`"
-  if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
-    # readlink(1) is not available as standard on Solaris 10.
-    readLink=`which readlink`
-    if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
-      if $darwin ; then
-        javaHome="`dirname \"$javaExecutable\"`"
-        javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
-      else
-        javaExecutable="`readlink -f \"$javaExecutable\"`"
-      fi
-      javaHome="`dirname \"$javaExecutable\"`"
-      javaHome=`expr "$javaHome" : '\(.*\)/bin'`
-      JAVA_HOME="$javaHome"
-      export JAVA_HOME
-    fi
-  fi
+# verbose opt
+__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR=''
+[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v
+
+# normalize http auth
+case "${MVNW_PASSWORD:+has-password}" in
+'') MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+esac
+
+if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then
+  verbose "Found wget ... using wget"
+  wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl"
+elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then
+  verbose "Found curl ... using curl"
+  curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl"
+elif set_java_home; then
+  verbose "Falling back to use Java to download"
+  javaSource="$TMP_DOWNLOAD_DIR/Downloader.java"
+  targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName"
+  cat >"$javaSource" <<-END
+	public class Downloader extends java.net.Authenticator
+	{
+	  protected java.net.PasswordAuthentication getPasswordAuthentication()
+	  {
+	    return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() );
+	  }
+	  public static void main( String[] args ) throws Exception
+	  {
+	    setDefault( new Downloader() );
+	    java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() );
+	  }
+	}
+	END
+  # For Cygwin/MinGW, switch paths to Windows format before running javac and java
+  verbose " - Compiling Downloader.java ..."
+  "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java"
+  verbose " - Running Downloader.java ..."
+  "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")"
 fi
 
-if [ -z "$JAVACMD" ] ; then
-  if [ -n "$JAVA_HOME"  ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-      # IBM's JDK on AIX uses strange locations for the executables
-      JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-      JAVACMD="$JAVA_HOME/bin/java"
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+if [ -n "${distributionSha256Sum-}" ]; then
+  distributionSha256Result=false
+  if [ "$MVN_CMD" = mvnd.sh ]; then
+    echo "Checksum validation is not supported for maven-mvnd." >&2
+    echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  elif command -v sha256sum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c - >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  elif command -v shasum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then
+      distributionSha256Result=true
     fi
   else
-    JAVACMD="`which java`"
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+    echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  fi
+  if [ $distributionSha256Result = false ]; then
+    echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2
+    echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2
+    exit 1
   fi
 fi
 
-if [ ! -x "$JAVACMD" ] ; then
-  echo "Error: JAVA_HOME is not defined correctly." >&2
-  echo "  We cannot execute $JAVACMD" >&2
-  exit 1
-fi
-
-if [ -z "$JAVA_HOME" ] ; then
-  echo "Warning: JAVA_HOME environment variable is not set."
+# unzip and move
+if command -v unzip >/dev/null; then
+  unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip"
+else
+  tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar"
 fi
 
-CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
-
-# traverses directory structure from process work directory to filesystem root
-# first directory with .mvn subdirectory is considered project base directory
-find_maven_basedir() {
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+actualDistributionDir=""
 
-  if [ -z "$1" ]
-  then
-    echo "Path not specified to find_maven_basedir"
-    return 1
+# First try the expected directory name (for regular distributions)
+if [ -d "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" ]; then
+  if [ -f "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/bin/$MVN_CMD" ]; then
+    actualDistributionDir="$distributionUrlNameMain"
   fi
+fi
 
-  basedir="$1"
-  wdir="$1"
-  while [ "$wdir" != '/' ] ; do
-    if [ -d "$wdir"/.mvn ] ; then
-      basedir=$wdir
-      break
-    fi
-    # workaround for JBEAP-8937 (on Solaris 10/Sparc)
-    if [ -d "${wdir}" ]; then
-      wdir=`cd "$wdir/.."; pwd`
+# If not found, search for any directory with the Maven executable (for snapshots)
+if [ -z "$actualDistributionDir" ]; then
+  # enable globbing to iterate over items
+  set +f
+  for dir in "$TMP_DOWNLOAD_DIR"/*; do
+    if [ -d "$dir" ]; then
+      if [ -f "$dir/bin/$MVN_CMD" ]; then
+        actualDistributionDir="$(basename "$dir")"
+        break
+      fi
     fi
-    # end of workaround
   done
-  echo "${basedir}"
-}
-
-# concatenates all lines of a file
-concat_lines() {
-  if [ -f "$1" ]; then
-    echo "$(tr -s '\n' ' ' < "$1")"
-  fi
-}
-
-BASE_DIR=`find_maven_basedir "$(pwd)"`
-if [ -z "$BASE_DIR" ]; then
-  exit 1;
+  set -f
 fi
 
-export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
-if [ "$MVNW_VERBOSE" = true ]; then
-  echo $MAVEN_PROJECTBASEDIR
-fi
-MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin; then
-  [ -n "$M2_HOME" ] &&
-    M2_HOME=`cygpath --path --windows "$M2_HOME"`
-  [ -n "$JAVA_HOME" ] &&
-    JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
-  [ -n "$CLASSPATH" ] &&
-    CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
-  [ -n "$MAVEN_PROJECTBASEDIR" ] &&
-    MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
+if [ -z "$actualDistributionDir" ]; then
+  verbose "Contents of $TMP_DOWNLOAD_DIR:"
+  verbose "$(ls -la "$TMP_DOWNLOAD_DIR")"
+  die "Could not find Maven distribution directory in extracted archive"
 fi
 
-WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$actualDistributionDir/mvnw.url"
+mv -- "$TMP_DOWNLOAD_DIR/$actualDistributionDir" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME"
 
-exec "$JAVACMD" \
-  $MAVEN_OPTS \
-  -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
-  "-Dmaven.home=${M2_HOME}" "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
-  ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"
+clean || :
+exec_maven "$@"
diff --git a/mvnw.cmd b/mvnw.cmd
index 48c810ef3..3fd2be860 100644
--- a/mvnw.cmd
+++ b/mvnw.cmd
@@ -1,3 +1,4 @@
+<# : batch portion
 @REM ----------------------------------------------------------------------------
 @REM Licensed to the Apache Software Foundation (ASF) under one
 @REM or more contributor license agreements.  See the NOTICE file
@@ -18,126 +19,171 @@
 @REM ----------------------------------------------------------------------------
 
 @REM ----------------------------------------------------------------------------
-@REM Maven2 Start Up Batch script
-@REM
-@REM Required ENV vars:
-@REM JAVA_HOME - location of a JDK home dir
+@REM Apache Maven Wrapper startup batch script, version 3.3.3
 @REM
 @REM Optional ENV vars
-@REM M2_HOME - location of maven2's installed home dir
-@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
-@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a key stroke before ending
-@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
-@REM     e.g. to debug Maven itself, use
-@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
-@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM   MVNW_REPOURL - repo url base for downloading maven distribution
+@REM   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+@REM   MVNW_VERBOSE - true: enable verbose log; others: silence the output
 @REM ----------------------------------------------------------------------------
 
-@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
-@echo off
-@REM enable echoing my setting MAVEN_BATCH_ECHO to 'on'
-@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
-
-@REM set %HOME% to equivalent of $HOME
-if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
-
-@REM Execute a user defined script before this one
-if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
-@REM check for pre script, once with legacy .bat ending and once with .cmd ending
-if exist "%HOME%\mavenrc_pre.bat" call "%HOME%\mavenrc_pre.bat"
-if exist "%HOME%\mavenrc_pre.cmd" call "%HOME%\mavenrc_pre.cmd"
-:skipRcPre
-
-@setlocal
-
-set ERROR_CODE=0
-
-@REM To isolate internal variables from possible post scripts, we use another setlocal
-@setlocal
-
-@REM ==== START VALIDATION ====
-if not "%JAVA_HOME%" == "" goto OkJHome
-
-echo.
-echo Error: JAVA_HOME not found in your environment. >&2
-echo Please set the JAVA_HOME variable in your environment to match the >&2
-echo location of your Java installation. >&2
-echo.
-goto error
-
-:OkJHome
-if exist "%JAVA_HOME%\bin\java.exe" goto init
-
-echo.
-echo Error: JAVA_HOME is set to an invalid directory. >&2
-echo JAVA_HOME = "%JAVA_HOME%" >&2
-echo Please set the JAVA_HOME variable in your environment to match the >&2
-echo location of your Java installation. >&2
-echo.
-goto error
-
-@REM ==== END VALIDATION ====
-
-:init
-
-@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
-@REM Fallback to current working directory if not found.
-
-set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
-IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
-
-set EXEC_DIR=%CD%
-set WDIR=%EXEC_DIR%
-:findBaseDir
-IF EXIST "%WDIR%"\.mvn goto baseDirFound
-cd ..
-IF "%WDIR%"=="%CD%" goto baseDirNotFound
-set WDIR=%CD%
-goto findBaseDir
-
-:baseDirFound
-set MAVEN_PROJECTBASEDIR=%WDIR%
-cd "%EXEC_DIR%"
-goto endDetectBaseDir
-
-:baseDirNotFound
-set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
-cd "%EXEC_DIR%"
-
-:endDetectBaseDir
-
-IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
-
-@setlocal EnableExtensions EnableDelayedExpansion
-for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
-@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
-
-:endReadAdditionalConfig
-
-SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
-
-set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
-set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
-
-%MAVEN_JAVA_EXE% %JVM_CONFIG_MAVEN_PROPS% %MAVEN_OPTS% %MAVEN_DEBUG_OPTS% -classpath %WRAPPER_JAR% "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
-if ERRORLEVEL 1 goto error
-goto end
-
-:error
-set ERROR_CODE=1
-
-:end
-@endlocal & set ERROR_CODE=%ERROR_CODE%
-
-if not "%MAVEN_SKIP_RC%" == "" goto skipRcPost
-@REM check for post script, once with legacy .bat ending and once with .cmd ending
-if exist "%HOME%\mavenrc_post.bat" call "%HOME%\mavenrc_post.bat"
-if exist "%HOME%\mavenrc_post.cmd" call "%HOME%\mavenrc_post.cmd"
-:skipRcPost
-
-@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
-if "%MAVEN_BATCH_PAUSE%" == "on" pause
-
-if "%MAVEN_TERMINATE_CMD%" == "on" exit %ERROR_CODE%
-
-exit /B %ERROR_CODE%
+@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0)
+@SET __MVNW_CMD__=
+@SET __MVNW_ERROR__=
+@SET __MVNW_PSMODULEP_SAVE=%PSModulePath%
+@SET PSModulePath=
+@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @(
+  IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B)
+)
+@SET PSModulePath=%__MVNW_PSMODULEP_SAVE%
+@SET __MVNW_PSMODULEP_SAVE=
+@SET __MVNW_ARG0_NAME__=
+@SET MVNW_USERNAME=
+@SET MVNW_PASSWORD=
+@IF NOT "%__MVNW_CMD__%"=="" ("%__MVNW_CMD__%" %*)
+@echo Cannot start maven from wrapper >&2 && exit /b 1
+@GOTO :EOF
+: end batch / begin powershell #>
+
+$ErrorActionPreference = "Stop"
+if ($env:MVNW_VERBOSE -eq "true") {
+  $VerbosePreference = "Continue"
+}
+
+# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties
+$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl
+if (!$distributionUrl) {
+  Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+}
+
+switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) {
+  "maven-mvnd-*" {
+    $USE_MVND = $true
+    $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip"
+    $MVN_CMD = "mvnd.cmd"
+    break
+  }
+  default {
+    $USE_MVND = $false
+    $MVN_CMD = $script -replace '^mvnw','mvn'
+    break
+  }
+}
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+if ($env:MVNW_REPOURL) {
+  $MVNW_REPO_PATTERN = if ($USE_MVND -eq $False) { "/org/apache/maven/" } else { "/maven/mvnd/" }
+  $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace "^.*$MVNW_REPO_PATTERN",'')"
+}
+$distributionUrlName = $distributionUrl -replace '^.*/',''
+$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$',''
+
+$MAVEN_M2_PATH = "$HOME/.m2"
+if ($env:MAVEN_USER_HOME) {
+  $MAVEN_M2_PATH = "$env:MAVEN_USER_HOME"
+}
+
+if (-not (Test-Path -Path $MAVEN_M2_PATH)) {
+    New-Item -Path $MAVEN_M2_PATH -ItemType Directory | Out-Null
+}
+
+$MAVEN_WRAPPER_DISTS = $null
+if ((Get-Item $MAVEN_M2_PATH).Target[0] -eq $null) {
+  $MAVEN_WRAPPER_DISTS = "$MAVEN_M2_PATH/wrapper/dists"
+} else {
+  $MAVEN_WRAPPER_DISTS = (Get-Item $MAVEN_M2_PATH).Target[0] + "/wrapper/dists"
+}
+
+$MAVEN_HOME_PARENT = "$MAVEN_WRAPPER_DISTS/$distributionUrlNameMain"
+$MAVEN_HOME_NAME = ([System.Security.Cryptography.SHA256]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join ''
+$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME"
+
+if (Test-Path -Path "$MAVEN_HOME" -PathType Container) {
+  Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
+  exit $?
+}
+
+if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) {
+  Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl"
+}
+
+# prepare tmp dir
+$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile
+$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
+$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
+trap {
+  if ($TMP_DOWNLOAD_DIR.Exists) {
+    try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+    catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+  }
+}
+
+New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null
+
+# Download and Install Apache Maven
+Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+Write-Verbose "Downloading from: $distributionUrl"
+Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+$webclient = New-Object System.Net.WebClient
+if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) {
+  $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD)
+}
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum
+if ($distributionSha256Sum) {
+  if ($USE_MVND) {
+    Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties."
+  }
+  Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash
+  if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) {
+    Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property."
+  }
+}
+
+# unzip and move
+Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+$actualDistributionDir = ""
+
+# First try the expected directory name (for regular distributions)
+$expectedPath = Join-Path "$TMP_DOWNLOAD_DIR" "$distributionUrlNameMain"
+$expectedMvnPath = Join-Path "$expectedPath" "bin/$MVN_CMD"
+if ((Test-Path -Path $expectedPath -PathType Container) -and (Test-Path -Path $expectedMvnPath -PathType Leaf)) {
+  $actualDistributionDir = $distributionUrlNameMain
+}
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if (!$actualDistributionDir) {
+  Get-ChildItem -Path "$TMP_DOWNLOAD_DIR" -Directory | ForEach-Object {
+    $testPath = Join-Path $_.FullName "bin/$MVN_CMD"
+    if (Test-Path -Path $testPath -PathType Leaf) {
+      $actualDistributionDir = $_.Name
+    }
+  }
+}
+
+if (!$actualDistributionDir) {
+  Write-Error "Could not find Maven distribution directory in extracted archive"
+}
+
+Write-Verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+Rename-Item -Path "$TMP_DOWNLOAD_DIR/$actualDistributionDir" -NewName $MAVEN_HOME_NAME | Out-Null
+try {
+  Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null
+} catch {
+  if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) {
+    Write-Error "fail to move MAVEN_HOME"
+  }
+} finally {
+  try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+  catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+}
+
+Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
diff --git a/pom.xml b/pom.xml
index cb54af9a0..b8320ef8f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -2,18 +2,66 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.microsoft.java</groupId>
-    <artifactId>parent</artifactId>
+    <artifactId>java-debug-parent</artifactId>
     <name>${base.name} :: Parent</name>
-    <version>0.1.0</version>
+    <description>The Java Debug Server is an implementation of Visual Studio Code (VSCode) Debug Protocol. It can be used in Visual Studio Code to debug Java programs.</description>
+    <url>https://github.com/Microsoft/java-debug</url>
+    <version>0.53.2</version>
     <packaging>pom</packaging>
     <properties>
         <base.name>Java Debug Server for Visual Studio Code</base.name>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <tycho-version>1.0.0</tycho-version>
+        <tycho-version>5.0.0</tycho-version>
+        <checkstyleDir>${basedir}</checkstyleDir>
     </properties>
+
+    <licenses>
+        <license>
+            <name>Eclipse Public License 1.0</name>
+            <url>https://github.com/Microsoft/java-debug/blob/master/LICENSE.txt</url>
+            <distribution>repo</distribution>
+        </license>
+    </licenses>
+
+    <developers>
+        <developer>
+            <id>akaroml</id>
+            <name>Rome Li</name>
+            <email>roml@microsoft.com</email>
+        </developer>
+        <developer>
+            <id>testforstephen</id>
+            <name>Jinbo Wang</name>
+            <email>jinbwan@microsoft.com</email>
+        </developer>
+        <developer>
+            <id>andxu</id>
+            <name>Andy Xu</name>
+            <email>andxu@microsoft.com</email>
+        </developer>
+        <developer>
+            <id>yaohaizh</id>
+            <name>Yaohai Zheng</name>
+            <email>yaozheng@microsoft.com</email>
+        </developer>
+    </developers>
+
+    <organization>
+        <name>Microsoft</name>
+        <url>https://www.microsoft.com</url>
+    </organization>
+
+    <scm>
+        <connection>scm:git:git://github.com/Microsoft/java-debug.git</connection>
+        <developerConnection>scm:git:ssh://github.com:Microsoft/java-debug.git</developerConnection>
+        <url>https://github.com/Microsoft/java-debug/tree/master</url>
+    </scm>
+
     <modules>
         <module>com.microsoft.java.debug.core</module>
         <module>com.microsoft.java.debug.plugin</module>
+        <module>com.microsoft.java.debug.repository</module>
+        <module>com.microsoft.java.debug.target</module>
     </modules>
     <build>
         <pluginManagement>
@@ -66,21 +114,12 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-checkstyle-plugin</artifactId>
-                    <version>2.17</version>
-                    <executions>
-                        <execution>
-                            <id>validate</id>
-                            <phase>validate</phase>
-                            <goals>
-                                <goal>check</goal>
-                            </goals>
-                        </execution>
-                    </executions>
+                    <version>3.1.0</version>
                     <dependencies>
                         <dependency>
                             <groupId>com.puppycrawl.tools</groupId>
                             <artifactId>checkstyle</artifactId>
-                            <version>8.0</version>
+                            <version>8.29</version>
                         </dependency>
                         <dependency>
                             <groupId>com.github.sevntu-checkstyle</groupId>
@@ -89,8 +128,7 @@
                         </dependency>
                     </dependencies>
                     <configuration>
-                        <configLocation>${project.parent.basedir}/check_style.xml</configLocation>
-                        <propertyExpansion>basedir=${project.parent.basedir}</propertyExpansion>
+                        <configLocation>${checkstyleDir}/check_style.xml</configLocation>
                         <failOnViolation>true</failOnViolation>
                     </configuration>
                 </plugin>
@@ -98,16 +136,42 @@
                     <groupId>org.eclipse.tycho</groupId>
                     <artifactId>target-platform-configuration</artifactId>
                     <version>${tycho-version}</version>
+                    <configuration>
+                        <resolver>p2</resolver>
+                        <target>
+                            <artifact>
+                                <groupId>com.microsoft.java</groupId>
+                                <artifactId>com.microsoft.java.debug.tp</artifactId>
+                                <version>${project.version}</version>
+                            </artifact>
+                        </target>
+                    </configuration>
                 </plugin>
             </plugins>
         </pluginManagement>
+        <plugins>
+            <plugin>
+                <groupId>org.eclipse.tycho</groupId>
+                <artifactId>tycho-maven-plugin</artifactId>
+                <version>${tycho-version}</version>
+                <extensions>true</extensions>
+            </plugin>
+        </plugins>
     </build>
+    <profiles>
+        <profile>
+            <id>activate-in-module</id>
+            <activation>
+                <file>
+                    <exists>${basedir}/../check_style.xml</exists>
+                </file>
+            </activation>
+            <properties>
+                <checkstyleDir>${basedir}/..</checkstyleDir>
+            </properties>
+        </profile>
+    </profiles>
     <repositories>
-        <repository>
-            <id>oxygen</id>
-            <layout>p2</layout>
-            <url>http://download.eclipse.org/releases/oxygen</url>
-        </repository>
         <repository>
             <id>oss.sonatype.org</id>
             <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
@@ -115,10 +179,5 @@
                 <enabled>true</enabled>
             </snapshots>
         </repository>
-        <repository>
-            <id>JDT.LS</id>
-            <layout>p2</layout>
-            <url>http://download.eclipse.org/jdtls/snapshots/repository/latest/</url>
-        </repository>
     </repositories>
-</project>
\ No newline at end of file
+</project>
diff --git a/scripts/publishMaven.js b/scripts/publishMaven.js
new file mode 100644
index 000000000..deb75fb8b
--- /dev/null
+++ b/scripts/publishMaven.js
@@ -0,0 +1,298 @@
+/**
+ * Usage:
+ * node publishMaven.js -task [gpg][upload|promote]
+ * 
+ * gpg: Sign artifacts with GPG.
+ * upload: Upload artifacts to a nexus staging repo.
+ * promote: Promote a repo to get it picked up by Maven Central.
+ */
+
+const childProcess = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const artifactFolder = process.env.artifactFolder;
+const configs = {
+    nexus_ossrhuser: process.env.NEXUS_OSSRHUSER,
+    nexus_ossrhpass: process.env.NEXUS_OSSRHPASS,
+    nexus_stagingProfileId: process.env.NEXUS_STAGINGPROFILEID,
+    gpgpass: process.env.GPGPASS,
+    stagingRepoId: process.env.NEXUS_STAGINGREPOID,
+    groupId: "com.microsoft.java",
+    projectName: "java-debug",
+    releaseVersion: process.env.releaseVersion,    
+    moduleNames: [
+        "java-debug-parent",
+        "com.microsoft.java.debug.core",
+        "com.microsoft.java.debug.plugin"
+    ],
+    artifactFolder: artifactFolder
+};
+
+main(configs, artifactFolder);
+
+function main() {
+    const argv = process.argv;
+    const task = argv[argv.indexOf("-task") + 1];
+    if (task === "gpg") {
+        gpgSign(configs, artifactFolder);
+    } else if (task === "upload") {
+        uploadToStaging(configs, artifactFolder);
+    } else if (task === "promote") {
+        promoteToCentral(configs);
+    } else {
+        console.error("Task not specified.");
+        console.log("Usage: node script.js -task [upload|promote]");
+    }
+}
+
+/**
+ * Task gpg: Sign artifacts with GPG.
+ * 
+ * Required binaries:
+ * - gpg
+ * 
+ * Required Environment Variables:
+ * - artifactFolder: folder containing *.jar/*.pom files.
+ * - GPGPASS: passphrase of GPG key.
+ */
+function gpgSign(configs, artifactFolder) {
+    const props = ["artifactFolder", "gpgpass" ];
+    for (const prop of props) {
+        if (!configs[prop]) {
+            console.error(`${prop} is not set.`);
+            process.exit(1);
+        }
+    }
+    addChecksumsAndGpgSignature(configs, artifactFolder);
+}
+
+/**
+ * Task upload: Upload artifacts to a nexus staging repo.
+ * 
+ * Required binaries:
+ * - gpg
+ * - curl
+ * 
+ * Required Environment Variables:
+ * - artifactFolder: folder containing *.jar/*.pom files.
+ * - releaseVersion: version of artifacts.
+ * - NEXUS_OSSRHUSER: username.
+ * - NEXUS_OSSRHPASS: password.
+ * - NEXUS_STAGINGPROFILEID: identifier of the repo to promote.
+ * - GPGPASS: passphrase of GPG key.
+ */
+function uploadToStaging(configs, artifactFolder) {
+    checkPrerequisite(configs);
+    addChecksumsAndGpgSignature(configs, artifactFolder);
+    createStagingRepo(configs);
+    deployToStagingRepo(configs, artifactFolder);
+    closeStagingRepo(configs);
+}
+
+ /**
+ * Task promote: Promote a repo to get it picked up by Maven Central.
+ * 
+ * Required binaries:
+ * - curl
+ * 
+ * Required Environment Variables:
+ * - NEXUS_OSSRHUSER: username.
+ * - NEXUS_OSSRHPASS: password.
+ * - NEXUS_STAGINGPROFILEID: identifier of the repo to promote.
+ * - NEXUS_STAGINGREPOID: id of staging repo with artifacts to promote.
+ */
+function promoteToCentral(configs) {
+    let message = "";
+    console.log("\n========Nexus: Promote=======");
+    try {
+        console.log(`Starting to promote staging repository ${configs.stagingRepoId} ...`);
+        console.log(`curl -i -X POST -d "<promoteRequest><data><stagedRepositoryId>${configs.stagingRepoId}</stagedRepositoryId></data></promoteRequest>" -H "Content-Type: application/xml" -u **:** -k https://oss.sonatype.org/service/local/staging/profiles/${configs.nexus_stagingProfileId}/promote`);
+        message = childProcess.execSync(`curl -i -X POST -d "<promoteRequest><data><stagedRepositoryId>${configs.stagingRepoId}</stagedRepositoryId></data></promoteRequest>" -H "Content-Type: application/xml" -u ${configs.nexus_ossrhuser}:${configs.nexus_ossrhpass} -k https://oss.sonatype.org/service/local/staging/profiles/${configs.nexus_stagingProfileId}/promote`);
+        message = message.toString();
+        console.log(message);
+    } catch (ex) {
+        console.error("\n\n[Failure] Promoting staging repository failed.");
+        console.error(!message ? ex : message.toString());
+        process.exit(1);
+    }
+    const success = isReleased(configs);
+    console.log("Below is the public repository url, you could manually validate it.");
+    console.log(`https://oss.sonatype.org/content/groups/public/${configs.groupId.replace(/\./g, "/")}`);
+    console.log("\n\n");
+    if (success) {
+        console.log("\n\n[Success] Nexus: Promote succeeded.");
+    } else {
+        console.error("\n\n[Failure] Nexus: Promote failed.");
+        process.exit(1)
+    }
+}
+
+function isReleased(configs) {
+    let pollingCount = 0;
+    const MAX_POLLINGS = 10;
+    for (; pollingCount < MAX_POLLINGS; pollingCount++) {
+        console.log(`\nPolling the release operation finished or not...`);
+        console.log(`curl -X GET -H "Content-Type:application/xml" -u **:** -k https://oss.sonatype.org/service/local/staging/repository/${configs.stagingRepoId}`);
+        message = childProcess.execSync(`curl -X GET -H "Content-Type:application/xml" -u ${configs.nexus_ossrhuser}:${configs.nexus_ossrhpass} -k https://oss.sonatype.org/service/local/staging/repository/${configs.stagingRepoId}`);
+        const status = extractStatus(message.toString());
+        console.log(status);
+        if (status !== "closed") {
+            return true;
+        }
+        // use system sleep command to pause the program.
+        childProcess.execSync(`sleep 6s`);
+    }
+    return false;
+}
+
+function checkPrerequisite(configs) {
+    const props = ["releaseVersion", "artifactFolder", "nexus_ossrhuser", "nexus_ossrhpass", "nexus_stagingProfileId", "gpgpass" ];
+    for (const prop of props) {
+        if (!configs[prop]) {
+            console.error(`${prop} is not set.`);
+            process.exit(1);
+        }
+    }
+}
+
+function addChecksumsAndGpgSignature(configs, artifactFolder) {
+    console.log("\n=======Checksum and gpg sign=======");
+    console.log("Starting to calculate checksum and gpg sign...");
+    for (let moduleName of configs.moduleNames) {
+        const modulePath = path.join(artifactFolder, moduleName);
+        // remove old md5/sha1/asc files.
+        fs.readdirSync(modulePath)
+            .filter(name => name.endsWith(".md5") || name.endsWith(".sha1") || name.endsWith(".asc"))
+            .forEach(name => fs.unlinkSync(path.join(modulePath, name)));
+
+        const files = fs.readdirSync(modulePath);
+        for (let file of files) {
+            // calc md5.
+            const md5 = childProcess.execSync(`md5sum "${path.join(modulePath, file)}"`);
+            const md5Match = /([a-z0-9]{32})/.exec(md5.toString());
+            fs.writeFileSync(path.join(modulePath, file + ".md5"), md5Match[0]);
+
+            // calc sha1.
+            const sha1 = childProcess.execSync(`sha1sum "${path.join(modulePath, file)}"`);
+            const sha1Match = /([a-z0-9]{40})/.exec(sha1.toString());
+            fs.writeFileSync(path.join(modulePath, file + ".sha1"), sha1Match[0]);
+
+            // gpg sign.
+            childProcess.execSync(`gpg --batch --pinentry-mode loopback --passphrase "${configs.gpgpass}" -ab "${path.join(modulePath, file)}"`)
+        }
+    }
+    console.log("\n\n[Success] Checksum and gpg sign finished.");
+    console.log("\n\n");
+}
+
+function createStagingRepo(configs) {
+    let message = "";
+    console.log("\n=======Nexus: Create staging repo=======");
+    console.log("Starting to create staging repository...");
+    try {
+        console.log(`curl -X POST -d "<promoteRequest><data><description>${configs.projectName}-${configs.releaseVersion}</description></data></promoteRequest>" -H "Content-Type: application/xml" -u **:** -k https://oss.sonatype.org/service/local/staging/profiles/${configs.nexus_stagingProfileId}/start`);
+        message = childProcess.execSync(`curl -X POST -d "<promoteRequest><data><description>${configs.projectName}-${configs.releaseVersion}</description></data></promoteRequest>" -H "Content-Type: application/xml" -u ${configs.nexus_ossrhuser}:${configs.nexus_ossrhpass} -k https://oss.sonatype.org/service/local/staging/profiles/${configs.nexus_stagingProfileId}/start`);
+        message = message.toString();
+        const match = /<stagedRepositoryId>([a-zA-Z0-9-_]+)<\/stagedRepositoryId>/.exec(message);
+        if (match != null && match.length > 1) {
+            configs.stagingRepoId = match[1];
+        } else {
+            console.error("\n[Failure] Creating staging repository failed.");
+            console.error(message);
+            process.exit(1);
+        }
+    } catch (ex) {
+        console.error("\n[Failure] Creating staging repository failed.");
+        console.error(!message ? ex : message.toString());
+        process.exit(1);
+    }
+    console.log("\n\n[Success] Nexus: Creating staging repository completion.");
+    console.log("staging repository id: " + configs.stagingRepoId);
+    console.log("\n\n");
+}
+
+function deployToStagingRepo(configs, artifactFolder) {
+    console.log("\n========Nexus: Deploy artifacts to staging repo=======");
+    console.log("Starting to deploy artifacts to staging repository...");
+    for (let moduleName of configs.moduleNames) {
+        const modulePath = path.join(artifactFolder, moduleName);
+        for (let file of fs.readdirSync(modulePath)) {
+            const realPath = path.join(modulePath, file);
+            const url = [
+                "https://oss.sonatype.org/service/local/staging/deployByRepositoryId",
+                configs.stagingRepoId,
+                configs.groupId.replace(/\./g, "/"),
+                moduleName,
+                configs.releaseVersion,
+                file
+            ];
+            console.log(`curl --upload-file "${realPath}" -u **:** -k ${url.join("/")}`);
+            message = childProcess.execSync(`curl --upload-file "${realPath}" -u ${configs.nexus_ossrhuser}:${configs.nexus_ossrhpass} -k ${url.join("/")}`);
+            message = message.toString();
+            console.log(message);
+            console.log("Succeeded.\n");
+        }
+    }
+    console.log("\n\n[Success] Nexus: Deploying completion.");
+    console.log("\n\n");
+}
+
+function closeStagingRepo(configs) {
+    let message = "";
+    let pollingCount = 0;
+    const MAX_POLLINGS = 10;
+    console.log("\n========Nexus: Verify and Close staging repo=======");
+    try {
+        console.log(`Starting to close staging repository ${configs.stagingRepoId} ...`);
+        console.log(`curl -X POST -d "<promoteRequest><data><stagedRepositoryId>${configs.stagingRepoId}</stagedRepositoryId></data></promoteRequest>" -H "Content-Type: application/xml" -u **:** -k https://oss.sonatype.org/service/local/staging/profiles/${configs.nexus_stagingProfileId}/finish`);
+        message = childProcess.execSync(`curl -X POST -d "<promoteRequest><data><stagedRepositoryId>${configs.stagingRepoId}</stagedRepositoryId></data></promoteRequest>" -H "Content-Type: application/xml" -u ${configs.nexus_ossrhuser}:${configs.nexus_ossrhpass} -k https://oss.sonatype.org/service/local/staging/profiles/${configs.nexus_stagingProfileId}/finish`);
+        message = message.toString();
+
+        for (; pollingCount < MAX_POLLINGS; pollingCount++) {
+            console.log(`\nPolling the close operation finished or not...`);
+            console.log(`curl -X GET -H "Content-Type:application/xml" -u **:** -k https://oss.sonatype.org/service/local/staging/repository/${configs.stagingRepoId}`);
+            message = childProcess.execSync(`curl -X GET -H "Content-Type:application/xml" -u ${configs.nexus_ossrhuser}:${configs.nexus_ossrhpass} -k https://oss.sonatype.org/service/local/staging/repository/${configs.stagingRepoId}`);
+            // console.log(message.toString());
+            if (extractStatus(message.toString()) === "closed") {
+                break;
+            }
+            // use system sleep command to pause the program.
+            childProcess.execSync(`sleep 6s`);
+        }
+
+        if (pollingCount >= MAX_POLLINGS) {
+            console.log("\nQuerying the close operation result...");
+            message = childProcess.execSync(`curl -X GET -H "Content-Type:application/xml" -u ${configs.nexus_ossrhuser}:${configs.nexus_ossrhpass} -k https://oss.sonatype.org/service/local/staging/repository/${configs.stagingRepoId}/activity`);
+            // console.log(message.toString());
+            const errors = extractErrorMessage(message.toString());
+            console.error(`\n\n[Failure] Closing staging repository failed.`);
+            console.error(`See failure messages:`);
+            console.error(errors.join("\n\n"));
+            process.exit(1);
+        }
+    } catch (ex) {
+        console.error("\n\n[Failure] Closing staging repository failed.");
+        console.error(!message ? ex : message.toString());
+        process.exit(1);
+    }
+    fs.writeFileSync(".stagingRepoId", configs.stagingRepoId);
+    console.log("\n\n[Success] Nexus: Staging completion.");
+    console.log("Below is the staging repository url, you could use it to test deployment.");
+    console.log(`https://oss.sonatype.org/content/repositories/${configs.stagingRepoId}`);
+    console.log("\n\n");
+}
+
+function extractStatus(message) {
+    const group = /<type>([a-zA-Z0-9-_\.]+)<\/type>/.exec(message);
+    return group[1];
+}
+
+function extractErrorMessage(message) {
+    const errors = [];
+    const group = message.match(/<name>failureMessage<\/name>[\r?\n ]+<value>(.*)<\/value>/g);
+    for (let error of group) {
+        errors.push(error.match(/<value>(.*)<\/value>/)[1])
+    }
+    return errors;
+}