Copilot-generated PR review code suggestions ("Suggest" changesets) are not returned by pull_request_read or any API

[VooDisss]

Describe the feature or problem you'd like to solve

When GitHub Copilot reviews a pull request, it generates two distinct types of content per review comment:

1. Prose commentary — a text description of the issue found (e.g., "Consider adding pydantic validation...")
2. Suggested code changesets — concrete, committable code diffs rendered with a green "Commit suggestion" / "Add to batch" button in the GitHub web UI

Currently, the pull_request_read tool (method: get_review_comments) and the underlying GitHub REST + GraphQL APIs only return the prose commentary in the comment body field. The suggested code changesets that Copilot generates — the ones visible in the GitHub web UI with the "Commit suggestion" button — are completely absent from all API responses.

This means MCP-connected AI agents cannot:

• Read Copilot's actual code suggestions to evaluate their correctness
• Programmatically accept, reject, or modify Copilot's suggested changes
• Build automated workflows that triage Copilot review suggestions
• Provide informed assessments of whether a Copilot suggestion should be committed

Exhaustive investigation proving the data is missing

I performed a thorough investigation across every available API surface to confirm this is not a client-side issue. The test PR used: zai-org/GLM-OCR#131 — Copilot generated 9 review comments, each with a visible "Suggest" code changeset in the GitHub web UI.

1. GitHub MCP Server — pull_request_read with get_review_comments

Using the official github/github-mcp-server (Docker, ghcr.io/github/github-mcp-server), I called:

pull_request_read(method="get_review_comments", owner="zai-org", repo="GLM-OCR", pullNumber=131)

Result: All 9 review threads returned with prose-only body fields. Zero suggestion blocks.

2. REST API — GET /repos/{owner}/{repo}/pulls/{pull_number}/comments

gh api repos/zai-org/GLM-OCR/pulls/131/comments --paginate --jq ".[].body"

Result: All 9 comment bodies are plain prose text. No ```suggestion ``` markdown blocks present.

3. GraphQL API — body and bodyHTML fields on PullRequestReviewComment

{
  repository(owner: "zai-org", name: "GLM-OCR") {
    pullRequest(number: 131) {
      reviewThreads(first: 15) {
        nodes {
          comments(first: 5) {
            nodes {
              body
              bodyHTML
              author { login }
            }
          }
        }
      }
    }
  }
}

Result: Both body and bodyHTML contain only prose. Checked every Copilot comment:

{"has_suggestion_in_body": false, "has_suggestion_in_html": false}
// ... repeated for all 9 comments

4. GraphQL — suggestedChanges field

Attempted to query suggestedChanges on PullRequestReviewComment:

suggestedChanges(first: 5) {
  nodes { suggestion, originalStartLine, originalEndLine }
}

Result: Field 'suggestedChanges' doesn't exist on type 'PullRequestReviewComment'

5. Community MCP server (@modelcontextprotocol/server-github)

Also tested with the community npm-based server — identical results: prose only, no suggestion code blocks.

What the GitHub web UI shows vs what the API returns

In the GitHub web UI, each Copilot review comment has two sections:

• The prose text (e.g., "This test module is collected by default...")
• A "Suggest" panel with a green-highlighted code diff and "Commit suggestion" / "Add to batch" buttons

Through any API, only the prose text is returned. The suggested code changeset is completely absent. It appears these suggestion diffs are either:

• Rendered client-side by GitHub's UI JavaScript and never persisted as part of the comment body
• Stored in a proprietary Copilot-internal data structure not exposed through any public API
• Attached to the comment via a mechanism that has no corresponding REST/GraphQL field

This is fundamentally different from human-written suggestions, which use ```suggestion ``` markdown syntax embedded directly in the comment body and ARE returned by all APIs.

Proposed solution

Expose Copilot's generated code suggestions through the API so that MCP-connected agents can read them. This could take several forms:

Option A (Preferred): Include suggestion blocks in the comment body

Store Copilot's suggestions as standard ```suggestion ``` markdown in the comment body, identical to how human-written suggestions work. This would require zero API changes — the existing body field would just contain the full content.

Option B: Add a suggestedChanges field to PullRequestReviewComment in GraphQL

type PullRequestReviewComment {
  # ... existing fields ...
  suggestedChanges: SuggestedChangeConnection
}

type SuggestedChange {
  suggestion: String!       # The suggested replacement code
  originalStartLine: Int!   # Start line in the diff
  originalEndLine: Int!     # End line in the diff
  path: String!             # File path
}

Then the MCP server's pull_request_read (method: get_review_comments) could include these in its response.

Option C: Add a REST API field

Add a suggested_changes array to the review comment REST response:

{
  "id": 2951701990,
  "body": "This test module is collected by default...",
  "suggested_changes": [
    {
      "original_start_line": 1,
      "original_end_line": 15,
      "suggestion": "import pytest\n\npytest.importorskip(\n    \"torch\",\n    reason=\"...\",\n)\n..."
    }
  ]
}

Example prompts or workflows (for tools/toolsets only)

1. Evaluate Copilot suggestions before committing

"Fetch all of Copilot's review comments on PR #131 including their suggested code changes, and tell me which ones are safe to commit"

Agent reads review threads with suggestion diffs, analyzes each suggestion against the codebase context, and provides a recommendation per suggestion.

2. Batch-commit safe suggestions

"For each Copilot suggestion on this PR, if it's a pure import guard or test marker change, commit it automatically"

Agent reads suggestions, filters by category, and commits the safe ones via add_comment_to_pending_review or the suggestions API.

3. Generate counter-suggestions

"Read Copilot's suggested changes and propose alternative implementations where you disagree"

Agent reads the actual code diffs Copilot proposed, compares with its own analysis, and replies with alternative ```suggestion ``` blocks.

4. Audit Copilot review quality

"Compare what Copilot suggested vs what the codebase actually needs and rate each suggestion"

Agent needs both the prose rationale AND the concrete code change to evaluate correctness. Currently only the prose is available.

Additional context

Scope of the problem:
This affects ALL Copilot-generated PR reviews. Every time Copilot reviews a PR and generates "Suggest" changesets (which is the majority of Copilot reviews), those changesets are invisible to any API consumer. Only the prose description is accessible.

Note: This issue is upstream of the MCP server — it's fundamentally a GitHub platform/API limitation. The MCP server correctly returns everything the GitHub API provides. However, filing here because:

1. The MCP server is the primary interface AI agents use to interact with GitHub
2. The MCP server team has direct access to internal GitHub APIs and could surface this data even if the public REST/GraphQL APIs don't expose it yet
3. This is a critical gap for the "AI agents reviewing code" workflow that the MCP server is designed to enable

Affected version:

github-mcp-server latest (ghcr.io/github/github-mcp-server:latest)
Docker image digest: sha256:a9dd39eec67f09ded51631c79641dd72acb4945c6391df47824fa2d508b5431b

Environment:

• Docker 28.5.1 on Windows 11
• GitHub token: OAuth (gho_***) with scopes gist, read:org, repo, workflow
• Also tested with community @modelcontextprotocol/server-github via npx

Reference PR used for testing: zai-org/GLM-OCR#131 (9 Copilot review comments, all with "Suggest" changesets visible in web UI, none returned via API)

[VooDisss]

Workaround: Extracting Copilot suggestion changesets via Playwright MCP browser automation

While this issue remains open, I found a working workaround that lets MCP-connected AI agents read Copilot's suggested code changesets by scraping them from the rendered GitHub web UI using Microsoft's Playwright MCP server (microsoft/playwright-mcp).

Since the suggestion diffs are rendered client-side by GitHub's JavaScript but never exposed through any API, the only reliable way to access them today is through a real browser.

Why this works

The Copilot suggestion changesets do exist in the DOM once the page renders. Specifically:

• Each unresolved Copilot review thread contains a .js-suggested-changes-contents element with a full diff table
• The diff table has standard <tr> rows with three <td> cells: old line number, new line number, and code content (with +/- prefixes for additions/removals)
• Resolved threads use deferred loading (data-resolved="true" + data-deferred-details-content-url) — their content isn't in the DOM until you click "Show resolved"

Setup

Add the Playwright MCP server to your MCP client config. Example for OpenCode:

{
  "mcp": {
    "playwright": {
      "type": "local",
      "command": ["npx", "-y", "@playwright/mcp", "--browser", "chromium"],
      "enabled": true
    }
  }
}

For Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp", "--browser", "chromium"]
    }
  }
}

Note: You need Chromium installed for Playwright. Run npx playwright install chromium if the browser is missing.

Extraction method

Once your agent has access to the Playwright MCP tools, instruct it to:

1. Navigate to the PR's Files Changed tab (e.g., https://github.com/{owner}/{repo}/pull/{number}/files)
2. Run JavaScript via browser_evaluate to extract suggestion data from the DOM

The following JavaScript extracts all unresolved Copilot suggestion changesets:

() => {
  const threads = document.querySelectorAll('.js-resolvable-timeline-thread-container');
  const results = [];

  threads.forEach((thread, idx) => {
    // Skip resolved (deferred/lazy-loaded) threads
    const grandParent = thread.parentElement?.parentElement;
    const isResolved = grandParent?.querySelector('details[data-resolved="true"]') !== null;
    if (isResolved) return;

    // Get file path
    const fileEl = thread.closest('[data-file-path]');
    const filePath = fileEl ? fileEl.getAttribute('data-file-path') : 'unknown';

    // Get prose commentary
    const commentBody = thread.querySelector('.comment-body, .markdown-body');
    const prose = commentBody ? commentBody.innerText.trim() : '';

    // Get suggestion changeset diff
    const suggestionContainer = thread.querySelector('.js-suggested-changes-contents');
    let suggestionDiff = '';
    if (suggestionContainer) {
      const rows = suggestionContainer.querySelectorAll('table tr');
      const diffLines = [];
      rows.forEach(row => {
        const cells = row.querySelectorAll('td');
        if (cells.length >= 3) {
          const oldLine = cells[0]?.textContent?.trim() || '';
          const newLine = cells[1]?.textContent?.trim() || '';
          const code = cells[2]?.textContent?.trim() || '';
          diffLines.push(`${oldLine}\t${newLine}\t${code}`);
        }
      });
      suggestionDiff = diffLines.join('\n');
    }

    if (prose || suggestionDiff) {
      results.push({
        index: idx + 1,
        filePath,
        prose,
        suggestionDiff
      });
    }
  });

  return JSON.stringify(results, null, 2);
}

Verified results

I tested this against the same PR referenced in this issue (zai-org/GLM-OCR#131). The PR has 9 Copilot review threads total: 4 resolved, 5 unresolved.

All 5 unresolved suggestion changesets were successfully extracted, including:

#	File	What Copilot suggested
1	glmocr/tests/test_layout_device.py	Add @pytest.mark.skipif + env var gate (GLMOCR_RUN_LAYOUT_REAL_TESTS) around slow real-model tests
2	glmocr/tests/test_layout_device.py	Replace strict cross-device assertions with basic invariants + opt-in strict mode (GLMOCR_STRICT_DEVICE_CONSISTENCY)
3	glmocr/tests/test_layout_device.py	Gate benchmark test behind RUN_LAYOUT_BENCHMARKS env var
4	glmocr/cli.py	Add layout_device_type() validator function + change type=str to type=layout_device_type on --layout-device
5	glmocr/config.py	Add @field_validator("device") pydantic validator to LayoutConfig

Each extraction included the full diff with old/new line numbers and +/- code lines — the exact same content shown in the green "Commit suggestion" panels in the web UI.

The 4 resolved threads were correctly identified as resolved (they have data-resolved="true" on their <details> wrapper and their content is deferred/lazy-loaded).

Limitations

• Authentication required for private repos. Playwright MCP launches a fresh Chromium instance. For private repos, you'd need to either pass --user-data-dir pointing to a Chrome profile that's already logged into GitHub, or have the agent navigate to the login page first. Public repos work without authentication.
• Resolved threads require an extra click. Resolved/collapsed threads use deferred loading — their suggestion content isn't in the DOM until you click "Show resolved." The agent can click those buttons to expand them if needed.
• DOM selectors may break. GitHub can change their CSS class names and DOM structure at any time. The .js-suggested-changes-contents selector works as of March 2026, but may need updating in the future.
• Not a substitute for a proper API. This is a workaround, not a solution. The right fix is still one of the options proposed in this issue (embedding suggestions in the comment body, adding a GraphQL field, or adding a REST field).

Why Playwright MCP specifically

MCP Server	How it helps	Stars
@playwright/mcp	Official Microsoft server. browser_navigate + browser_evaluate for targeted JS extraction. Deterministic, fast.	29k+
mcp-browser-use	Higher-level autonomous browser agent. Works but slower (AI decision loop).	900+
webpage-mcp	Chrome extension approach — reuses your existing authenticated Chrome session. Good for private repos.	New

Playwright MCP is the most reliable option because browser_evaluate lets you run exact JavaScript against the page DOM rather than relying on accessibility snapshots or AI-interpreted screenshots.

Bottom line

Until GitHub exposes Copilot suggestion changesets through the API (any of Options A/B/C from this issue), Playwright MCP + DOM scraping is a viable workaround for MCP-connected agents that need to read, evaluate, or act on Copilot's code suggestions.